pcm-agents 0.6.11 → 0.6.13

package/dist/components/p-Dv8qvK0w.js

@@ -0,0 +1,2646 @@
+class MessageService {
+    _container = null;
+    _instances = new Map();
+    _maxCount = 2; // 最大同时显示数量
+    _idCounter = 0;
+    getContainer() {
+        if (!this._container) {
+            this._container = document.createElement('div');
+            this._container.className = 'pcm-message-container';
+            document.body.appendChild(this._container);
+        }
+        return this._container;
+    }
+    generateId() {
+        return `pcm-message-${++this._idCounter}`;
+    }
+    getMessageKey(options) {
+        // 如果提供了key，使用key；否则使用content+type作为key
+        return options.key || `${options.content}-${options.type}`;
+    }
+    removeOldestMessage() {
+        if (this._instances.size >= this._maxCount) {
+            const firstKey = this._instances.keys().next().value;
+            if (firstKey) {
+                this.removeMessage(firstKey);
+            }
+        }
+    }
+    removeMessage(key) {
+        const instance = this._instances.get(key);
+        if (instance) {
+            // 清除定时器
+            if (instance.timer) {
+                clearTimeout(instance.timer);
+            }
+            // 移除DOM元素
+            if (instance.element && instance.element.parentNode) {
+                instance.element.parentNode.removeChild(instance.element);
+            }
+            // 从实例映射中移除
+            this._instances.delete(key);
+        }
+    }
+    create(options) {
+        const messageKey = this.getMessageKey(options);
+        // 如果相同key的消息已存在，先移除
+        if (this._instances.has(messageKey)) {
+            this.removeMessage(messageKey);
+        }
+        // 检查数量限制
+        this.removeOldestMessage();
+        const messageElement = document.createElement('pcm-message');
+        messageElement.setAttribute('content', options.content);
+        if (options.type) {
+            messageElement.setAttribute('type', options.type);
+        }
+        if (options.duration !== undefined) {
+            messageElement.setAttribute('duration', options.duration.toString());
+        }
+        const container = this.getContainer();
+        container.appendChild(messageElement);
+        // 创建实例记录
+        const id = this.generateId();
+        const instance = {
+            id,
+            element: messageElement,
+            options: { ...options }
+        };
+        // 设置自动移除定时器
+        const duration = options.duration ?? 3000;
+        if (duration > 0) {
+            instance.timer = window.setTimeout(() => {
+                this.removeMessage(messageKey);
+            }, duration);
+        }
+        // 保存实例
+        this._instances.set(messageKey, instance);
+        return messageElement;
+    }
+    success(content, duration) {
+        const options = typeof content === 'string'
+            ? { content, type: 'success', duration }
+            : { ...content, type: 'success' };
+        this.create(options);
+    }
+    error(content, duration) {
+        const options = typeof content === 'string'
+            ? { content, type: 'error', duration }
+            : { ...content, type: 'error' };
+        this.create(options);
+    }
+    info(content, duration) {
+        const options = typeof content === 'string'
+            ? { content, type: 'info', duration }
+            : { ...content, type: 'info' };
+        this.create(options);
+    }
+    warning(content, duration) {
+        const options = typeof content === 'string'
+            ? { content, type: 'warning', duration }
+            : { ...content, type: 'warning' };
+        this.create(options);
+    }
+    // 清除所有消息
+    clear() {
+        this._instances.forEach((_, key) => {
+            this.removeMessage(key);
+        });
+    }
+    // 清除指定key的消息
+    remove(key) {
+        this.removeMessage(key);
+    }
+    // 设置最大显示数量
+    setMaxCount(count) {
+        this._maxCount = Math.max(1, count);
+    }
+    // 销毁服务（清理资源）
+    destroy() {
+        this.clear();
+        if (this._container && this._container.parentNode) {
+            this._container.parentNode.removeChild(this._container);
+            this._container = null;
+        }
+    }
+}
+// 创建单例实例
+const Message = new MessageService();
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module Charset
+ */
+const VALUES_TO_CHARSET = new Map();
+class Charset {
+  #label;
+  #values;
+  // See: https://en.wikipedia.org/wiki/Extended_Channel_Interpretation
+  static CP437 = new Charset('cp437', 2, 0);
+  static ISO_8859_1 = new Charset('iso-8859-1', 3, 1);
+  static ISO_8859_2 = new Charset('iso-8859-2', 4);
+  static ISO_8859_3 = new Charset('iso-8859-3', 5);
+  static ISO_8859_4 = new Charset('iso-8859-4', 6);
+  static ISO_8859_5 = new Charset('iso-8859-5', 7);
+  static ISO_8859_6 = new Charset('iso-8859-6', 8);
+  static ISO_8859_7 = new Charset('iso-8859-7', 9);
+  static ISO_8859_8 = new Charset('iso-8859-8', 10);
+  static ISO_8859_9 = new Charset('iso-8859-9', 11);
+  static ISO_8859_10 = new Charset('iso-8859-10', 12);
+  static ISO_8859_11 = new Charset('iso-8859-11', 13);
+  static ISO_8859_13 = new Charset('iso-8859-13', 15);
+  static ISO_8859_14 = new Charset('iso-8859-14', 16);
+  static ISO_8859_15 = new Charset('iso-8859-15', 17);
+  static ISO_8859_16 = new Charset('iso-8859-16', 18);
+  static SHIFT_JIS = new Charset('shift-jis', 20);
+  static CP1250 = new Charset('cp1250', 21);
+  static CP1251 = new Charset('cp1251', 22);
+  static CP1252 = new Charset('cp1252', 23);
+  static CP1256 = new Charset('cp1256', 24);
+  static UTF_16BE = new Charset('utf-16be', 25);
+  static UTF_8 = new Charset('utf-8', 26);
+  static ASCII = new Charset('ascii', 27);
+  static BIG5 = new Charset('big5', 28);
+  static GB2312 = new Charset('gb2312', 29);
+  static EUC_KR = new Charset('euc-kr', 30);
+  static GBK = new Charset('gbk', 31);
+  static GB18030 = new Charset('gb18030', 32);
+  static UTF_16LE = new Charset('utf-16le', 33);
+  static UTF_32BE = new Charset('utf-32be', 34);
+  static UTF_32LE = new Charset('utf-32le', 35);
+  static ISO_646_INV = new Charset('iso-646-inv', 170);
+  static BINARY = new Charset('binary', 899);
+  /**
+   * @constructor
+   * @param label The label of charset.
+   * @param values The values of charset.
+   */
+  constructor(label, ...values) {
+    this.#label = label;
+    this.#values = Object.freeze(values);
+    for (const value of values) {
+      if (value >= 0 && value <= 999999 && Number.isInteger(value)) {
+        VALUES_TO_CHARSET.set(value, this);
+      } else {
+        throw new Error('illegal extended channel interpretation value');
+      }
+    }
+  }
+  /**
+   * @property label
+   * @description Get the label of charset.
+   */
+  get label() {
+    return this.#label;
+  }
+  /**
+   * @property values
+   * @description Get the values of charset.
+   */
+  get values() {
+    return this.#values;
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module utils
+ */
+function toBit(value) {
+  return value & 0x01;
+}
+function toInt32(value) {
+  return value | 0;
+}
+function getBitMask(value) {
+  return 1 << getBitOffset(value);
+}
+function getBitOffset(value) {
+  return value & 0x1f;
+}
+// Return the position of the most significant bit set (to one) in the "value". The most
+// significant bit is position 32. If there is no bit set, return 0. Examples:
+// - findMSBSet(0) => 0
+// - findMSBSet(1) => 1
+// - findMSBSet(255) => 8
+function findMSBSet(value) {
+  return 32 - Math.clz32(value);
+}
+// Calculate BCH (Bose-Chaudhuri-Hocquenghem) code for "value" using polynomial "poly". The BCH
+// code is used for encoding type information and version information.
+// Example: Calculation of version information of 7.
+// f(x) is created from 7.
+//   - 7 = 000111 in 6 bits
+//   - f(x) = x^2 + x^1 + x^0
+// g(x) is given by the standard (p. 67)
+//   - g(x) = x^12 + x^11 + x^10 + x^9 + x^8 + x^5 + x^2 + 1
+// Multiply f(x) by x^(18 - 6)
+//   - f'(x) = f(x) * x^(18 - 6)
+//   - f'(x) = x^14 + x^13 + x^12
+// Calculate the remainder of f'(x) / g(x)
+//         x^2
+//         __________________________________________________
+//   g(x) )x^14 + x^13 + x^12
+//         x^14 + x^13 + x^12 + x^11 + x^10 + x^7 + x^4 + x^2
+//         --------------------------------------------------
+//                              x^11 + x^10 + x^7 + x^4 + x^2
+//
+// The remainder is x^11 + x^10 + x^7 + x^4 + x^2
+// Encode it in binary: 110010010100
+// The return value is 0xc94 (1100 1001 0100)
+//
+// Since all coefficients in the polynomials are 1 or 0, we can do the calculation by bit
+// operations. We don't care if coefficients are positive or negative.
+function calculateBCHCode(value, poly) {
+  // If poly is "1 1111 0010 0101" (version info poly), msbSetInPoly is 13. We'll subtract 1
+  // from 13 to make it 12.
+  const msbSetInPoly = findMSBSet(poly);
+  value <<= msbSetInPoly - 1;
+  // Do the division business using exclusive-or operations.
+  while (findMSBSet(value) >= msbSetInPoly) {
+    value ^= poly << (findMSBSet(value) - msbSetInPoly);
+  }
+  // Now the "value" is the remainder (i.e. the BCH code).
+  return value;
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module Mode
+ */
+const VALUES_TO_MODE = new Map();
+class Mode {
+  #bits;
+  #characterCountBitsSet;
+  static TERMINATOR = new Mode([0, 0, 0], 0x00);
+  static NUMERIC = new Mode([10, 12, 14], 0x01);
+  static ALPHANUMERIC = new Mode([9, 11, 13], 0x02);
+  static STRUCTURED_APPEND = new Mode([0, 0, 0], 0x03);
+  static BYTE = new Mode([8, 16, 16], 0x04);
+  static ECI = new Mode([0, 0, 0], 0x07);
+  static KANJI = new Mode([8, 10, 12], 0x08);
+  static FNC1_FIRST_POSITION = new Mode([0, 0, 0], 0x05);
+  static FNC1_SECOND_POSITION = new Mode([0, 0, 0], 0x09);
+  static HANZI = new Mode([8, 10, 12], 0x0d);
+  constructor(characterCountBitsSet, bits) {
+    this.#bits = bits;
+    this.#characterCountBitsSet = new Int32Array(characterCountBitsSet);
+    VALUES_TO_MODE.set(bits, this);
+  }
+  get bits() {
+    return this.#bits;
+  }
+  getCharacterCountBits({ version }) {
+    let offset;
+    if (version <= 9) {
+      offset = 0;
+    } else if (version <= 26) {
+      offset = 1;
+    } else {
+      offset = 2;
+    }
+    return this.#characterCountBitsSet[offset];
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module mask
+ */
+// Penalty weights.
+const N1 = 3;
+const N2 = 3;
+const N3 = 40;
+const N4 = 10;
+// Is dark point.
+function isDark(matrix, x, y) {
+  return matrix.get(x, y) === 1;
+}
+// Helper function for applyMaskPenaltyRule1. We need this for doing this calculation in both
+// horizontal and vertical orders respectively.
+function applyMaskPenaltyRule1Internal(matrix, isVertical) {
+  let penalty = 0;
+  const { size } = matrix;
+  for (let y = 0; y < size; y++) {
+    let prevBit = -1;
+    let numSameBitCells = 0;
+    for (let x = 0; x < size; x++) {
+      const bit = isVertical ? matrix.get(y, x) : matrix.get(x, y);
+      if (bit === prevBit) {
+        numSameBitCells++;
+      } else {
+        if (numSameBitCells >= 5) {
+          penalty += N1 + (numSameBitCells - 5);
+        }
+        // set prev bit.
+        prevBit = bit;
+        // include the cell itself.
+        numSameBitCells = 1;
+      }
+    }
+    if (numSameBitCells >= 5) {
+      penalty += N1 + (numSameBitCells - 5);
+    }
+  }
+  return penalty;
+}
+// Apply mask penalty rule 1 and return the penalty. Find repetitive cells with the same color and
+// give penalty to them. Example: 00000 or 11111.
+function applyMaskPenaltyRule1(matrix) {
+  return applyMaskPenaltyRule1Internal(matrix) + applyMaskPenaltyRule1Internal(matrix, true);
+}
+// Apply mask penalty rule 2 and return the penalty. Find 2x2 blocks with the same color and give
+// penalty to them. This is actually equivalent to the spec's rule, which is to find MxN blocks and give a
+// penalty proportional to (M-1)x(N-1), because this is the number of 2x2 blocks inside such a block.
+function applyMaskPenaltyRule2(matrix) {
+  let penalty = 0;
+  const size = matrix.size - 1;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const bit = matrix.get(x, y);
+      if (
+        // Find 2x2 blocks with the same color.
+        bit === matrix.get(x + 1, y) &&
+        bit === matrix.get(x, y + 1) &&
+        bit === matrix.get(x + 1, y + 1)
+      ) {
+        penalty += N2;
+      }
+    }
+  }
+  return penalty;
+}
+// Is is four white, check on horizontal and vertical.
+function isFourWhite(matrix, offset, from, to, isVertical) {
+  if (from < 0 || to > matrix.size) {
+    return false;
+  }
+  for (let i = from; i < to; i++) {
+    if (isVertical ? isDark(matrix, offset, i) : isDark(matrix, i, offset)) {
+      return false;
+    }
+  }
+  return true;
+}
+// Apply mask penalty rule 3 and return the penalty. Find consecutive runs of 1:1:3:1:1:4
+// starting with black, or 4:1:1:3:1:1 starting with white, and give penalty to them. If we
+// find patterns like 000010111010000, we give penalty once.
+function applyMaskPenaltyRule3(matrix) {
+  let numPenalties = 0;
+  const { size } = matrix;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      if (
+        // Find consecutive runs of 1:1:3:1:1:4 or 4:1:1:3:1:1, patterns like 000010111010000.
+        x + 6 < size &&
+        isDark(matrix, x, y) &&
+        !isDark(matrix, x + 1, y) &&
+        isDark(matrix, x + 2, y) &&
+        isDark(matrix, x + 3, y) &&
+        isDark(matrix, x + 4, y) &&
+        !isDark(matrix, x + 5, y) &&
+        isDark(matrix, x + 6, y) &&
+        (isFourWhite(matrix, y, x - 4, x) || isFourWhite(matrix, y, x + 7, x + 11))
+      ) {
+        numPenalties++;
+      }
+      if (
+        // Find consecutive runs of 1:1:3:1:1:4 or 4:1:1:3:1:1, patterns like 000010111010000.
+        y + 6 < size &&
+        isDark(matrix, x, y) &&
+        !isDark(matrix, x, y + 1) &&
+        isDark(matrix, x, y + 2) &&
+        isDark(matrix, x, y + 3) &&
+        isDark(matrix, x, y + 4) &&
+        !isDark(matrix, x, y + 5) &&
+        isDark(matrix, x, y + 6) &&
+        (isFourWhite(matrix, x, y - 4, y, true) || isFourWhite(matrix, x, y + 7, y + 11, true))
+      ) {
+        numPenalties++;
+      }
+    }
+  }
+  return numPenalties * N3;
+}
+// Apply mask penalty rule 4 and return the penalty. Calculate the ratio of dark cells and give
+// penalty if the ratio is far from 50%. It gives 10 penalty for 5% distance.
+function applyMaskPenaltyRule4(matrix) {
+  let numDarkCells = 0;
+  const { size } = matrix;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      if (isDark(matrix, x, y)) {
+        numDarkCells++;
+      }
+    }
+  }
+  const numTotalCells = size * size;
+  const fivePercentVariances = toInt32((Math.abs(numDarkCells * 2 - numTotalCells) * 10) / numTotalCells);
+  return fivePercentVariances * N4;
+}
+// The mask penalty calculation is complicated. See Table 11 of ISO/IEC 18004:2015(E)(p.54) for details.
+// Basically it applies four rules and summate all penalties.
+function calculateMaskPenalty(matrix) {
+  return (
+    applyMaskPenaltyRule1(matrix) +
+    applyMaskPenaltyRule2(matrix) +
+    applyMaskPenaltyRule3(matrix) +
+    applyMaskPenaltyRule4(matrix)
+  );
+}
+// Return is apply mask at "x" and "y". See 7.8 of ISO/IEC 18004:2015(E)(p.50) for mask pattern conditions.
+function isApplyMask(mask, x, y) {
+  let temporary;
+  let intermediate;
+  switch (mask) {
+    case 0:
+      intermediate = (y + x) & 0x01;
+      break;
+    case 1:
+      intermediate = y & 0x01;
+      break;
+    case 2:
+      intermediate = x % 3;
+      break;
+    case 3:
+      intermediate = (y + x) % 3;
+      break;
+    case 4:
+      intermediate = (toInt32(y / 2) + toInt32(x / 3)) & 0x01;
+      break;
+    case 5:
+      temporary = y * x;
+      intermediate = (temporary & 0x01) + (temporary % 3);
+      break;
+    case 6:
+      temporary = y * x;
+      intermediate = ((temporary & 0x01) + (temporary % 3)) & 0x01;
+      break;
+    case 7:
+      intermediate = (((y * x) % 3) + ((y + x) & 0x01)) & 0x01;
+      break;
+    default:
+      throw new Error(`illegal mask: ${mask}`);
+  }
+  return intermediate === 0;
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module ECLevel
+ */
+const VALUES_TO_ECLEVEL = new Map();
+class ECLevel {
+  #name;
+  #bits;
+  #level;
+  // L = ~7% correction.
+  static L = new ECLevel('L', 0, 0x01);
+  // L = ~15% correction.
+  static M = new ECLevel('M', 1, 0x00);
+  // L = ~25% correction.
+  static Q = new ECLevel('Q', 2, 0x03);
+  // L = ~30% correction.
+  static H = new ECLevel('H', 3, 0x02);
+  constructor(name, level, bits) {
+    this.#bits = bits;
+    this.#name = name;
+    this.#level = level;
+    VALUES_TO_ECLEVEL.set(bits, this);
+  }
+  get bits() {
+    return this.#bits;
+  }
+  get name() {
+    return this.#name;
+  }
+  get level() {
+    return this.#level;
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module ECB
+ */
+class ECB {
+  #count;
+  #numDataCodewords;
+  constructor(count, numDataCodewords) {
+    this.#count = count;
+    this.#numDataCodewords = numDataCodewords;
+  }
+  get count() {
+    return this.#count;
+  }
+  get numDataCodewords() {
+    return this.#numDataCodewords;
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module ECBlocks
+ */
+class ECBlocks {
+  #ecBlocks;
+  #numTotalCodewords;
+  #numTotalECCodewords;
+  #numTotalDataCodewords;
+  #numECCodewordsPerBlock;
+  constructor(numECCodewordsPerBlock, ...ecBlocks) {
+    let numBlocks = 0;
+    let numTotalDataCodewords = 0;
+    for (const { count, numDataCodewords } of ecBlocks) {
+      numBlocks += count;
+      numTotalDataCodewords += numDataCodewords * count;
+    }
+    const numTotalECCodewords = numECCodewordsPerBlock * numBlocks;
+    this.#ecBlocks = ecBlocks;
+    this.#numTotalECCodewords = numTotalECCodewords;
+    this.#numTotalDataCodewords = numTotalDataCodewords;
+    this.#numECCodewordsPerBlock = numECCodewordsPerBlock;
+    this.#numTotalCodewords = numTotalDataCodewords + numTotalECCodewords;
+  }
+  get ecBlocks() {
+    return this.#ecBlocks;
+  }
+  get numTotalCodewords() {
+    return this.#numTotalCodewords;
+  }
+  get numTotalECCodewords() {
+    return this.#numTotalECCodewords;
+  }
+  get numTotalDataCodewords() {
+    return this.#numTotalDataCodewords;
+  }
+  get numECCodewordsPerBlock() {
+    return this.#numECCodewordsPerBlock;
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+class Version {
+  #size;
+  #version;
+  #ecBlocks;
+  #alignmentPatterns;
+  constructor(version, alignmentPatterns, ...ecBlocks) {
+    this.#version = version;
+    this.#ecBlocks = ecBlocks;
+    this.#size = 17 + 4 * version;
+    this.#alignmentPatterns = alignmentPatterns;
+  }
+  get size() {
+    return this.#size;
+  }
+  get version() {
+    return this.#version;
+  }
+  get alignmentPatterns() {
+    return this.#alignmentPatterns;
+  }
+  getECBlocks({ level }) {
+    return this.#ecBlocks[level];
+  }
+}
+const VERSIONS = [
+  new Version(
+    1,
+    [],
+    new ECBlocks(7, new ECB(1, 19)),
+    new ECBlocks(10, new ECB(1, 16)),
+    new ECBlocks(13, new ECB(1, 13)),
+    new ECBlocks(17, new ECB(1, 9))
+  ),
+  new Version(
+    2,
+    [6, 18],
+    new ECBlocks(10, new ECB(1, 34)),
+    new ECBlocks(16, new ECB(1, 28)),
+    new ECBlocks(22, new ECB(1, 22)),
+    new ECBlocks(28, new ECB(1, 16))
+  ),
+  new Version(
+    3,
+    [6, 22],
+    new ECBlocks(15, new ECB(1, 55)),
+    new ECBlocks(26, new ECB(1, 44)),
+    new ECBlocks(18, new ECB(2, 17)),
+    new ECBlocks(22, new ECB(2, 13))
+  ),
+  new Version(
+    4,
+    [6, 26],
+    new ECBlocks(20, new ECB(1, 80)),
+    new ECBlocks(18, new ECB(2, 32)),
+    new ECBlocks(26, new ECB(2, 24)),
+    new ECBlocks(16, new ECB(4, 9))
+  ),
+  new Version(
+    5,
+    [6, 30],
+    new ECBlocks(26, new ECB(1, 108)),
+    new ECBlocks(24, new ECB(2, 43)),
+    new ECBlocks(18, new ECB(2, 15), new ECB(2, 16)),
+    new ECBlocks(22, new ECB(2, 11), new ECB(2, 12))
+  ),
+  new Version(
+    6,
+    [6, 34],
+    new ECBlocks(18, new ECB(2, 68)),
+    new ECBlocks(16, new ECB(4, 27)),
+    new ECBlocks(24, new ECB(4, 19)),
+    new ECBlocks(28, new ECB(4, 15))
+  ),
+  new Version(
+    7,
+    [6, 22, 38],
+    new ECBlocks(20, new ECB(2, 78)),
+    new ECBlocks(18, new ECB(4, 31)),
+    new ECBlocks(18, new ECB(2, 14), new ECB(4, 15)),
+    new ECBlocks(26, new ECB(4, 13), new ECB(1, 14))
+  ),
+  new Version(
+    8,
+    [6, 24, 42],
+    new ECBlocks(24, new ECB(2, 97)),
+    new ECBlocks(22, new ECB(2, 38), new ECB(2, 39)),
+    new ECBlocks(22, new ECB(4, 18), new ECB(2, 19)),
+    new ECBlocks(26, new ECB(4, 14), new ECB(2, 15))
+  ),
+  new Version(
+    9,
+    [6, 26, 46],
+    new ECBlocks(30, new ECB(2, 116)),
+    new ECBlocks(22, new ECB(3, 36), new ECB(2, 37)),
+    new ECBlocks(20, new ECB(4, 16), new ECB(4, 17)),
+    new ECBlocks(24, new ECB(4, 12), new ECB(4, 13))
+  ),
+  new Version(
+    10,
+    [6, 28, 50],
+    new ECBlocks(18, new ECB(2, 68), new ECB(2, 69)),
+    new ECBlocks(26, new ECB(4, 43), new ECB(1, 44)),
+    new ECBlocks(24, new ECB(6, 19), new ECB(2, 20)),
+    new ECBlocks(28, new ECB(6, 15), new ECB(2, 16))
+  ),
+  new Version(
+    11,
+    [6, 30, 54],
+    new ECBlocks(20, new ECB(4, 81)),
+    new ECBlocks(30, new ECB(1, 50), new ECB(4, 51)),
+    new ECBlocks(28, new ECB(4, 22), new ECB(4, 23)),
+    new ECBlocks(24, new ECB(3, 12), new ECB(8, 13))
+  ),
+  new Version(
+    12,
+    [6, 32, 58],
+    new ECBlocks(24, new ECB(2, 92), new ECB(2, 93)),
+    new ECBlocks(22, new ECB(6, 36), new ECB(2, 37)),
+    new ECBlocks(26, new ECB(4, 20), new ECB(6, 21)),
+    new ECBlocks(28, new ECB(7, 14), new ECB(4, 15))
+  ),
+  new Version(
+    13,
+    [6, 34, 62],
+    new ECBlocks(26, new ECB(4, 107)),
+    new ECBlocks(22, new ECB(8, 37), new ECB(1, 38)),
+    new ECBlocks(24, new ECB(8, 20), new ECB(4, 21)),
+    new ECBlocks(22, new ECB(12, 11), new ECB(4, 12))
+  ),
+  new Version(
+    14,
+    [6, 26, 46, 66],
+    new ECBlocks(30, new ECB(3, 115), new ECB(1, 116)),
+    new ECBlocks(24, new ECB(4, 40), new ECB(5, 41)),
+    new ECBlocks(20, new ECB(11, 16), new ECB(5, 17)),
+    new ECBlocks(24, new ECB(11, 12), new ECB(5, 13))
+  ),
+  new Version(
+    15,
+    [6, 26, 48, 70],
+    new ECBlocks(22, new ECB(5, 87), new ECB(1, 88)),
+    new ECBlocks(24, new ECB(5, 41), new ECB(5, 42)),
+    new ECBlocks(30, new ECB(5, 24), new ECB(7, 25)),
+    new ECBlocks(24, new ECB(11, 12), new ECB(7, 13))
+  ),
+  new Version(
+    16,
+    [6, 26, 50, 74],
+    new ECBlocks(24, new ECB(5, 98), new ECB(1, 99)),
+    new ECBlocks(28, new ECB(7, 45), new ECB(3, 46)),
+    new ECBlocks(24, new ECB(15, 19), new ECB(2, 20)),
+    new ECBlocks(30, new ECB(3, 15), new ECB(13, 16))
+  ),
+  new Version(
+    17,
+    [6, 30, 54, 78],
+    new ECBlocks(28, new ECB(1, 107), new ECB(5, 108)),
+    new ECBlocks(28, new ECB(10, 46), new ECB(1, 47)),
+    new ECBlocks(28, new ECB(1, 22), new ECB(15, 23)),
+    new ECBlocks(28, new ECB(2, 14), new ECB(17, 15))
+  ),
+  new Version(
+    18,
+    [6, 30, 56, 82],
+    new ECBlocks(30, new ECB(5, 120), new ECB(1, 121)),
+    new ECBlocks(26, new ECB(9, 43), new ECB(4, 44)),
+    new ECBlocks(28, new ECB(17, 22), new ECB(1, 23)),
+    new ECBlocks(28, new ECB(2, 14), new ECB(19, 15))
+  ),
+  new Version(
+    19,
+    [6, 30, 58, 86],
+    new ECBlocks(28, new ECB(3, 113), new ECB(4, 114)),
+    new ECBlocks(26, new ECB(3, 44), new ECB(11, 45)),
+    new ECBlocks(26, new ECB(17, 21), new ECB(4, 22)),
+    new ECBlocks(26, new ECB(9, 13), new ECB(16, 14))
+  ),
+  new Version(
+    20,
+    [6, 34, 62, 90],
+    new ECBlocks(28, new ECB(3, 107), new ECB(5, 108)),
+    new ECBlocks(26, new ECB(3, 41), new ECB(13, 42)),
+    new ECBlocks(30, new ECB(15, 24), new ECB(5, 25)),
+    new ECBlocks(28, new ECB(15, 15), new ECB(10, 16))
+  ),
+  new Version(
+    21,
+    [6, 28, 50, 72, 94],
+    new ECBlocks(28, new ECB(4, 116), new ECB(4, 117)),
+    new ECBlocks(26, new ECB(17, 42)),
+    new ECBlocks(28, new ECB(17, 22), new ECB(6, 23)),
+    new ECBlocks(30, new ECB(19, 16), new ECB(6, 17))
+  ),
+  new Version(
+    22,
+    [6, 26, 50, 74, 98],
+    new ECBlocks(28, new ECB(2, 111), new ECB(7, 112)),
+    new ECBlocks(28, new ECB(17, 46)),
+    new ECBlocks(30, new ECB(7, 24), new ECB(16, 25)),
+    new ECBlocks(24, new ECB(34, 13))
+  ),
+  new Version(
+    23,
+    [6, 30, 54, 78, 102],
+    new ECBlocks(30, new ECB(4, 121), new ECB(5, 122)),
+    new ECBlocks(28, new ECB(4, 47), new ECB(14, 48)),
+    new ECBlocks(30, new ECB(11, 24), new ECB(14, 25)),
+    new ECBlocks(30, new ECB(16, 15), new ECB(14, 16))
+  ),
+  new Version(
+    24,
+    [6, 28, 54, 80, 106],
+    new ECBlocks(30, new ECB(6, 117), new ECB(4, 118)),
+    new ECBlocks(28, new ECB(6, 45), new ECB(14, 46)),
+    new ECBlocks(30, new ECB(11, 24), new ECB(16, 25)),
+    new ECBlocks(30, new ECB(30, 16), new ECB(2, 17))
+  ),
+  new Version(
+    25,
+    [6, 32, 58, 84, 110],
+    new ECBlocks(26, new ECB(8, 106), new ECB(4, 107)),
+    new ECBlocks(28, new ECB(8, 47), new ECB(13, 48)),
+    new ECBlocks(30, new ECB(7, 24), new ECB(22, 25)),
+    new ECBlocks(30, new ECB(22, 15), new ECB(13, 16))
+  ),
+  new Version(
+    26,
+    [6, 30, 58, 86, 114],
+    new ECBlocks(28, new ECB(10, 114), new ECB(2, 115)),
+    new ECBlocks(28, new ECB(19, 46), new ECB(4, 47)),
+    new ECBlocks(28, new ECB(28, 22), new ECB(6, 23)),
+    new ECBlocks(30, new ECB(33, 16), new ECB(4, 17))
+  ),
+  new Version(
+    27,
+    [6, 34, 62, 90, 118],
+    new ECBlocks(30, new ECB(8, 122), new ECB(4, 123)),
+    new ECBlocks(28, new ECB(22, 45), new ECB(3, 46)),
+    new ECBlocks(30, new ECB(8, 23), new ECB(26, 24)),
+    new ECBlocks(30, new ECB(12, 15), new ECB(28, 16))
+  ),
+  new Version(
+    28,
+    [6, 26, 50, 74, 98, 122],
+    new ECBlocks(30, new ECB(3, 117), new ECB(10, 118)),
+    new ECBlocks(28, new ECB(3, 45), new ECB(23, 46)),
+    new ECBlocks(30, new ECB(4, 24), new ECB(31, 25)),
+    new ECBlocks(30, new ECB(11, 15), new ECB(31, 16))
+  ),
+  new Version(
+    29,
+    [6, 30, 54, 78, 102, 126],
+    new ECBlocks(30, new ECB(7, 116), new ECB(7, 117)),
+    new ECBlocks(28, new ECB(21, 45), new ECB(7, 46)),
+    new ECBlocks(30, new ECB(1, 23), new ECB(37, 24)),
+    new ECBlocks(30, new ECB(19, 15), new ECB(26, 16))
+  ),
+  new Version(
+    30,
+    [6, 26, 52, 78, 104, 130],
+    new ECBlocks(30, new ECB(5, 115), new ECB(10, 116)),
+    new ECBlocks(28, new ECB(19, 47), new ECB(10, 48)),
+    new ECBlocks(30, new ECB(15, 24), new ECB(25, 25)),
+    new ECBlocks(30, new ECB(23, 15), new ECB(25, 16))
+  ),
+  new Version(
+    31,
+    [6, 30, 56, 82, 108, 134],
+    new ECBlocks(30, new ECB(13, 115), new ECB(3, 116)),
+    new ECBlocks(28, new ECB(2, 46), new ECB(29, 47)),
+    new ECBlocks(30, new ECB(42, 24), new ECB(1, 25)),
+    new ECBlocks(30, new ECB(23, 15), new ECB(28, 16))
+  ),
+  new Version(
+    32,
+    [6, 34, 60, 86, 112, 138],
+    new ECBlocks(30, new ECB(17, 115)),
+    new ECBlocks(28, new ECB(10, 46), new ECB(23, 47)),
+    new ECBlocks(30, new ECB(10, 24), new ECB(35, 25)),
+    new ECBlocks(30, new ECB(19, 15), new ECB(35, 16))
+  ),
+  new Version(
+    33,
+    [6, 30, 58, 86, 114, 142],
+    new ECBlocks(30, new ECB(17, 115), new ECB(1, 116)),
+    new ECBlocks(28, new ECB(14, 46), new ECB(21, 47)),
+    new ECBlocks(30, new ECB(29, 24), new ECB(19, 25)),
+    new ECBlocks(30, new ECB(11, 15), new ECB(46, 16))
+  ),
+  new Version(
+    34,
+    [6, 34, 62, 90, 118, 146],
+    new ECBlocks(30, new ECB(13, 115), new ECB(6, 116)),
+    new ECBlocks(28, new ECB(14, 46), new ECB(23, 47)),
+    new ECBlocks(30, new ECB(44, 24), new ECB(7, 25)),
+    new ECBlocks(30, new ECB(59, 16), new ECB(1, 17))
+  ),
+  new Version(
+    35,
+    [6, 30, 54, 78, 102, 126, 150],
+    new ECBlocks(30, new ECB(12, 121), new ECB(7, 122)),
+    new ECBlocks(28, new ECB(12, 47), new ECB(26, 48)),
+    new ECBlocks(30, new ECB(39, 24), new ECB(14, 25)),
+    new ECBlocks(30, new ECB(22, 15), new ECB(41, 16))
+  ),
+  new Version(
+    36,
+    [6, 24, 50, 76, 102, 128, 154],
+    new ECBlocks(30, new ECB(6, 121), new ECB(14, 122)),
+    new ECBlocks(28, new ECB(6, 47), new ECB(34, 48)),
+    new ECBlocks(30, new ECB(46, 24), new ECB(10, 25)),
+    new ECBlocks(30, new ECB(2, 15), new ECB(64, 16))
+  ),
+  new Version(
+    37,
+    [6, 28, 54, 80, 106, 132, 158],
+    new ECBlocks(30, new ECB(17, 122), new ECB(4, 123)),
+    new ECBlocks(28, new ECB(29, 46), new ECB(14, 47)),
+    new ECBlocks(30, new ECB(49, 24), new ECB(10, 25)),
+    new ECBlocks(30, new ECB(24, 15), new ECB(46, 16))
+  ),
+  new Version(
+    38,
+    [6, 32, 58, 84, 110, 136, 162],
+    new ECBlocks(30, new ECB(4, 122), new ECB(18, 123)),
+    new ECBlocks(28, new ECB(13, 46), new ECB(32, 47)),
+    new ECBlocks(30, new ECB(48, 24), new ECB(14, 25)),
+    new ECBlocks(30, new ECB(42, 15), new ECB(32, 16))
+  ),
+  new Version(
+    39,
+    [6, 26, 54, 82, 110, 138, 166],
+    new ECBlocks(30, new ECB(20, 117), new ECB(4, 118)),
+    new ECBlocks(28, new ECB(40, 47), new ECB(7, 48)),
+    new ECBlocks(30, new ECB(43, 24), new ECB(22, 25)),
+    new ECBlocks(30, new ECB(10, 15), new ECB(67, 16))
+  ),
+  new Version(
+    40,
+    [6, 30, 58, 86, 114, 142, 170],
+    new ECBlocks(30, new ECB(19, 118), new ECB(6, 119)),
+    new ECBlocks(28, new ECB(18, 47), new ECB(31, 48)),
+    new ECBlocks(30, new ECB(34, 24), new ECB(34, 25)),
+    new ECBlocks(30, new ECB(20, 15), new ECB(61, 16))
+  )
+];
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module Polynomial
+ */
+class Polynomial {
+  #field;
+  #coefficients;
+  constructor(field, coefficients) {
+    const { length } = coefficients;
+    if (length <= 0) {
+      throw new Error('polynomial coefficients cannot empty');
+    }
+    this.#field = field;
+    if (length > 1 && coefficients[0] === 0) {
+      // Leading term must be non-zero for anything except the constant polynomial "0".
+      let firstNonZero = 1;
+      while (firstNonZero < length && coefficients[firstNonZero] === 0) {
+        firstNonZero++;
+      }
+      if (firstNonZero === length) {
+        this.#coefficients = new Int32Array([0]);
+      } else {
+        const array = new Int32Array(length - firstNonZero);
+        array.set(coefficients.subarray(firstNonZero));
+        this.#coefficients = array;
+      }
+    } else {
+      this.#coefficients = coefficients;
+    }
+  }
+  get coefficients() {
+    return this.#coefficients;
+  }
+  isZero() {
+    return this.#coefficients[0] === 0;
+  }
+  getDegree() {
+    return this.#coefficients.length - 1;
+  }
+  getCoefficient(degree) {
+    const coefficients = this.#coefficients;
+    return coefficients[coefficients.length - 1 - degree];
+  }
+  evaluate(a) {
+    if (a === 0) {
+      // Just return the x^0 coefficient.
+      return this.getCoefficient(0);
+    }
+    let result;
+    const coefficients = this.#coefficients;
+    if (a === 1) {
+      // Just the sum of the coefficients.
+      result = 0;
+      for (const coefficient of coefficients) {
+        result ^= coefficient;
+      }
+      return result;
+    }
+    [result] = coefficients;
+    const field = this.#field;
+    const { length } = coefficients;
+    for (let i = 1; i < length; i++) {
+      result = field.multiply(a, result) ^ coefficients[i];
+    }
+    return result;
+  }
+  multiply(other) {
+    const field = this.#field;
+    const coefficients = this.#coefficients;
+    const { length } = coefficients;
+    if (other instanceof Polynomial) {
+      if (this.isZero() || other.isZero()) {
+        return field.zero;
+      }
+      const otherCoefficients = other.#coefficients;
+      const otherLength = otherCoefficients.length;
+      const product = new Int32Array(length + otherLength - 1);
+      for (let i = 0; i < length; i++) {
+        const coefficient = coefficients[i];
+        for (let j = 0; j < otherLength; j++) {
+          product[i + j] ^= field.multiply(coefficient, otherCoefficients[j]);
+        }
+      }
+      return new Polynomial(field, product);
+    }
+    if (other === 0) {
+      return field.zero;
+    }
+    if (other === 1) {
+      return this;
+    }
+    const product = new Int32Array(length);
+    for (let i = 0; i < length; i++) {
+      product[i] = field.multiply(coefficients[i], other);
+    }
+    return new Polynomial(field, product);
+  }
+  multiplyByMonomial(degree, coefficient) {
+    const field = this.#field;
+    if (coefficient === 0) {
+      return field.zero;
+    }
+    const coefficients = this.#coefficients;
+    const { length } = coefficients;
+    const product = new Int32Array(length + degree);
+    for (let i = 0; i < length; i++) {
+      product[i] = field.multiply(coefficients[i], coefficient);
+    }
+    return new Polynomial(field, product);
+  }
+  addOrSubtract(other) {
+    if (this.isZero()) {
+      return other;
+    }
+    if (other.isZero()) {
+      return this;
+    }
+    let largerCoefficients = other.#coefficients;
+    let largerLength = largerCoefficients.length;
+    let smallerCoefficients = this.#coefficients;
+    let smallerLength = smallerCoefficients.length;
+    if (largerLength < smallerLength) {
+      [largerLength, smallerLength] = [smallerLength, largerLength];
+      [largerCoefficients, smallerCoefficients] = [smallerCoefficients, largerCoefficients];
+    }
+    // Diff index offset.
+    const offset = largerLength - smallerLength;
+    const coefficients = new Int32Array(largerLength);
+    // Copy high-order terms only found in higher-degree polynomial's coefficients.
+    coefficients.set(largerCoefficients.subarray(0, offset));
+    for (let i = offset; i < largerLength; i++) {
+      coefficients[i] = smallerCoefficients[i - offset] ^ largerCoefficients[i];
+    }
+    return new Polynomial(this.#field, coefficients);
+  }
+  divide(other) {
+    const field = this.#field;
+    let quotient = field.zero;
+    let remainder = this;
+    const denominatorLeadingTerm = other.getCoefficient(other.getDegree());
+    const invertDenominatorLeadingTerm = field.invert(denominatorLeadingTerm);
+    while (remainder.getDegree() >= other.getDegree() && !remainder.isZero()) {
+      const remainderDegree = remainder.getDegree();
+      const degreeDiff = remainderDegree - other.getDegree();
+      const scale = field.multiply(remainder.getCoefficient(remainderDegree), invertDenominatorLeadingTerm);
+      const term = other.multiplyByMonomial(degreeDiff, scale);
+      const iterationQuotient = field.buildPolynomial(degreeDiff, scale);
+      quotient = quotient.addOrSubtract(iterationQuotient);
+      remainder = remainder.addOrSubtract(term);
+    }
+    return [quotient, remainder];
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module GaloisField
+ */
+class GaloisField {
+  #size;
+  #one;
+  #zero;
+  #generator;
+  #expTable;
+  #logTable;
+  constructor(primitive, size, generator) {
+    let x = 1;
+    const expTable = new Int32Array(size);
+    for (let i = 0; i < size; i++) {
+      expTable[i] = x;
+      // We're assuming the generator alpha is 2.
+      x *= 2;
+      if (x >= size) {
+        x ^= primitive;
+        x &= size - 1;
+      }
+    }
+    const logTable = new Int32Array(size);
+    for (let i = 0, length = size - 1; i < length; i++) {
+      logTable[expTable[i]] = i;
+    }
+    this.#size = size;
+    this.#expTable = expTable;
+    this.#logTable = logTable;
+    this.#generator = generator;
+    this.#one = new Polynomial(this, new Int32Array([1]));
+    this.#zero = new Polynomial(this, new Int32Array([0]));
+  }
+  get size() {
+    return this.#size;
+  }
+  get one() {
+    return this.#one;
+  }
+  get zero() {
+    return this.#zero;
+  }
+  get generator() {
+    return this.#generator;
+  }
+  exp(a) {
+    return this.#expTable[a];
+  }
+  log(a) {
+    return this.#logTable[a];
+  }
+  invert(a) {
+    return this.#expTable[this.#size - this.#logTable[a] - 1];
+  }
+  multiply(a, b) {
+    if (a === 0 || b === 0) {
+      return 0;
+    }
+    const logTable = this.#logTable;
+    return this.#expTable[(logTable[a] + logTable[b]) % (this.#size - 1)];
+  }
+  buildPolynomial(degree, coefficient) {
+    if (coefficient === 0) {
+      return this.#zero;
+    }
+    const coefficients = new Int32Array(degree + 1);
+    coefficients[0] = coefficient;
+    return new Polynomial(this, coefficients);
+  }
+}
+const QR_CODE_FIELD_256 = new GaloisField(0x011d, 256, 0);
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module index
+ */
+function getUnicodeCodes(content, maxCode) {
+  const bytes = [];
+  for (const character of content) {
+    const code = character.codePointAt(0);
+    // If gt max code, push "?".
+    bytes.push(code == null || code > maxCode ? 63 : code);
+  }
+  return new Uint8Array(bytes);
+}
+function encode$1(content, charset) {
+  switch (charset) {
+    case Charset.ASCII:
+      return getUnicodeCodes(content, 0x7f);
+    case Charset.ISO_8859_1:
+      return getUnicodeCodes(content, 0xff);
+    case Charset.UTF_8:
+      return new TextEncoder().encode(content);
+    default:
+      throw Error(`built-in encode not support charset: ${charset.label}`);
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module BitArray
+ */
+const LOAD_FACTOR = 0.75;
+function offset(index) {
+  return toInt32(index / 32);
+}
+function makeArray(length) {
+  return new Int32Array(Math.ceil(length / 32));
+}
+class BitArray {
+  #length;
+  #bits;
+  constructor(length = 0) {
+    this.#length = length;
+    this.#bits = makeArray(length);
+  }
+  #alloc(length) {
+    const bits = this.#bits;
+    if (length > bits.length * 32) {
+      const array = makeArray(Math.ceil(length / LOAD_FACTOR));
+      array.set(bits);
+      this.#bits = array;
+    }
+    this.#length = length;
+  }
+  get length() {
+    return this.#length;
+  }
+  get byteLength() {
+    return Math.ceil(this.#length / 8);
+  }
+  set(index) {
+    this.#bits[offset(index)] |= getBitMask(index);
+  }
+  get(index) {
+    return toBit(this.#bits[offset(index)] >>> getBitOffset(index));
+  }
+  xor(mask) {
+    const bits = this.#bits;
+    const maskBits = mask.#bits;
+    const length = Math.min(this.#length, mask.#length);
+    for (let i = 0; i < length; i++) {
+      // The last int could be incomplete (i.e. not have 32 bits in
+      // it) but there is no problem since 0 XOR 0 == 0.
+      bits[i] ^= maskBits[i];
+    }
+  }
+  append(value, length = 1) {
+    let index = this.#length;
+    if (value instanceof BitArray) {
+      length = value.#length;
+      this.#alloc(index + length);
+      for (let i = 0; i < length; i++) {
+        if (value.get(i) !== 0) {
+          this.set(index);
+        }
+        index++;
+      }
+    } else {
+      this.#alloc(index + length);
+      for (let i = length - 1; i >= 0; i--) {
+        if (toBit(value >>> i) !== 0) {
+          this.set(index);
+        }
+        index++;
+      }
+    }
+  }
+  writeToUint8Array(bitOffset, target, byteOffset, byteLength) {
+    for (let i = 0; i < byteLength; i++) {
+      let byte = 0;
+      for (let j = 0; j < 8; j++) {
+        if (this.get(bitOffset++) !== 0) {
+          byte |= 1 << (7 - j);
+        }
+      }
+      target[byteOffset + i] = byte;
+    }
+  }
+  clear() {
+    this.#bits.fill(0);
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module ByteMatrix
+ */
+class ByteMatrix {
+  #size;
+  #bytes;
+  constructor(size) {
+    this.#size = size;
+    this.#bytes = new Int8Array(size * size);
+  }
+  get size() {
+    return this.#size;
+  }
+  set(x, y, value) {
+    this.#bytes[y * this.#size + x] = value;
+  }
+  get(x, y) {
+    return this.#bytes[y * this.#size + x];
+  }
+  clear(value) {
+    this.#bytes.fill(value);
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module matrix
+ */
+// Format information poly: 101 0011 0111.
+const FORMAT_INFO_POLY = 0x537;
+// Format information mask.
+const FORMAT_INFO_MASK = 0x5412;
+// Version information poly: 1 1111 0010 0101.
+const VERSION_INFO_POLY = 0x1f25;
+// Finder pattern shape.
+const FINDER_PATTERN_SHAPE = [
+  [1, 1, 1, 1, 1, 1, 1],
+  [1, 0, 0, 0, 0, 0, 1],
+  [1, 0, 1, 1, 1, 0, 1],
+  [1, 0, 1, 1, 1, 0, 1],
+  [1, 0, 1, 1, 1, 0, 1],
+  [1, 0, 0, 0, 0, 0, 1],
+  [1, 1, 1, 1, 1, 1, 1]
+];
+// Alignment pattern shape.
+const ALIGNMENT_PATTERN_SHAPE = [
+  [1, 1, 1, 1, 1],
+  [1, 0, 0, 0, 1],
+  [1, 0, 1, 0, 1],
+  [1, 0, 0, 0, 1],
+  [1, 1, 1, 1, 1]
+];
+// Format information coordinates.
+const FORMAT_INFO_COORDINATES = [
+  [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]
+];
+// Is empty point.
+function isEmpty(matrix, x, y) {
+  return matrix.get(x, y) === -1;
+}
+function embedFinderPattern(matrix, x, y) {
+  for (let i = 0; i < 7; i++) {
+    const pattern = FINDER_PATTERN_SHAPE[i];
+    for (let j = 0; j < 7; j++) {
+      matrix.set(x + j, y + i, pattern[j]);
+    }
+  }
+}
+function embedHorizontalSeparator(matrix, x, y) {
+  for (let j = 0; j < 8; j++) {
+    matrix.set(x + j, y, 0);
+  }
+}
+function embedVerticalSeparator(matrix, x, y) {
+  for (let i = 0; i < 7; i++) {
+    matrix.set(x, y + i, 0);
+  }
+}
+// Embed finder patterns and surrounding vertical/horizontal separators.
+function embedFinderPatternsAndSeparators(matrix) {
+  // Embed three big squares at corners.
+  const pdpWidth = 7;
+  // Embed horizontal separation patterns around the squares.
+  const hspWidth = 8;
+  // Embed vertical separation patterns around the squares.
+  const vspHeight = 7;
+  // Matrix width
+  const { size } = matrix;
+  // Left top corner.
+  embedFinderPattern(matrix, 0, 0);
+  // Right top corner.
+  embedFinderPattern(matrix, size - pdpWidth, 0);
+  // Left bottom corner.
+  embedFinderPattern(matrix, 0, size - pdpWidth);
+  // Left top corner.
+  embedHorizontalSeparator(matrix, 0, hspWidth - 1);
+  // Right top corner.
+  embedHorizontalSeparator(matrix, size - hspWidth, hspWidth - 1);
+  // Left bottom corner.
+  embedHorizontalSeparator(matrix, 0, size - hspWidth);
+  // Left top corner.
+  embedVerticalSeparator(matrix, vspHeight, 0);
+  // Right top corner.
+  embedVerticalSeparator(matrix, size - vspHeight - 1, 0);
+  // Left bottom corner.
+  embedVerticalSeparator(matrix, vspHeight, size - vspHeight);
+}
+function embedTimingPatterns(matrix) {
+  const size = matrix.size - 8;
+  // -8 is for skipping position detection patterns (7: size)
+  // separation patterns (1: size). Thus, 8 = 7 + 1.
+  for (let x = 8; x < size; x++) {
+    const bit = (x + 1) & 0x01;
+    // Horizontal line.
+    if (isEmpty(matrix, x, 6)) {
+      matrix.set(x, 6, bit);
+    }
+  }
+  // -8 is for skipping position detection patterns (7: size)
+  // separation patterns (1: size). Thus, 8 = 7 + 1.
+  for (let y = 8; y < size; y++) {
+    const bit = (y + 1) & 0x01;
+    // Vertical line.
+    if (isEmpty(matrix, 6, y)) {
+      matrix.set(6, y, bit);
+    }
+  }
+}
+function embedAlignmentPattern(matrix, x, y) {
+  for (let i = 0; i < 5; i++) {
+    const pattern = ALIGNMENT_PATTERN_SHAPE[i];
+    for (let j = 0; j < 5; j++) {
+      matrix.set(x + j, y + i, pattern[j]);
+    }
+  }
+}
+// Embed position alignment patterns if need be.
+function embedAlignmentPatterns(matrix, { version }) {
+  if (version >= 2) {
+    const { alignmentPatterns } = VERSIONS[version - 1];
+    const { length } = alignmentPatterns;
+    for (let i = 0; i < length; i++) {
+      const y = alignmentPatterns[i];
+      for (let j = 0; j < length; j++) {
+        const x = alignmentPatterns[j];
+        if (isEmpty(matrix, x, y)) {
+          // If the cell is unset, we embed the position alignment pattern here.
+          // -2 is necessary since the x/y coordinates point to the center of the pattern, not the
+          // left top corner.
+          embedAlignmentPattern(matrix, x - 2, y - 2);
+        }
+      }
+    }
+  }
+}
+// Embed the lonely dark dot at left bottom corner. ISO/IEC 18004:2015(E)(p.56)
+function embedDarkModule(matrix) {
+  matrix.set(8, matrix.size - 8, 1);
+}
+// Make bit vector of format information. On success, store the result in "bits".
+// Encode error correction level and mask pattern. See 8.9 of
+// ISO/IEC 18004:2015(E)(p.55) for details.
+function makeFormatInfoBits(bits, ecLevel, mask) {
+  const formatInfo = (ecLevel.bits << 3) | mask;
+  bits.append(formatInfo, 5);
+  const bchCode = calculateBCHCode(formatInfo, FORMAT_INFO_POLY);
+  bits.append(bchCode, 10);
+  const maskBits = new BitArray();
+  maskBits.append(FORMAT_INFO_MASK, 15);
+  bits.xor(maskBits);
+}
+// Embed format information. On success, modify the matrix.
+function embedFormatInfo(matrix, ecLevel, mask) {
+  const formatInfoBits = new BitArray();
+  makeFormatInfoBits(formatInfoBits, ecLevel, mask);
+  const { size } = matrix;
+  const { length } = formatInfoBits;
+  for (let i = 0; i < length; i++) {
+    // Type info bits at the left top corner.
+    const [x, y] = FORMAT_INFO_COORDINATES[i];
+    // Place bits in LSB to MSB order. LSB (least significant bit) is the last value in formatInfoBits.
+    const bit = formatInfoBits.get(length - 1 - i);
+    matrix.set(x, y, bit);
+    if (i < 8) {
+      // Right top corner.
+      matrix.set(size - i - 1, 8, bit);
+    } else {
+      // Left bottom corner.
+      matrix.set(8, size - 7 + (i - 8), bit);
+    }
+  }
+  // Then, embed the dark dot at the left bottom corner.
+  embedDarkModule(matrix);
+}
+// Make bit vector of version information. On success, store the result in "bits".
+// See 7.10 of ISO/IEC 18004:2015(E)(p.58) for details.
+function makeVersionInfoBits(bits, version) {
+  bits.append(version, 6);
+  const bchCode = calculateBCHCode(version, VERSION_INFO_POLY);
+  bits.append(bchCode, 12);
+}
+// Embed version information if need be. On success, modify the matrix.
+// See 7.10 of ISO/IEC 18004:2015(E)(p.58) for how to embed version information.
+function embedVersionInfo(matrix, { version }) {
+  if (version >= 7) {
+    const versionInfoBits = new BitArray();
+    makeVersionInfoBits(versionInfoBits, version);
+    // It will decrease from 17 to 0.
+    let bitIndex = 6 * 3 - 1;
+    const { size } = matrix;
+    for (let i = 0; i < 6; i++) {
+      for (let j = 0; j < 3; j++) {
+        // Place bits in LSB (least significant bit) to MSB order.
+        const bit = versionInfoBits.get(bitIndex--);
+        // Left bottom corner.
+        matrix.set(i, size - 11 + j, bit);
+        // Right bottom corner.
+        matrix.set(size - 11 + j, i, bit);
+      }
+    }
+  }
+}
+// Embed "codewords". On success, modify the matrix.
+// See 7.7.3 of ISO/IEC 18004:2015(E)(p.46) for how to embed codewords.
+function embedCodewords(matrix, codewords, mask) {
+  let bitIndex = 0;
+  const { size } = matrix;
+  const { length } = codewords;
+  // Start from the right bottom cell.
+  for (let x = size - 1; x >= 1; x -= 2) {
+    // Skip the vertical timing pattern.
+    if (x === 6) {
+      x = 5;
+    }
+    for (let y = 0; y < size; y++) {
+      for (let i = 0; i < 2; i++) {
+        const offsetX = x - i;
+        const upward = ((x + 1) & 2) === 0;
+        const offsetY = upward ? size - 1 - y : y;
+        // Skip the cell if it's not empty.
+        if (isEmpty(matrix, offsetX, offsetY)) {
+          // Padding bit. If there is no bit left, we'll fill the left cells with 0.
+          let bit = 0;
+          if (bitIndex < length) {
+            bit = codewords.get(bitIndex++);
+          }
+          // Is apply mask.
+          if (isApplyMask(mask, offsetX, offsetY)) {
+            bit ^= 1;
+          }
+          matrix.set(offsetX, offsetY, bit);
+        }
+      }
+    }
+  }
+}
+// Embed function patterns. On success, modify the matrix.
+// The function patterns are:
+// - Finder patterns and separators
+// - Alignment patterns, if version >= 2
+// - Timing patterns
+function embedFunctionPatterns(matrix, version) {
+  // Let's get started with embedding big squares at corners.
+  embedFinderPatternsAndSeparators(matrix);
+  // Alignment patterns appear if version >= 2.
+  embedAlignmentPatterns(matrix, version);
+  // Timing patterns should be embedded after position adj. patterns.
+  embedTimingPatterns(matrix);
+}
+// Embed encoding region. On success, modify the matrix.
+// The encoding region are:
+// - Format Info
+// - Version Info, if version >= 7
+// - Data with correction
+function embedEncodingRegion(matrix, codewords, version, ecLevel, mask) {
+  // Type information appear with any version.
+  embedFormatInfo(matrix, ecLevel, mask);
+  // Version info appear if version >= 7.
+  embedVersionInfo(matrix, version);
+  // Data should be embedded at end.
+  embedCodewords(matrix, codewords, mask);
+}
+// Build 2D matrix of QR Code from "codewords" with "ecLevel", "version" and "getMaskPattern". On
+// success, store the result in "matrix".
+function buildMatrix(codewords, version, ecLevel, mask) {
+  const matrix = new ByteMatrix(version.size);
+  // Clear matrix.
+  matrix.clear(-1);
+  // Embed function patterns.
+  embedFunctionPatterns(matrix, version);
+  // Embed encoding region.
+  embedEncodingRegion(matrix, codewords, version, ecLevel, mask);
+  return matrix;
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module BlockPair
+ */
+class BlockPair {
+  #ecCodewords;
+  #dataCodewords;
+  constructor(dataCodewords, ecCodewords) {
+    this.#ecCodewords = ecCodewords;
+    this.#dataCodewords = dataCodewords;
+  }
+  get ecCodewords() {
+    return this.#ecCodewords;
+  }
+  get dataCodewords() {
+    return this.#dataCodewords;
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module Encoder
+ */
+function buildGenerator(field, generators, degree) {
+  const { length } = generators;
+  if (degree >= length) {
+    const { generator } = field;
+    let lastGenerator = generators[length - 1];
+    for (let i = length; i <= degree; i++) {
+      const coefficients = new Int32Array([1, field.exp(i - 1 + generator)]);
+      const nextGenerator = lastGenerator.multiply(new Polynomial(field, coefficients));
+      generators.push(nextGenerator);
+      lastGenerator = nextGenerator;
+    }
+  }
+  return generators[degree];
+}
+let Encoder$1 = class Encoder {
+  #field;
+  #generators;
+  constructor(field = QR_CODE_FIELD_256) {
+    this.#field = field;
+    this.#generators = [new Polynomial(field, new Int32Array([1]))];
+  }
+  encode(received, ecLength) {
+    const dataBytes = received.length - ecLength;
+    const infoCoefficients = new Int32Array(dataBytes);
+    const generator = buildGenerator(this.#field, this.#generators, ecLength);
+    infoCoefficients.set(received.subarray(0, dataBytes));
+    const base = new Polynomial(this.#field, infoCoefficients);
+    const info = base.multiplyByMonomial(ecLength, 1);
+    const [, remainder] = info.divide(generator);
+    const { coefficients } = remainder;
+    const numZeroCoefficients = ecLength - coefficients.length;
+    const zeroCoefficientsOffset = dataBytes + numZeroCoefficients;
+    received.fill(0, dataBytes, zeroCoefficientsOffset);
+    received.set(coefficients, zeroCoefficientsOffset);
+  }
+};
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module encoder
+ */
+function generateECCodewords(codewords, numECCodewords) {
+  const numDataCodewords = codewords.length;
+  const buffer = new Int32Array(numDataCodewords + numECCodewords);
+  // Copy data codewords.
+  buffer.set(codewords);
+  // Reed solomon encode.
+  new Encoder$1().encode(buffer, numECCodewords);
+  // Get ec codewords.
+  return new Uint8Array(buffer.subarray(numDataCodewords));
+}
+function injectECCodewords(bits, { ecBlocks, numECCodewordsPerBlock }) {
+  // Step 1.  Divide data bytes into blocks and generate error correction bytes for them. We'll
+  // store the divided data bytes blocks and error correction bytes blocks into "blocks".
+  let maxNumECCodewords = 0;
+  let maxNumDataCodewords = 0;
+  let dataCodewordsOffset = 0;
+  // Block pair.
+  const blocks = [];
+  for (const { count, numDataCodewords } of ecBlocks) {
+    for (let i = 0; i < count; i++) {
+      const dataCodewords = new Uint8Array(numDataCodewords);
+      bits.writeToUint8Array(dataCodewordsOffset * 8, dataCodewords, 0, numDataCodewords);
+      const ecCodewords = generateECCodewords(dataCodewords, numECCodewordsPerBlock);
+      blocks.push(new BlockPair(dataCodewords, ecCodewords));
+      dataCodewordsOffset += numDataCodewords;
+      maxNumECCodewords = Math.max(maxNumECCodewords, ecCodewords.length);
+      maxNumDataCodewords = Math.max(maxNumDataCodewords, numDataCodewords);
+    }
+  }
+  const codewords = new BitArray();
+  // First, place data blocks.
+  for (let i = 0; i < maxNumDataCodewords; i++) {
+    for (const { dataCodewords } of blocks) {
+      if (i < dataCodewords.length) {
+        codewords.append(dataCodewords[i], 8);
+      }
+    }
+  }
+  // Then, place error correction blocks.
+  for (let i = 0; i < maxNumECCodewords; i++) {
+    for (const { ecCodewords } of blocks) {
+      if (i < ecCodewords.length) {
+        codewords.append(ecCodewords[i], 8);
+      }
+    }
+  }
+  return codewords;
+}
+function appendTerminator(bits, numDataCodewords) {
+  const capacity = numDataCodewords * 8;
+  // Append terminator if there is enough space (value is 0000).
+  for (let i = 0; i < 4 && bits.length < capacity; i++) {
+    bits.append(0);
+  }
+  // Append terminator. See 7.4.9 of ISO/IEC 18004:2015(E)(p.32) for details.
+  // If the last byte isn't 8-bit aligned, we'll add padding bits.
+  const numBitsInLastByte = bits.length & 0x07;
+  if (numBitsInLastByte > 0) {
+    for (let i = numBitsInLastByte; i < 8; i++) {
+      bits.append(0);
+    }
+  }
+  // If we have more space, we'll fill the space with padding patterns defined in 8.4.9 (p.24).
+  const numPaddingCodewords = numDataCodewords - bits.byteLength;
+  for (let i = 0; i < numPaddingCodewords; i++) {
+    bits.append(i & 0x01 ? 0x11 : 0xec, 8);
+  }
+}
+function isByteMode(segment) {
+  return segment.mode === Mode.BYTE;
+}
+function isHanziMode(segment) {
+  return segment.mode === Mode.HANZI;
+}
+function appendModeInfo(bits, mode) {
+  bits.append(mode.bits, 4);
+}
+function appendECI(bits, segment, currentECIValue) {
+  if (isByteMode(segment)) {
+    const [value] = segment.charset.values;
+    if (value !== currentECIValue) {
+      bits.append(Mode.ECI.bits, 4);
+      // See 7.4.2.2 of ISO/IEC 18004:2015(E)(p.24) for details.
+      if (value <= 127) {
+        bits.append(value, 8);
+      } else if (value <= 16383) {
+        bits.append(0x8000 | value, 16);
+      } else {
+        bits.append(0xc00000 | value, 24);
+      }
+      return value;
+    }
+  }
+  return currentECIValue;
+}
+function appendFNC1Info(bits, fnc1) {
+  const [mode, indicator] = fnc1;
+  // Append FNC1 if applicable.
+  switch (mode) {
+    case 'GS1':
+      // GS1 formatted codes are prefixed with a FNC1 in first position mode header.
+      appendModeInfo(bits, Mode.FNC1_FIRST_POSITION);
+      break;
+    case 'AIM':
+      // AIM formatted codes are prefixed with a FNC1 in first position mode header.
+      appendModeInfo(bits, Mode.FNC1_SECOND_POSITION);
+      // Append AIM application indicator.
+      bits.append(indicator, 8);
+      break;
+  }
+}
+function getSegmentLength(segment, bits) {
+  // Byte segment use byte Length.
+  if (isByteMode(segment)) {
+    return bits.byteLength;
+  }
+  // Other segments use the real length of characters.
+  // All rest segments content codePointAt at 0x0000 to 0xffff, so use length directly.
+  return segment.content.length;
+}
+function appendLengthInfo(bits, mode, version, numLetters) {
+  bits.append(numLetters, mode.getCharacterCountBits(version));
+}
+function willFit(numInputBits, version, ecLevel) {
+  // In the following comments, we use numbers of Version 7-H.
+  const ecBlocks = version.getECBlocks(ecLevel);
+  const numInputCodewords = Math.ceil(numInputBits / 8);
+  return ecBlocks.numTotalDataCodewords >= numInputCodewords;
+}
+function chooseVersion(numInputBits, ecLevel) {
+  for (const version of VERSIONS) {
+    if (willFit(numInputBits, version, ecLevel)) {
+      return version;
+    }
+  }
+  throw new Error('data too big for all versions');
+}
+function calculateBitsNeeded(segmentBlocks, version) {
+  let bitsNeeded = 0;
+  for (const { mode, head, body } of segmentBlocks) {
+    bitsNeeded += head.length + mode.getCharacterCountBits(version) + body.length;
+  }
+  return bitsNeeded;
+}
+function chooseRecommendVersion(segmentBlocks, ecLevel) {
+  // Hard part: need to know version to know how many bits length takes. But need to know how many
+  // bits it takes to know version. First we take a guess at version by assuming version will be
+  // the minimum, 1:
+  const provisionalBitsNeeded = calculateBitsNeeded(segmentBlocks, VERSIONS[0]);
+  const provisionalVersion = chooseVersion(provisionalBitsNeeded, ecLevel);
+  // Use that guess to calculate the right version. I am still not sure this works in 100% of cases.
+  const bitsNeeded = calculateBitsNeeded(segmentBlocks, provisionalVersion);
+  return chooseVersion(bitsNeeded, ecLevel);
+}
+function chooseBestMaskAndMatrix(codewords, version, ecLevel) {
+  let bestMask = 0;
+  let bestMatrix = buildMatrix(codewords, version, ecLevel, bestMask);
+  let minPenalty = calculateMaskPenalty(bestMatrix);
+  // We try all rest mask patterns to choose the best one.
+  for (let mask = 1; mask < 8; mask++) {
+    const matrix = buildMatrix(codewords, version, ecLevel, mask);
+    const penalty = calculateMaskPenalty(matrix);
+    // Lower penalty is better.
+    if (penalty < minPenalty) {
+      bestMask = mask;
+      bestMatrix = matrix;
+      minPenalty = penalty;
+    }
+  }
+  return [bestMask, bestMatrix];
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module Dict
+ * @see https://github.com/google/dart-gif-encoder
+ */
+// The highest code that can be defined in the CodeBook.
+const MAX_CODE = (1 << 12) - 1;
+/**
+ * A dict contains codes defined during LZW compression. It's a mapping from a string
+ * of pixels to the code that represents it. The codes are stored in a trie which is
+ * represented as a map. Codes may be up to 12 bits. The size of the codebook is always
+ * the minimum power of 2 needed to represent all the codes and automatically increases
+ * as new codes are defined.
+ */
+class Dict {
+  #bof;
+  #eof;
+  #bits;
+  #depth;
+  #size;
+  #unused;
+  #codes;
+  constructor(depth) {
+    const bof = 1 << depth;
+    const eof = bof + 1;
+    this.#bof = bof;
+    this.#eof = eof;
+    this.#depth = depth;
+    this.reset();
+  }
+  get bof() {
+    return this.#bof;
+  }
+  get eof() {
+    return this.#eof;
+  }
+  get bits() {
+    return this.#bits;
+  }
+  get depth() {
+    return this.#depth;
+  }
+  reset() {
+    const bits = this.#depth + 1;
+    this.#bits = bits;
+    this.#size = 1 << bits;
+    this.#codes = new Map();
+    this.#unused = this.#eof + 1;
+  }
+  add(code, index) {
+    let unused = this.#unused;
+    if (unused > MAX_CODE) {
+      return false;
+    }
+    this.#codes.set((code << 8) | index, unused++);
+    let bits = this.#bits;
+    let size = this.#size;
+    if (unused > size) {
+      size = 1 << ++bits;
+    }
+    this.#bits = bits;
+    this.#size = size;
+    this.#unused = unused;
+    return true;
+  }
+  get(code, index) {
+    return this.#codes.get((code << 8) | index);
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module DictStream
+ * @see https://github.com/google/dart-gif-encoder
+ */
+class DictStream {
+  #bits = 0;
+  #dict;
+  #buffer = 0;
+  #bytes = [];
+  constructor(dict) {
+    this.#dict = dict;
+  }
+  write(code) {
+    let bits = this.#bits;
+    let buffer = this.#buffer | (code << bits);
+    bits += this.#dict.bits;
+    const bytes = this.#bytes;
+    while (bits >= 8) {
+      bytes.push(buffer & 0xff);
+      buffer >>= 8;
+      bits -= 8;
+    }
+    this.#bits = bits;
+    this.#buffer = buffer;
+  }
+  pipe(stream) {
+    const bytes = this.#bytes;
+    // Add the remaining bits. (Unused bits are set to zero.)
+    if (this.#bits > 0) {
+      bytes.push(this.#buffer);
+    }
+    stream.writeByte(this.#dict.depth);
+    // Divide it up into blocks with a size in front of each block.
+    const { length } = bytes;
+    for (let i = 0; i < length; ) {
+      const remain = length - i;
+      if (remain >= 255) {
+        stream.writeByte(0xff);
+        stream.writeBytes(bytes, i, 255);
+        i += 255;
+      } else {
+        stream.writeByte(remain);
+        stream.writeBytes(bytes, i, remain);
+        i = length;
+      }
+    }
+    stream.writeByte(0);
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module index
+ * @see https://github.com/google/dart-gif-encoder
+ */
+function compress(pixels, depth, stream) {
+  const dict = new Dict(depth);
+  const buffer = new DictStream(dict);
+  buffer.write(dict.bof);
+  if (pixels.length > 0) {
+    let code = pixels[0];
+    const { length } = pixels;
+    for (let i = 1; i < length; i++) {
+      const pixelIndex = pixels[i];
+      const nextCode = dict.get(code, pixelIndex);
+      if (nextCode != null) {
+        code = nextCode;
+      } else {
+        buffer.write(code);
+        // Reset dict when full.
+        if (!dict.add(code, pixelIndex)) {
+          buffer.write(dict.bof);
+          dict.reset();
+        }
+        code = pixelIndex;
+      }
+    }
+    buffer.write(code);
+  }
+  buffer.write(dict.eof);
+  buffer.pipe(stream);
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+/**
+ * @module ByteStream
+ */
+class ByteStream {
+  #bytes = [];
+  get bytes() {
+    return this.#bytes;
+  }
+  writeByte(value) {
+    this.#bytes.push(value & 0xff);
+  }
+  writeInt16(value) {
+    this.#bytes.push(value & 0xff, (value >> 8) & 0xff);
+  }
+  writeBytes(bytes, offset = 0, length = bytes.length) {
+    const buffer = this.#bytes;
+    for (let i = 0; i < length; i++) {
+      buffer.push(bytes[offset + i] & 0xff);
+    }
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module Base64Stream
+ */
+const { fromCharCode } = String;
+function encode(byte) {
+  byte &= 0x3f;
+  if (byte >= 0) {
+    if (byte < 26) {
+      // A.
+      return 0x41 + byte;
+    } else if (byte < 52) {
+      // a.
+      return 0x61 + (byte - 26);
+    } else if (byte < 62) {
+      // 0.
+      return 0x30 + (byte - 52);
+    } else if (byte === 62) {
+      // +.
+      return 0x2b;
+    } else if (byte === 63) {
+      // /.
+      return 0x2f;
+    }
+  }
+  throw new Error(`illegal char: ${fromCharCode(byte)}`);
+}
+class Base64Stream {
+  #bits = 0;
+  #buffer = 0;
+  #length = 0;
+  #stream = new ByteStream();
+  get bytes() {
+    return this.#stream.bytes;
+  }
+  write(byte) {
+    let bits = this.#bits + 8;
+    const stream = this.#stream;
+    const buffer = (this.#buffer << 8) | (byte & 0xff);
+    while (bits >= 6) {
+      stream.writeByte(encode(buffer >>> (bits - 6)));
+      bits -= 6;
+    }
+    this.#length++;
+    this.#bits = bits;
+    this.#buffer = buffer;
+  }
+  close() {
+    const bits = this.#bits;
+    const stream = this.#stream;
+    if (bits > 0) {
+      stream.writeByte(encode(this.#buffer << (6 - bits)));
+      this.#bits = 0;
+      this.#buffer = 0;
+    }
+    const length = this.#length;
+    if (length % 3 != 0) {
+      // Padding.
+      const pad = 3 - (length % 3);
+      for (let i = 0; i < pad; i++) {
+        // =.
+        stream.writeByte(0x3d);
+      }
+    }
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module GIFImage
+ */
+class GIFImage {
+  #width;
+  #height;
+  #foreground;
+  #background;
+  #pixels = [];
+  constructor(width, height, { foreground = [0x00, 0x00, 0x00], background = [0xff, 0xff, 0xff] } = {}) {
+    this.#width = width;
+    this.#height = height;
+    this.#foreground = foreground;
+    this.#background = background;
+  }
+  #encode() {
+    const width = this.#width;
+    const height = this.#height;
+    const stream = new ByteStream();
+    const background = this.#background;
+    const foreground = this.#foreground;
+    // GIF signature: GIF89a.
+    stream.writeBytes([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
+    // Logical screen descriptor.
+    stream.writeInt16(width);
+    stream.writeInt16(height);
+    stream.writeBytes([0x80, 0, 0]);
+    // Global background color palette.
+    stream.writeBytes([background[0], background[1], background[2]]);
+    // Global foreground color palette.
+    stream.writeBytes([foreground[0], foreground[1], foreground[2]]);
+    // Image descriptor.
+    stream.writeByte(0x2c);
+    stream.writeInt16(0);
+    stream.writeInt16(0);
+    stream.writeInt16(width);
+    stream.writeInt16(height);
+    stream.writeByte(0);
+    // Compress pixels to stream.
+    compress(this.#pixels, 2, stream);
+    // GIF terminator.
+    stream.writeByte(0x3b);
+    return stream.bytes;
+  }
+  set(x, y, color) {
+    this.#pixels[y * this.#width + x] = color;
+  }
+  toDataURL() {
+    const bytes = this.#encode();
+    const stream = new Base64Stream();
+    for (const byte of bytes) {
+      stream.write(byte);
+    }
+    stream.close();
+    const base64 = stream.bytes;
+    let url = 'data:image/gif;base64,';
+    for (const byte of base64) {
+      url += fromCharCode(byte);
+    }
+    return url;
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module Encoded
+ */
+class Encoded {
+  #mask;
+  #level;
+  #version;
+  #matrix;
+  constructor(matrix, version, level, mask) {
+    this.#mask = mask;
+    this.#level = level;
+    this.#matrix = matrix;
+    this.#version = version;
+  }
+  /**
+   * @property matrix
+   * @description Get the size of qrcode.
+   */
+  get size() {
+    return this.#matrix.size;
+  }
+  /**
+   * @property mask
+   * @description Get the mask of qrcode.
+   */
+  get mask() {
+    return this.#mask;
+  }
+  /**
+   * @property level
+   * @description Get the error correction level of qrcode.
+   */
+  get level() {
+    return this.#level.name;
+  }
+  /**
+   * @property version
+   * @description Get the version of qrcode.
+   */
+  get version() {
+    return this.#version.version;
+  }
+  /**
+   * @method get
+   * @description Get the bit value of the specified coordinate of qrcode.
+   */
+  get(x, y) {
+    const { size } = this.#matrix;
+    if (x < 0 || y < 0 || x >= size || y >= size) {
+      throw new Error(`illegal coordinate: [${x}, ${y}]`);
+    }
+    return this.#matrix.get(x, y);
+  }
+  /**
+   * @method toDataURL
+   * @param moduleSize The size of one qrcode module
+   * @param options Set rest options of gif, like margin, foreground and background.
+   */
+  toDataURL(moduleSize = 2, { margin = moduleSize * 4, ...colors } = {}) {
+    moduleSize = Math.max(1, moduleSize >> 0);
+    margin = Math.max(0, margin >> 0);
+    const matrix = this.#matrix;
+    const matrixSize = matrix.size;
+    const size = moduleSize * matrixSize + margin * 2;
+    const gif = new GIFImage(size, size, colors);
+    const max = size - margin;
+    for (let y = 0; y < size; y++) {
+      for (let x = 0; x < size; x++) {
+        if (x >= margin && x < max && y >= margin && y < max) {
+          const offsetX = toInt32((x - margin) / moduleSize);
+          const offsetY = toInt32((y - margin) / moduleSize);
+          gif.set(x, y, matrix.get(offsetX, offsetY));
+        } else {
+          // Margin pixels.
+          gif.set(x, y, 0);
+        }
+      }
+    }
+    return gif.toDataURL();
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module asserts
+ */
+function assertContent(content) {
+  if (content === '') {
+    throw new Error('segment content should be at least 1 character');
+  }
+}
+function assertCharset(charset) {
+  if (!(charset instanceof Charset)) {
+    throw new Error('illegal charset');
+  }
+}
+function assertHints(hints) {
+  const { fnc1 } = hints;
+  // FNC1.
+  if (fnc1 != null) {
+    const [mode] = fnc1;
+    if (mode !== 'GS1' && mode !== 'AIM') {
+      throw new Error('illegal fn1 hint');
+    }
+    if (mode === 'AIM') {
+      const [, indicator] = fnc1;
+      if (indicator < 0 || indicator > 0xff || !Number.isInteger(indicator)) {
+        throw new Error('illegal fn1 application indicator');
+      }
+    }
+  }
+}
+function assertLevel(level) {
+  if (['L', 'M', 'Q', 'H'].indexOf(level) < 0) {
+    throw new Error('illegal error correction level');
+  }
+}
+function assertVersion(version) {
+  if (version !== 'Auto') {
+    if (version < 1 || version > 40 || !Number.isInteger(version)) {
+      throw new Error('illegal version');
+    }
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module Encoder
+ */
+class Encoder {
+  #hints;
+  #level;
+  #encode;
+  #version;
+  /**
+   * @constructor
+   * @param options The options of encoder.
+   */
+  constructor({ hints = {}, level = 'L', version = 'Auto', encode: encode$1$1 = encode$1 } = {}) {
+    assertHints(hints);
+    assertLevel(level);
+    assertVersion(version);
+    this.#hints = hints;
+    this.#encode = encode$1$1;
+    this.#version = version;
+    this.#level = ECLevel[level];
+  }
+  /**
+   * @method encode
+   * @description Encode the segments.
+   * @param segments The segments.
+   */
+  encode(...segments) {
+    const ecLevel = this.#level;
+    const encode = this.#encode;
+    const { fnc1 } = this.#hints;
+    const versionNumber = this.#version;
+    const segmentBlocks = [];
+    // Only append FNC1 once.
+    let isFNC1Appended = false;
+    // Current ECI value.
+    let [currentECIValue] = Charset.ISO_8859_1.values;
+    // Init segments.
+    for (const segment of segments) {
+      const { mode } = segment;
+      const head = new BitArray();
+      const body = segment.encode(encode);
+      const length = getSegmentLength(segment, body);
+      // Append ECI segment if applicable.
+      currentECIValue = appendECI(head, segment, currentECIValue);
+      // Append FNC1 if applicable.
+      if (fnc1 != null && !isFNC1Appended) {
+        isFNC1Appended = true;
+        appendFNC1Info(head, fnc1);
+      }
+      // With ECI in place, Write the mode marker.
+      appendModeInfo(head, mode);
+      // If is Hanzi mode append GB2312 subset.
+      if (isHanziMode(segment)) {
+        head.append(1, 4);
+      }
+      // Push segment block.
+      segmentBlocks.push({ mode, head, body, length });
+    }
+    let version;
+    if (versionNumber === 'Auto') {
+      version = chooseRecommendVersion(segmentBlocks, ecLevel);
+    } else {
+      version = VERSIONS[versionNumber - 1];
+      const bitsNeeded = calculateBitsNeeded(segmentBlocks, version);
+      if (!willFit(bitsNeeded, version, ecLevel)) {
+        throw new Error('data too big for requested version');
+      }
+    }
+    const buffer = new BitArray();
+    for (const { mode, head, body, length } of segmentBlocks) {
+      buffer.append(head);
+      appendLengthInfo(buffer, mode, version, length);
+      buffer.append(body);
+    }
+    const ecBlocks = version.getECBlocks(ecLevel);
+    appendTerminator(buffer, ecBlocks.numTotalDataCodewords);
+    const codewords = injectECCodewords(buffer, ecBlocks);
+    const [mask, matrix] = chooseBestMaskAndMatrix(codewords, version, ecLevel);
+    return new Encoded(matrix, version, ecLevel, mask);
+  }
+}
+
+/**
+ * @module QRCode
+ * @package @nuintun/qrcode
+ * @license MIT
+ * @version 5.0.2
+ * @author nuintun <nuintun@qq.com>
+ * @description A pure JavaScript QRCode encode and decode library.
+ * @see https://github.com/nuintun/qrcode#readme
+ */
+
+
+/**
+ * @module Byte
+ */
+class Byte {
+  #content;
+  #charset;
+  /**
+   * @constructor
+   * @param content The content to encode.
+   * @param charset The charset of the content.
+   */
+  constructor(content, charset = Charset.ISO_8859_1) {
+    assertContent(content);
+    assertCharset(charset);
+    this.#content = content;
+    this.#charset = charset;
+  }
+  /**
+   * @property mode
+   * @description The mode of the segment.
+   */
+  get mode() {
+    return Mode.BYTE;
+  }
+  /**
+   * @property content
+   * @description The content of the segment.
+   */
+  get content() {
+    return this.#content;
+  }
+  /**
+   * @property charset
+   * @description The charset of the content.
+   */
+  get charset() {
+    return this.#charset;
+  }
+  /**
+   * @method encode
+   * @description Encode the segment.
+   * @param encode The text encode function.
+   */
+  encode(encode) {
+    const bits = new BitArray();
+    const bytes = encode(this.#content, this.#charset);
+    for (const byte of bytes) {
+      bits.append(byte, 8);
+    }
+    return bits;
+  }
+}
+
+export { Byte as B, Encoder as E, Message as M };
+//# sourceMappingURL=p-Dv8qvK0w.js.map
+
+//# sourceMappingURL=p-Dv8qvK0w.js.map