@foxford/qr-code 1.1.0

package/index.cjs

@@ -0,0 +1,1438 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  QRCode: () => QRCode,
+  renderQr: () => renderQr
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/ecc.ts
+var _Ecc = class _Ecc {
+  // QR-код может выдержать около 30% ошибочных кодовых слов
+  constructor(ordinal, formatBits) {
+    this.ordinal = ordinal;
+    this.formatBits = formatBits;
+  }
+};
+_Ecc.LOW = new _Ecc(0, 1);
+// QR-код может выдержать около 7% ошибочных кодовых слов
+_Ecc.MEDIUM = new _Ecc(1, 0);
+// QR-код может выдержать около 15% ошибочных кодовых слов
+_Ecc.QUARTILE = new _Ecc(2, 3);
+// QR-код может выдержать около 25% ошибочных кодовых слов
+_Ecc.HIGH = new _Ecc(3, 2);
+var Ecc = _Ecc;
+
+// src/lib/mode.ts
+var _Mode = class _Mode {
+  constructor(modeBits, numBitsCharCount) {
+    this.modeBits = modeBits;
+    this.numBitsCharCount = numBitsCharCount;
+  }
+  // (Package-private) Возвращает битовую ширину поля счетчика символов для сегмента в
+  // этом режиме в QR-коде с заданным номером версии. Результат находится в диапазоне [0, 16].
+  numCharCountBits(ver) {
+    const result = this.numBitsCharCount[Math.floor((ver + 7) / 17)];
+    if (result === void 0) throw new Error("Assertion Error");
+    return result;
+  }
+};
+_Mode.NUMERIC = new _Mode(1, [10, 12, 14]);
+_Mode.ALPHANUMERIC = new _Mode(2, [9, 11, 13]);
+_Mode.BYTE = new _Mode(4, [8, 16, 16]);
+_Mode.KANJI = new _Mode(8, [8, 10, 12]);
+_Mode.ECI = new _Mode(7, [0, 0, 0]);
+var Mode = _Mode;
+
+// src/lib/utils.ts
+function appendBits(val, len, bb) {
+  if (len < 0 || len > 31 || val >>> len != 0) throw new RangeError("Value out of range");
+  for (let i = len - 1; i >= 0; i--)
+    bb.push(val >>> i & 1);
+}
+function getBit(x, i) {
+  return (x >>> i & 1) != 0;
+}
+function assert(cond) {
+  if (!cond) throw new Error("Assertion error");
+}
+
+// src/lib/qr-segment.ts
+var _QrSegment = class _QrSegment {
+  // Создает новый сегмент QR-кода с заданными атрибутами и данными.
+  // Количество символов (numChars) должно соответствовать режиму и длине битового буфера,
+  // но это ограничение не проверяется. Данный битовый буфер клонируется и сохраняется.
+  constructor(mode, numChars, bitData) {
+    this.mode = mode;
+    this.numChars = numChars;
+    this.bitData = bitData;
+    if (numChars < 0) throw new RangeError("Invalid argument");
+    this.bitData = bitData.slice();
+  }
+  // Возвращает сегмент, представляющий данные двоичные данные, закодированные в
+  // байтовом режиме. Допустимы все входные байтовые массивы. Любая текстовая строка
+  // может быть преобразована в байты UTF-8 и закодирована как сегмент в байтовом режиме.
+  static makeBytes(data) {
+    const bb = [];
+    for (const b of data) appendBits(b, 8, bb);
+    return new _QrSegment(Mode.BYTE, data.length, bb);
+  }
+  // Возвращает сегмент, представляющий данную строку десятичных цифр, закодированную в числовом режиме.
+  static makeNumeric(digits) {
+    if (!_QrSegment.isNumeric(digits)) throw new RangeError("String contains non-numeric characters");
+    const bb = [];
+    for (let i = 0; i < digits.length; ) {
+      const n = Math.min(digits.length - i, 3);
+      appendBits(parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
+      i += n;
+    }
+    return new _QrSegment(Mode.NUMERIC, digits.length, bb);
+  }
+  // Возвращает сегмент, представляющий данную текстовую строку, закодированную в буквенно-цифровом режиме.
+  // Допустимые символы: от 0 до 9, от A до Z (только в верхнем регистре), пробел,
+  // доллар, процент, звездочка, плюс, дефис, точка, слэш, двоеточие.
+  static makeAlphanumeric(text) {
+    if (!_QrSegment.isAlphanumeric(text))
+      throw new RangeError("String contains unencodable characters in alphanumeric mode");
+    const bb = [];
+    let i;
+    for (i = 0; i + 2 <= text.length; i += 2) {
+      let temp = _QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
+      temp += _QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+      appendBits(temp, 11, bb);
+    }
+    if (i < text.length)
+      appendBits(_QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
+    return new _QrSegment(Mode.ALPHANUMERIC, text.length, bb);
+  }
+  // Возвращает новый изменяемый список из нуля или более сегментов для представления данной текстовой строки Unicode.
+  // Результат может использовать различные режимы сегментов и переключать режимы для оптимизации длины битового потока.
+  static makeSegments(text) {
+    if (text == "") return [];
+    else if (_QrSegment.isNumeric(text)) return [_QrSegment.makeNumeric(text)];
+    else if (_QrSegment.isAlphanumeric(text)) return [_QrSegment.makeAlphanumeric(text)];
+    else return [_QrSegment.makeBytes(_QrSegment.toUtf8ByteArray(text))];
+  }
+  // Возвращает сегмент, представляющий Extended Channel Interpretation
+  // (ECI) с заданным значением.
+  static makeEci(assignVal) {
+    const bb = [];
+    if (assignVal < 0) throw new RangeError("ECI assignment value out of range");
+    else if (assignVal < 1 << 7) appendBits(assignVal, 8, bb);
+    else if (assignVal < 1 << 14) {
+      appendBits(2, 2, bb);
+      appendBits(assignVal, 14, bb);
+    } else if (assignVal < 1e6) {
+      appendBits(6, 3, bb);
+      appendBits(assignVal, 21, bb);
+    } else throw new RangeError("ECI assignment value out of range");
+    return new _QrSegment(Mode.ECI, 0, bb);
+  }
+  // Проверяет, может ли данная строка быть закодирована как сегмент в числовом режиме.
+  // Строка кодируема, если каждый символ находится в диапазоне от 0 до 9.
+  static isNumeric(text) {
+    return _QrSegment.NUMERIC_REGEX.test(text);
+  }
+  // Проверяет, может ли данная строка быть закодирована как сегмент в буквенно-цифровом режиме.
+  // Строка кодируема, если каждый символ принадлежит следующему набору: от 0 до 9, от A до Z
+  // (только в верхнем регистре), пробел, доллар, процент, звездочка, плюс, дефис, точка, слэш, двоеточие.
+  static isAlphanumeric(text) {
+    return _QrSegment.ALPHANUMERIC_REGEX.test(text);
+  }
+  // Возвращает новую копию битов данных этого сегмента.
+  getData() {
+    return this.bitData.slice();
+  }
+  // (Package-private) Вычисляет и возвращает количество битов, необходимое для кодирования данных сегментов
+  // в данной версии. Результат - бесконечность, если у сегмента слишком много символов для поля длины.
+  static getTotalBits(segs, version) {
+    let result = 0;
+    for (const seg of segs) {
+      const ccbits = seg.mode.numCharCountBits(version);
+      if (seg.numChars >= 1 << ccbits) return Infinity;
+      result += 4 + ccbits + seg.bitData.length;
+    }
+    return result;
+  }
+  // Возвращает новый массив байтов, представляющий данную строку, закодированную в UTF-8.
+  static toUtf8ByteArray(str) {
+    str = encodeURI(str);
+    const result = [];
+    for (let i = 0; i < str.length; i++) {
+      if (str.charAt(i) != "%") result.push(str.charCodeAt(i));
+      else {
+        result.push(parseInt(str.substring(i + 1, i + 3), 16));
+        i += 2;
+      }
+    }
+    return result;
+  }
+};
+// Точно описывает все строки, которые можно закодировать в числовом режиме.
+_QrSegment.NUMERIC_REGEX = /^[0-9]*$/;
+// Точно описывает все строки, которые можно закодировать в буквенно-цифровом режиме.
+_QrSegment.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;
+// Набор всех допустимых символов в буквенно-цифровом режиме,
+// где значение каждого символа соответствует индексу в строке.
+_QrSegment.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+var QrSegment = _QrSegment;
+
+// src/lib/index.ts
+var _QrCode = class _QrCode {
+  // Создает новый QR-код с заданным номером версии,
+  // уровнем коррекции ошибок, байтами кодовых слов данных и номером маски.
+  // Это низкоуровневый API, который большинству пользователей не следует использовать напрямую.
+  // API среднего уровня - это функция encodeSegments().
+  constructor(version, errorCorrectionLevel, dataCodewords, msk) {
+    this.version = version;
+    this.errorCorrectionLevel = errorCorrectionLevel;
+    // Модули этого QR-кода (false = светлый, true = темный).
+    // Неизменяемы после завершения конструктора. Доступ через getModule().
+    this.modules = [];
+    // Указывает функциональные модули, которые не подвергаются маскированию. Отбрасывается после завершения конструктора.
+    this.isFunction = [];
+    if (version < _QrCode.MIN_VERSION || version > _QrCode.MAX_VERSION) throw new RangeError("Version value out of range");
+    if (msk < -1 || msk > 7) throw new RangeError("Mask value out of range");
+    this.size = version * 4 + 17;
+    const row = [];
+    for (let i = 0; i < this.size; i++) row.push(false);
+    for (let i = 0; i < this.size; i++) {
+      this.modules.push(row.slice());
+      this.isFunction.push(row.slice());
+    }
+    this.drawFunctionPatterns();
+    const allCodewords = this.addEccAndInterleave(dataCodewords);
+    this.drawCodewords(allCodewords);
+    if (msk == -1) {
+      let minPenalty = 1e9;
+      for (let i = 0; i < 8; i++) {
+        this.applyMask(i);
+        this.drawFormatBits(i);
+        const penalty = this.getPenaltyScore();
+        if (penalty < minPenalty) {
+          msk = i;
+          minPenalty = penalty;
+        }
+        this.applyMask(i);
+      }
+    }
+    assert(0 <= msk && msk <= 7);
+    this.mask = msk;
+    this.applyMask(msk);
+    this.drawFormatBits(msk);
+    this.isFunction = [];
+  }
+  // Возвращает QR-код, представляющий данную текстовую строку Unicode с заданным уровнем коррекции ошибок.
+  // В качестве консервативной верхней границы, эта функция гарантированно успешно работает для строк, содержащих 738 или меньше
+  // кодовых точек Unicode (не кодовых единиц UTF-16), если используется низкий уровень коррекции ошибок. Наименьшая возможная
+  // версия QR-кода выбирается автоматически для вывода. Уровень ECC результата может быть выше, чем
+  // аргумент ecl, если это можно сделать без увеличения версии.
+  static encodeText(text, ecl) {
+    const segs = QrSegment.makeSegments(text);
+    return _QrCode.encodeSegments(segs, ecl);
+  }
+  // Возвращает QR-код, представляющий данные двоичные данные с заданным уровнем коррекции ошибок.
+  // Эта функция всегда кодирует в двоичном режиме сегмента, а не в текстовом. Максимальное количество
+  // разрешенных байтов - 2953. Наименьшая возможная версия QR-кода выбирается автоматически для вывода.
+  // Уровень ECC результата может быть выше, чем аргумент ecl, если это можно сделать без увеличения версии.
+  static encodeBinary(data, ecl) {
+    const seg = QrSegment.makeBytes(data);
+    return _QrCode.encodeSegments([seg], ecl);
+  }
+  // Возвращает QR-код, представляющий данные сегменты с заданными параметрами кодирования.
+  // Наименьшая возможная версия QR-кода в заданном диапазоне автоматически
+  // выбирается для вывода. Если boostEcl истинно, то уровень ECC результата
+  // может быть выше, чем аргумент ecl, если это можно сделать без увеличения
+  // версии. Номер маски либо от 0 до 7 (включительно), чтобы принудительно использовать эту
+  // маску, либо -1 для автоматического выбора подходящей маски (что может быть медленно).
+  // Эта функция позволяет пользователю создавать настраиваемую последовательность сегментов, которая переключается
+  // между режимами (например, буквенно-цифровым и байтовым) для кодирования текста с меньшими затратами.
+  // Это API среднего уровня; API высокого уровня - encodeText() и encodeBinary().
+  static encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {
+    if (!(_QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= _QrCode.MAX_VERSION) || mask < -1 || mask > 7)
+      throw new RangeError("Invalid value");
+    let version;
+    let dataUsedBits;
+    for (version = minVersion; ; version++) {
+      const dataCapacityBits2 = _QrCode.getNumDataCodewords(version, ecl) * 8;
+      const usedBits = QrSegment.getTotalBits(segs, version);
+      if (usedBits <= dataCapacityBits2) {
+        dataUsedBits = usedBits;
+        break;
+      }
+      if (version >= maxVersion)
+        throw new RangeError("Data too long");
+    }
+    for (const newEcl of [Ecc.MEDIUM, Ecc.QUARTILE, Ecc.HIGH]) {
+      if (boostEcl && dataUsedBits <= _QrCode.getNumDataCodewords(version, newEcl) * 8) ecl = newEcl;
+    }
+    const bb = [];
+    for (const seg of segs) {
+      appendBits(seg.mode.modeBits, 4, bb);
+      appendBits(seg.numChars, seg.mode.numCharCountBits(version), bb);
+      for (const b of seg.getData()) bb.push(b);
+    }
+    assert(bb.length == dataUsedBits);
+    const dataCapacityBits = _QrCode.getNumDataCodewords(version, ecl) * 8;
+    assert(bb.length <= dataCapacityBits);
+    appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
+    appendBits(0, (8 - bb.length % 8) % 8, bb);
+    assert(bb.length % 8 == 0);
+    for (let padByte = 236; bb.length < dataCapacityBits; padByte ^= 236 ^ 17) appendBits(padByte, 8, bb);
+    const dataCodewords = [];
+    while (dataCodewords.length * 8 < bb.length) dataCodewords.push(0);
+    bb.forEach((b, i) => {
+      var _a;
+      if (dataCodewords[i >>> 3] !== void 0) {
+        const idx = i >>> 3;
+        dataCodewords[idx] = ((_a = dataCodewords[idx]) != null ? _a : 0) | b << 7 - (i & 7);
+      }
+    });
+    return new _QrCode(version, ecl, dataCodewords, mask);
+  }
+  // Возвращает цвет модуля (пикселя) по заданным координатам, который равен false
+  // для светлого или true для темного. Левый верхний угол имеет координаты (x=0, y=0).
+  // Если заданные координаты выходят за пределы, возвращается false (светлый).
+  getModule(x, y) {
+    if (0 <= x && x < this.size && 0 <= y && y < this.size) {
+      const row = this.modules[y];
+      if (row !== void 0) {
+        const module2 = row[x];
+        if (module2 !== void 0) {
+          return module2;
+        }
+      }
+    }
+    return false;
+  }
+  // Считывает поле версии этого объекта, а затем рисует и помечает все функциональные модули.
+  drawFunctionPatterns() {
+    for (let i = 0; i < this.size; i++) {
+      this.setFunctionModule(6, i, i % 2 == 0);
+      this.setFunctionModule(i, 6, i % 2 == 0);
+    }
+    this.drawFinderPattern(3, 3);
+    this.drawFinderPattern(this.size - 4, 3);
+    this.drawFinderPattern(3, this.size - 4);
+    const alignPatPos = this.getAlignmentPatternPositions();
+    const numAlign = alignPatPos.length;
+    for (let i = 0; i < numAlign; i++) {
+      for (let j = 0; j < numAlign; j++) {
+        const iPos = alignPatPos[i];
+        const jPos = alignPatPos[j];
+        if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0) && iPos !== void 0 && jPos !== void 0)
+          this.drawAlignmentPattern(iPos, jPos);
+      }
+    }
+    this.drawFormatBits(0);
+    this.drawVersion();
+  }
+  // Рисует две копии битов формата (с собственным кодом коррекции ошибок)
+  // на основе данной маски и поля уровня коррекции ошибок этого объекта.
+  drawFormatBits(mask) {
+    const data = this.errorCorrectionLevel.formatBits << 3 | mask;
+    let rem = data;
+    for (let i = 0; i < 10; i++) rem = rem << 1 ^ (rem >>> 9) * 1335;
+    const bits = (data << 10 | rem) ^ 21522;
+    assert(bits >>> 15 == 0);
+    for (let i = 0; i <= 5; i++) this.setFunctionModule(8, i, getBit(bits, i));
+    this.setFunctionModule(8, 7, getBit(bits, 6));
+    this.setFunctionModule(8, 8, getBit(bits, 7));
+    this.setFunctionModule(7, 8, getBit(bits, 8));
+    for (let i = 9; i < 15; i++) this.setFunctionModule(14 - i, 8, getBit(bits, i));
+    for (let i = 0; i < 8; i++) this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
+    for (let i = 8; i < 15; i++) this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
+    this.setFunctionModule(8, this.size - 8, true);
+  }
+  // Рисует две копии битов версии (с собственным кодом коррекции ошибок),
+  // на основе поля версии этого объекта, если 7 <= version <= 40.
+  drawVersion() {
+    if (this.version < 7) return;
+    let rem = this.version;
+    for (let i = 0; i < 12; i++) rem = rem << 1 ^ (rem >>> 11) * 7973;
+    const bits = this.version << 12 | rem;
+    assert(bits >>> 18 == 0);
+    for (let i = 0; i < 18; i++) {
+      const color = getBit(bits, i);
+      const a = this.size - 11 + i % 3;
+      const b = Math.floor(i / 3);
+      this.setFunctionModule(a, b, color);
+      this.setFunctionModule(b, a, color);
+    }
+  }
+  // Рисует поисковый узор 9x9, включая разделитель границы,
+  // с центральным модулем в (x, y). Модули могут выходить за пределы.
+  drawFinderPattern(x, y) {
+    for (let dy = -4; dy <= 4; dy++) {
+      for (let dx = -4; dx <= 4; dx++) {
+        const dist = Math.max(Math.abs(dx), Math.abs(dy));
+        const xx = x + dx;
+        const yy = y + dy;
+        if (0 <= xx && xx < this.size && 0 <= yy && yy < this.size)
+          this.setFunctionModule(xx, yy, dist != 2 && dist != 4);
+      }
+    }
+  }
+  // Рисует выравнивающий узор 5x5 с центральным модулем
+  // в (x, y). Все модули должны быть в пределах границ.
+  drawAlignmentPattern(x, y) {
+    for (let dy = -2; dy <= 2; dy++) {
+      for (let dx = -2; dx <= 2; dx++) this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) != 1);
+    }
+  }
+  // Устанавливает цвет модуля и помечает его как функциональный модуль.
+  // Используется только конструктором. Координаты должны быть в пределах границ.
+  setFunctionModule(x, y, isDark) {
+    const row = this.modules[y];
+    const funcRow = this.isFunction[y];
+    if (row !== void 0 && funcRow !== void 0) {
+      row[x] = isDark;
+      funcRow[x] = true;
+    }
+  }
+  // Возвращает новую байтовую строку, представляющую данные с добавленными
+  // соответствующими кодовыми словами коррекции ошибок, на основе версии и уровня коррекции ошибок этого объекта.
+  addEccAndInterleave(data) {
+    var _a, _b, _c, _d;
+    const ver = this.version;
+    const ecl = this.errorCorrectionLevel;
+    if (data.length != _QrCode.getNumDataCodewords(ver, ecl)) throw new RangeError("Invalid argument");
+    const numBlocks = (_b = (_a = _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal]) == null ? void 0 : _a[ver]) != null ? _b : 0;
+    const blockEccLen = (_d = (_c = _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal]) == null ? void 0 : _c[ver]) != null ? _d : 0;
+    const rawCodewords = Math.floor(_QrCode.getNumRawDataModules(ver) / 8);
+    const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+    const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+    const blocks = [];
+    const rsDiv = _QrCode.reedSolomonComputeDivisor(blockEccLen);
+    for (let i = 0, k = 0; i < numBlocks; i++) {
+      const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+      k += dat.length;
+      const ecc = _QrCode.reedSolomonComputeRemainder(dat, rsDiv);
+      if (i < numShortBlocks) dat.push(0);
+      blocks.push(dat.concat(ecc));
+    }
+    const result = [];
+    const firstBlock = blocks[0];
+    if (firstBlock !== void 0) {
+      for (let i = 0; i < firstBlock.length; i++) {
+        blocks.forEach((block, j) => {
+          const blockI = block[i];
+          if ((i != shortBlockLen - blockEccLen || j >= numShortBlocks) && blockI !== void 0) result.push(blockI);
+        });
+      }
+    }
+    assert(result.length == rawCodewords);
+    return result;
+  }
+  // Рисует данную последовательность 8-битных кодовых слов (данные и коррекция ошибок) на всей
+  // области данных этого QR-кода. Функциональные модули должны быть отмечены до вызова этого метода.
+  drawCodewords(data) {
+    if (data.length != Math.floor(_QrCode.getNumRawDataModules(this.version) / 8))
+      throw new RangeError("Invalid argument");
+    let i = 0;
+    for (let right = this.size - 1; right >= 1; right -= 2) {
+      if (right == 6) right = 5;
+      for (let vert = 0; vert < this.size; vert++) {
+        for (let j = 0; j < 2; j++) {
+          const x = right - j;
+          const upward = (right + 1 & 2) == 0;
+          const y = upward ? this.size - 1 - vert : vert;
+          const funcRow = this.isFunction[y];
+          const dataByte = data[i >>> 3];
+          if (funcRow !== void 0 && !funcRow[x] && i < data.length * 8 && dataByte !== void 0) {
+            const row = this.modules[y];
+            if (row !== void 0) {
+              row[x] = getBit(dataByte, 7 - (i & 7));
+              i++;
+            }
+          }
+        }
+      }
+    }
+    assert(i == data.length * 8);
+  }
+  // Выполняет операцию XOR для модулей кодовых слов в этом QR-коде с заданным шаблоном маски.
+  // Функциональные модули должны быть отмечены, а биты кодовых слов нарисованы
+  // перед маскированием. Из-за арифметики XOR повторный вызов applyMask() с
+  // тем же значением маски отменит маску. Окончательный правильно сформированный
+  // QR-код требует применения ровно одной (не ноль, двух и т.д.) маски.
+  applyMask(mask) {
+    if (mask < 0 || mask > 7) throw new RangeError("Mask value out of range");
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        let invert;
+        switch (mask) {
+          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:
+            throw new Error("Unreachable");
+        }
+        const funcRow = this.isFunction[y];
+        if (funcRow !== void 0 && !funcRow[x] && invert) {
+          const row = this.modules[y];
+          if (row !== void 0) {
+            const val = row[x];
+            if (val !== void 0) row[x] = !val;
+          }
+        }
+      }
+    }
+  }
+  // Вычисляет и возвращает штрафной балл на основе состояния текущих модулей этого QR-кода.
+  // Это используется алгоритмом автоматического выбора маски для поиска шаблона маски, который дает наименьший балл.
+  getPenaltyScore() {
+    let result = 0;
+    for (let y = 0; y < this.size; y++) {
+      let runColor = false;
+      let runX = 0;
+      const runHistory = [0, 0, 0, 0, 0, 0, 0];
+      const row = this.modules[y];
+      if (row === void 0) continue;
+      for (let x = 0; x < this.size; x++) {
+        if (row[x] == runColor) {
+          runX++;
+          if (runX == 5) result += _QrCode.PENALTY_N1;
+          else if (runX > 5) result++;
+        } else {
+          this.finderPenaltyAddHistory(runX, runHistory);
+          if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * _QrCode.PENALTY_N3;
+          const val = row[x];
+          if (val !== void 0) {
+            runColor = val;
+            runX = 1;
+          }
+        }
+      }
+      result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * _QrCode.PENALTY_N3;
+    }
+    for (let x = 0; x < this.size; x++) {
+      let runColor = false;
+      let runY = 0;
+      const runHistory = [0, 0, 0, 0, 0, 0, 0];
+      for (let y = 0; y < this.size; y++) {
+        const row = this.modules[y];
+        if (row === void 0) continue;
+        if (row[x] == runColor) {
+          runY++;
+          if (runY == 5) result += _QrCode.PENALTY_N1;
+          else if (runY > 5) result++;
+        } else {
+          this.finderPenaltyAddHistory(runY, runHistory);
+          if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * _QrCode.PENALTY_N3;
+          const val = row[x];
+          if (val !== void 0) {
+            runColor = val;
+            runY = 1;
+          }
+        }
+      }
+      result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * _QrCode.PENALTY_N3;
+    }
+    for (let y = 0; y < this.size - 1; y++) {
+      const row = this.modules[y];
+      const nextRow = this.modules[y + 1];
+      if (row === void 0 || nextRow === void 0) continue;
+      for (let x = 0; x < this.size - 1; x++) {
+        const color = row[x];
+        if (color !== void 0 && color == row[x + 1] && color == nextRow[x] && color == nextRow[x + 1])
+          result += _QrCode.PENALTY_N2;
+      }
+    }
+    let dark = 0;
+    for (const row of this.modules) dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);
+    const total = this.size * this.size;
+    const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+    assert(0 <= k && k <= 9);
+    result += k * _QrCode.PENALTY_N4;
+    assert(0 <= result && result <= 2568888);
+    return result;
+  }
+  // Возвращает возрастающий список позиций выравнивающих узоров для этого номера версии.
+  // Каждая позиция находится в диапазоне [0,177) и используется как для оси x, так и для оси y.
+  // Это может быть реализовано как таблица поиска из 40 списков целых чисел переменной длины.
+  getAlignmentPatternPositions() {
+    if (this.version == 1) return [];
+    else {
+      const numAlign = Math.floor(this.version / 7) + 2;
+      const step = this.version == 32 ? 26 : Math.ceil((this.size - 13) / (numAlign * 2 - 2)) * 2;
+      const result = [6];
+      for (let pos = this.size - 7; result.length < numAlign; pos -= step) result.splice(1, 0, pos);
+      return result;
+    }
+  }
+  // Возвращает количество битов данных, которые можно сохранить в QR-коде данной версии, после
+  // исключения всех функциональных модулей. Включает остаточные биты, поэтому может быть не кратным 8.
+  // Результат находится в диапазоне [208, 29648]. Это может быть реализовано как таблица поиска на 40 записей.
+  static getNumRawDataModules(ver) {
+    if (ver < _QrCode.MIN_VERSION || ver > _QrCode.MAX_VERSION) throw new RangeError("Version number out of range");
+    let result = (16 * ver + 128) * ver + 64;
+    if (ver >= 2) {
+      const numAlign = Math.floor(ver / 7) + 2;
+      result -= (25 * numAlign - 10) * numAlign - 55;
+      if (ver >= 7) result -= 36;
+    }
+    assert(208 <= result && result <= 29648);
+    return result;
+  }
+  // Возвращает количество 8-битных кодовых слов данных (т.е. не для коррекции ошибок)
+  // в любом QR-коде для данной версии и уровня коррекции ошибок, с отброшенными остаточными битами.
+  // Эта чистая функция без состояния может быть реализована как таблица поиска (40*4).
+  static getNumDataCodewords(ver, ecl) {
+    var _a, _b, _c, _d;
+    const eccPerBlock = (_b = (_a = _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal]) == null ? void 0 : _a[ver]) != null ? _b : 0;
+    const numBlocks = (_d = (_c = _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal]) == null ? void 0 : _c[ver]) != null ? _d : 0;
+    return Math.floor(_QrCode.getNumRawDataModules(ver) / 8) - eccPerBlock * numBlocks;
+  }
+  // Возвращает порождающий полином для ECC Рида-Соломона для данной степени.
+  // Может быть реализована как таблица поиска по всем возможным значениям параметров, а не как алгоритм.
+  static reedSolomonComputeDivisor(degree) {
+    var _a;
+    if (degree < 1 || degree > 255) throw new RangeError("Degree out of range");
+    const result = [];
+    for (let i = 0; i < degree - 1; i++) result.push(0);
+    result.push(1);
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+      for (let j = 0; j < result.length; j++) {
+        const val = result[j];
+        if (val !== void 0) {
+          result[j] = _QrCode.reedSolomonMultiply(val, root);
+          if (j + 1 < result.length) {
+            const nextVal = result[j + 1];
+            if (nextVal !== void 0) result[j] = ((_a = result[j]) != null ? _a : 0) ^ nextVal;
+          }
+        }
+      }
+      root = _QrCode.reedSolomonMultiply(root, 2);
+    }
+    return result;
+  }
+  // Возвращает кодовое слово коррекции ошибок Рида-Соломона для данных полиномов данных и делителя.
+  static reedSolomonComputeRemainder(data, divisor) {
+    var _a;
+    const result = divisor.map((_) => 0);
+    for (const b of data) {
+      const factor = b ^ ((_a = result.shift()) != null ? _a : 0);
+      result.push(0);
+      divisor.forEach((coef, i) => {
+        const res = result[i];
+        if (res !== void 0) result[i] = res ^ _QrCode.reedSolomonMultiply(coef, factor);
+      });
+    }
+    return result;
+  }
+  // Возвращает произведение двух данных элементов поля по модулю GF(2^8/0x11D). Аргументы и результат
+  // являются беззнаковыми 8-битными целыми числами. Это может быть реализовано как таблица поиска 256*256 записей uint8.
+  static reedSolomonMultiply(x, y) {
+    if (x >>> 8 != 0 || y >>> 8 != 0) throw new RangeError("Byte out of range");
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+      z = z << 1 ^ (z >>> 7) * 285;
+      z ^= (y >>> i & 1) * x;
+    }
+    assert(z >>> 8 == 0);
+    return z;
+  }
+  // Может быть вызвана только сразу после добавления светлой серии,
+  // и возвращает 0, 1 или 2. Вспомогательная функция для getPenaltyScore().
+  finderPenaltyCountPatterns(runHistory) {
+    var _a, _b;
+    const n = runHistory[1];
+    if (n === void 0) return 0;
+    assert(n <= this.size * 3);
+    const core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
+    const h0 = (_a = runHistory[0]) != null ? _a : 0;
+    const h6 = (_b = runHistory[6]) != null ? _b : 0;
+    return (core && h0 >= n * 4 && h6 >= n ? 1 : 0) + (core && h6 >= n * 4 && h0 >= n ? 1 : 0);
+  }
+  // Должна быть вызвана в конце строки (ряда или столбца) модулей. Вспомогательная функция для getPenaltyScore().
+  finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
+    if (currentRunColor) {
+      this.finderPenaltyAddHistory(currentRunLength, runHistory);
+      currentRunLength = 0;
+    }
+    currentRunLength += this.size;
+    this.finderPenaltyAddHistory(currentRunLength, runHistory);
+    return this.finderPenaltyCountPatterns(runHistory);
+  }
+  // Добавляет данное значение в начало и удаляет последнее значение. Вспомогательная функция для getPenaltyScore().
+  finderPenaltyAddHistory(currentRunLength, runHistory) {
+    if (runHistory[0] == 0) currentRunLength += this.size;
+    runHistory.pop();
+    runHistory.unshift(currentRunLength);
+  }
+};
+// Минимальный номер версии, поддерживаемый в стандарте QR Code Model 2.
+_QrCode.MIN_VERSION = 1;
+// Максимальный номер версии, поддерживаемый в стандарте QR Code Model 2.
+_QrCode.MAX_VERSION = 40;
+// Для использования в getPenaltyScore() при оценке, какая маска лучше.
+_QrCode.PENALTY_N1 = 3;
+_QrCode.PENALTY_N2 = 3;
+_QrCode.PENALTY_N3 = 40;
+_QrCode.PENALTY_N4 = 10;
+_QrCode.ECC_CODEWORDS_PER_BLOCK = [
+  // Версия: (обратите внимание, что индекс 0 используется для заполнения и имеет недопустимое значение)
+  //0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Уровень коррекции ошибок
+  [
+    -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
+  ]
+  // Высокий
+];
+_QrCode.NUM_ERROR_CORRECTION_BLOCKS = [
+  // Версия: (обратите внимание, что индекс 0 используется для заполнения и имеет недопустимое значение)
+  //0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Уровень коррекции ошибок
+  [
+    -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
+  ]
+  // Высокий
+];
+var QrCode = _QrCode;
+
+// src/service/common-utils.ts
+var isModuleVisible = (cellRect, logoRect) => {
+  if (!logoRect) return true;
+  return !(cellRect.x >= logoRect.x && cellRect.x + cellRect.w <= logoRect.x + logoRect.w && cellRect.y >= logoRect.y && cellRect.y + cellRect.h <= logoRect.y + logoRect.h);
+};
+var getLogoModuleSize = (aspectRatio, padModules) => {
+  let logoWidthModules, logoHeightModules;
+  if (aspectRatio >= 1) {
+    logoWidthModules = padModules - 2;
+    logoHeightModules = logoWidthModules / aspectRatio;
+    if (logoHeightModules > padModules - 2) {
+      logoHeightModules = padModules - 2;
+      logoWidthModules = logoHeightModules * aspectRatio;
+    }
+  } else {
+    logoHeightModules = padModules - 2;
+    logoWidthModules = logoHeightModules * aspectRatio;
+    if (logoWidthModules > padModules - 2) {
+      logoWidthModules = padModules - 2;
+      logoHeightModules = logoWidthModules / aspectRatio;
+    }
+  }
+  return {
+    logoHeightModules,
+    logoWidthModules
+  };
+};
+var prepareQRCodeData = ({
+  text,
+  logo,
+  logoAspectRatio = 1,
+  logoSizePercent = 30,
+  size = 320
+}) => {
+  if (!text || !text.trim()) return null;
+  const qr = QrCode.encodeText(text, Ecc.HIGH);
+  const cellCount = qr.size;
+  const cellSize = size / cellCount;
+  const qrPixelSize = size;
+  const offset = 0;
+  const maxPadModules = cellCount - 8;
+  const maxPadPx = maxPadModules * cellSize;
+  const areaLimit = 0.2;
+  const maxPadPxByArea = Math.sqrt(qrPixelSize * qrPixelSize * areaLimit);
+  const maxPadPxFinal = Math.min(maxPadPx, maxPadPxByArea);
+  const padSizeRaw = logoSizePercent / 100 * qrPixelSize;
+  let padModules = Math.round(padSizeRaw / cellSize);
+  if (padModules < 3) padModules = 3;
+  if (padModules % 2 === 0) padModules += 1;
+  padModules = Math.min(padModules, Math.floor(maxPadPxFinal / cellSize));
+  if (padModules % 2 === 0) padModules -= 1;
+  const padCenterX = offset + qrPixelSize / 2;
+  const padCenterY = offset + qrPixelSize / 2;
+  if (!logo) {
+    return {
+      cellCount,
+      cellSize,
+      logoRect: null,
+      offset,
+      padCenterX,
+      padCenterY,
+      padModules,
+      qr,
+      qrPixelSize
+    };
+  }
+  const { logoHeightModules, logoWidthModules } = getLogoModuleSize(logoAspectRatio, padModules);
+  const padWidth = (logoWidthModules + 2) * cellSize;
+  const padHeight = (logoHeightModules + 2) * cellSize;
+  const padX = padCenterX - padWidth / 2;
+  const padY = padCenterY - padHeight / 2;
+  const logoDrawWidth = logoWidthModules * cellSize;
+  const logoDrawHeight = logoHeightModules * cellSize;
+  const logoX = padX + cellSize;
+  const logoY = padY + cellSize;
+  const logoRect = { h: padHeight, w: padWidth, x: padX, y: padY };
+  return {
+    aspectRatio: logoAspectRatio,
+    cellCount,
+    cellSize,
+    logoDrawHeight,
+    logoDrawWidth,
+    logoRect,
+    logoX,
+    logoY,
+    offset,
+    padCenterX,
+    padCenterY,
+    padHeight,
+    padModules,
+    padWidth,
+    qr,
+    qrPixelSize
+  };
+};
+
+// src/constants.ts
+var DEFAULT_LOGO_PROPS = { logo: null, logoAspectRatio: 1 };
+var DEFAULT_QRCODE_SIZE = 200;
+var DEFAULT_QRCODE_COLOR = "#000";
+var DEFAULT_QRCODE_BG_COLOR = "transparent";
+
+// src/service/draw-utils.ts
+function drawRoundRect(ctx, x, y, w, h, r) {
+  ctx.beginPath();
+  ctx.moveTo(x + r, y);
+  ctx.lineTo(x + w - r, y);
+  ctx.arcTo(x + w, y, x + w, y + r, r);
+  ctx.lineTo(x + w, y + h - r);
+  ctx.arcTo(x + w, y + h, x + w - r, y + h, r);
+  ctx.lineTo(x + r, y + h);
+  ctx.arcTo(x, y + h, x, y + h - r, r);
+  ctx.lineTo(x, y + r);
+  ctx.arcTo(x, y, x + r, y, r);
+  ctx.closePath();
+}
+function drawSmartRoundRect(ctx, x, y, size, rad, tl, tr, br, bl) {
+  ctx.beginPath();
+  ctx.moveTo(x + (tl ? rad : 0), y);
+  ctx.lineTo(x + size - (tr ? rad : 0), y);
+  if (tr) ctx.quadraticCurveTo(x + size, y, x + size, y + rad);
+  else ctx.lineTo(x + size, y);
+  ctx.lineTo(x + size, y + size - (br ? rad : 0));
+  if (br) ctx.quadraticCurveTo(x + size, y + size, x + size - rad, y + size);
+  else ctx.lineTo(x + size, y + size);
+  ctx.lineTo(x + (bl ? rad : 0), y + size);
+  if (bl) ctx.quadraticCurveTo(x, y + size, x, y + size - rad);
+  else ctx.lineTo(x, y + size);
+  ctx.lineTo(x, y + (tl ? rad : 0));
+  if (tl) ctx.quadraticCurveTo(x, y, x + (tl ? rad : 0), y);
+  else ctx.lineTo(x, y);
+  ctx.closePath();
+}
+function drawFinderPatternRound(ctx, x, y, size, color, finderRadius, bgColor) {
+  const rad7 = finderRadius / 100 * (size * 7 / 2);
+  const rad5 = finderRadius / 100 * (size * 5 / 2);
+  const rad3 = finderRadius / 100 * (size * 3 / 2);
+  ctx.save();
+  ctx.fillStyle = color;
+  drawRoundRect(ctx, x, y, size * 7, size * 7, rad7);
+  ctx.fill();
+  ctx.save();
+  ctx.globalCompositeOperation = "destination-out";
+  drawRoundRect(ctx, x + size, y + size, size * 5, size * 5, rad5);
+  ctx.fill();
+  ctx.restore();
+  if (bgColor !== "transparent") {
+    ctx.fillStyle = bgColor;
+    drawRoundRect(ctx, x + size, y + size, size * 5, size * 5, rad5);
+    ctx.fill();
+  }
+  ctx.fillStyle = color;
+  drawRoundRect(ctx, x + size * 2, y + size * 2, size * 3, size * 3, rad3);
+  ctx.fill();
+  ctx.restore();
+}
+function drawLogoImage(ctx, qrData, image) {
+  const { cellSize, padModules } = qrData;
+  const aspectRatio = image.width / image.height || 1;
+  const { logoHeightModules, logoWidthModules } = getLogoModuleSize(aspectRatio, padModules);
+  const padWidth = (logoWidthModules + 2) * cellSize;
+  const padHeight = (logoHeightModules + 2) * cellSize;
+  const padX = qrData.padCenterX - padWidth / 2;
+  const padY = qrData.padCenterY - padHeight / 2;
+  const logoDrawWidth = logoWidthModules * cellSize;
+  const logoDrawHeight = logoHeightModules * cellSize;
+  const logoX = padX + cellSize;
+  const logoY = padY + cellSize;
+  ctx.save();
+  ctx.fillStyle = "transparent";
+  ctx.fillRect(padX, padY, padWidth, padHeight);
+  ctx.drawImage(image, logoX, logoY, logoDrawWidth, logoDrawHeight);
+  ctx.restore();
+}
+function drawLogo(ctx, qrData, logo) {
+  if (!logo || !qrData.logoRect || !qrData.cellSize) return;
+  const image = new window.Image();
+  image.onload = () => drawLogoImage(ctx, qrData, image);
+  image.src = logo;
+  if (image.complete && image.naturalWidth) {
+    drawLogoImage(ctx, qrData, image);
+  }
+}
+function drawBackground(ctx, props, qrData) {
+  const { size = DEFAULT_QRCODE_SIZE, finderRadius = 0, bgColor } = props;
+  if (!bgColor || bgColor === "transparent") return;
+  const { cellSize } = qrData;
+  const finderSize = 7 * cellSize;
+  const cornerRadius = finderRadius / 100 * (finderSize / 2);
+  ctx.save();
+  ctx.fillStyle = bgColor;
+  drawRoundRect(ctx, 0, 0, size, size, cornerRadius);
+  ctx.fill();
+  ctx.restore();
+}
+function drawModules(ctx, qrData, props) {
+  const { qr, cellCount, cellSize, offset, logoRect } = qrData;
+  const { dotColor = "#000", radius = 0, smoothDots = false } = props;
+  const dotRad = radius / 100 * (cellSize / 2);
+  for (let r = 0; r < cellCount; r++) {
+    for (let c = 0; c < cellCount; c++) {
+      if (qr.getModule(c, r)) {
+        const inFinder = r < 7 && c < 7 || r < 7 && c >= cellCount - 7 || r >= cellCount - 7 && c < 7;
+        if (inFinder) continue;
+        const x = c * cellSize + offset;
+        const y = r * cellSize + offset;
+        const cellRect = { h: cellSize, w: cellSize, x, y };
+        if (!isModuleVisible(cellRect, logoRect)) continue;
+        ctx.fillStyle = dotColor;
+        if (smoothDots) {
+          const isActiveNeighbor = (c2, r2) => {
+            if (c2 < 0 || c2 >= cellCount || r2 < 0 || r2 >= cellCount) return false;
+            if (!qr.getModule(c2, r2)) return false;
+            if (logoRect) {
+              const x2 = c2 * cellSize + offset;
+              const y2 = r2 * cellSize + offset;
+              const neighborRect = { h: cellSize, w: cellSize, x: x2, y: y2 };
+              if (!isModuleVisible(neighborRect, logoRect)) return false;
+            }
+            return true;
+          };
+          const left = isActiveNeighbor(c - 1, r);
+          const right = isActiveNeighbor(c + 1, r);
+          const top = isActiveNeighbor(c, r - 1);
+          const bottom = isActiveNeighbor(c, r + 1);
+          const tl = !(top || left);
+          const tr = !(top || right);
+          const br = !(bottom || right);
+          const bl = !(bottom || left);
+          drawSmartRoundRect(ctx, x, y, cellSize, dotRad, tl, tr, br, bl);
+          ctx.fill();
+        } else {
+          if (dotRad === 0) {
+            ctx.fillRect(x, y, cellSize, cellSize);
+          } else {
+            drawRoundRect(ctx, x, y, cellSize, cellSize, dotRad);
+            ctx.fill();
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/service/index.ts
+var renderQr = ({ ctx, params }) => {
+  const {
+    text,
+    dotColor = DEFAULT_QRCODE_COLOR,
+    finderRadius = 0,
+    logo,
+    logoAspectRatio,
+    logoSizePercent = 30,
+    size = DEFAULT_QRCODE_SIZE,
+    bgColor = DEFAULT_QRCODE_BG_COLOR
+  } = params;
+  ctx.lineJoin = "round";
+  ctx.imageSmoothingEnabled = false;
+  ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+  if (!text || !text.trim()) {
+    ctx.fillStyle = "#888";
+    ctx.font = "bold 18px sans-serif";
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillText("\u041D\u0435\u0442 \u0434\u0430\u043D\u043D\u044B\u0445", size / 2, size / 2);
+    return;
+  }
+  const qrData = prepareQRCodeData({ logo, logoAspectRatio, logoSizePercent, size, text });
+  if (!qrData) return;
+  drawBackground(ctx, params, qrData);
+  drawModules(ctx, qrData, params);
+  const { cellSize, offset, cellCount } = qrData;
+  drawFinderPatternRound(ctx, offset, offset, cellSize, dotColor, finderRadius, bgColor);
+  drawFinderPatternRound(ctx, offset + (cellCount - 7) * cellSize, offset, cellSize, dotColor, finderRadius, bgColor);
+  drawFinderPatternRound(ctx, offset, offset + (cellCount - 7) * cellSize, cellSize, dotColor, finderRadius, bgColor);
+  if (logo) {
+    drawLogo(ctx, qrData, logo);
+  }
+};
+
+// src/ui/index.tsx
+var import_react = require("react");
+
+// src/ui/styled.ts
+var import_styled_components = __toESM(require("styled-components"), 1);
+var Canvas = (0, import_styled_components.default)("canvas")`
+  ${({ $size }) => `
+    width: ${$size}px;
+    height: ${$size}px;
+  `}
+`;
+
+// src/ui/index.tsx
+var QRCode = (props) => {
+  const { size = DEFAULT_QRCODE_SIZE, logo } = props;
+  const canvasRef = (0, import_react.useRef)(null);
+  const [asyncProps, setAsyncProps] = (0, import_react.useState)(logo ? null : DEFAULT_LOGO_PROPS);
+  (0, import_react.useEffect)(() => {
+    if (logo) {
+      const img = new window.Image();
+      img.onload = () => {
+        setAsyncProps({
+          logo,
+          logoAspectRatio: img.naturalWidth / img.naturalHeight
+        });
+      };
+      img.onerror = () => {
+        setAsyncProps({
+          logo: null,
+          logoAspectRatio: 1
+        });
+      };
+      img.src = logo;
+    } else {
+      setAsyncProps(DEFAULT_LOGO_PROPS);
+    }
+  }, [logo]);
+  (0, import_react.useEffect)(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !asyncProps) {
+      return;
+    }
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+    const dpr = window.devicePixelRatio || 1;
+    const newSize = size * dpr;
+    canvas.width = newSize;
+    canvas.height = newSize;
+    ctx.scale(dpr, dpr);
+    renderQr({ ctx, params: __spreadValues(__spreadValues({}, props), asyncProps) });
+  }, [props, asyncProps, size]);
+  return /* @__PURE__ */ React.createElement(Canvas, { ref: canvasRef, $size: size });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QRCode,
+  renderQr
+});