@digigov/ui 2.0.0-7d9a8d86 → 2.0.0-85c27c19

package/cjs/app/QrCodeViewer/qrcodegen/index.js

@@ -1,35 +1,53 @@
 "use strict";
 var __defProp = Object.defineProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {get: all[name], enumerable: true});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-__markAsModule(exports);
-__export(exports, {
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var qrcodegen_exports = {};
+__export(qrcodegen_exports, {
   default: () => qrcodegen_default
 });
+module.exports = __toCommonJS(qrcodegen_exports);
 /**
  * @license QR Code generator library (TypeScript)
  * Copyright (c) Project Nayuki.
  * SPDX-License-Identifier: MIT
  */
 var qrcodegen;
-(function(qrcodegen2) {
-  const _QrCode = class {
+((qrcodegen2) => {
+  class QrCode {
+    /*-- Constructor (low level) and fields --*/
+    // Creates a new QR Code with the given version number,
+    // error correction level, data codeword bytes, and mask number.
+    // This is a low-level API that most users should not use directly.
+    // A mid-level API is the encodeSegments() function.
     constructor(version, errorCorrectionLevel, dataCodewords, msk) {
+      // The modules of this QR Code (false = light, true = dark).
+      // Immutable after constructor finishes. Accessed through getModule().
       this.modules = [];
+      // Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
       this.isFunction = [];
       this.version = version;
       this.errorCorrectionLevel = errorCorrectionLevel;
-      if (version < _QrCode.MIN_VERSION || version > _QrCode.MAX_VERSION)
+      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");
+      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++) row.push(false);
       for (let i = 0; i < this.size; i++) {
         this.modules.push(row.slice());
         this.isFunction.push(row.slice());
@@ -56,21 +74,41 @@ var qrcodegen;
       this.drawFormatBits(msk);
       this.isFunction = [];
     }
+    /*-- Static factory functions (high level) --*/
+    // Returns a QR Code representing the given Unicode text string at the given error correction level.
+    // As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
+    // Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
+    // QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
+    // ecl argument if it can be done without increasing the version.
     static encodeText(text, ecl) {
       const segs = qrcodegen2.QrSegment.makeSegments(text);
-      return _QrCode.encodeSegments(segs, ecl);
+      return QrCode.encodeSegments(segs, ecl);
     }
+    // Returns a QR Code representing the given binary data at the given error correction level.
+    // This function always encodes using the binary segment mode, not any text mode. The maximum number of
+    // bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+    // The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
     static encodeBinary(data, ecl) {
       const seg = qrcodegen2.QrSegment.makeBytes(data);
-      return _QrCode.encodeSegments([seg], ecl);
+      return QrCode.encodeSegments([seg], ecl);
     }
+    /*-- Static factory functions (mid level) --*/
+    // Returns a QR Code representing the given segments with the given encoding parameters.
+    // The smallest possible QR Code version within the given range is automatically
+    // chosen for the output. Iff boostEcl is true, then the ECC level of the result
+    // may be higher than the ecl argument if it can be done without increasing the
+    // version. The mask number is either between 0 to 7 (inclusive) to force that
+    // mask, or -1 to automatically choose an appropriate mask (which may be slow).
+    // This function allows the user to create a custom sequence of segments that switches
+    // between modes (such as alphanumeric and byte) to encode text in less space.
+    // This is a mid-level API; the high-level API is encodeText() and 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)
+      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 dataCapacityBits2 = QrCode.getNumDataCodewords(version, ecl) * 8;
         const usedBits = QrSegment.getTotalBits(segs, version);
         if (usedBits <= dataCapacityBits2) {
           dataUsedBits = usedBits;
@@ -80,22 +118,21 @@ var qrcodegen;
           throw new RangeError("Data too long");
       }
       for (const newEcl of [
-        _QrCode.Ecc.MEDIUM,
-        _QrCode.Ecc.QUARTILE,
-        _QrCode.Ecc.HIGH
+        QrCode.Ecc.MEDIUM,
+        QrCode.Ecc.QUARTILE,
+        QrCode.Ecc.HIGH
       ]) {
-        if (boostEcl && dataUsedBits <= _QrCode.getNumDataCodewords(version, newEcl) * 8)
+        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);
+        for (const b of seg.getData()) bb.push(b);
       }
       assert(bb.length == dataUsedBits);
-      const dataCapacityBits = _QrCode.getNumDataCodewords(version, ecl) * 8;
+      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);
@@ -103,17 +140,25 @@ var qrcodegen;
       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) => dataCodewords[i >>> 3] |= b << 7 - (i & 7));
-      return new _QrCode(version, ecl, dataCodewords, mask);
+      while (dataCodewords.length * 8 < bb.length) dataCodewords.push(0);
+      bb.forEach(
+        (b, i) => dataCodewords[i >>> 3] |= b << 7 - (i & 7)
+      );
+      return new QrCode(version, ecl, dataCodewords, mask);
     }
+    /*-- Accessor methods --*/
+    // Returns the color of the module (pixel) at the given coordinates, which is false
+    // for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+    // If the given coordinates are out of bounds, then false (light) is returned.
     getModule(x, y) {
       return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];
     }
+    // Modified to expose modules for easy access
     getModules() {
       return this.modules;
     }
+    /*-- Private helper methods for constructor: Drawing function modules --*/
+    // Reads this object's version field, and draws and marks all function modules.
     drawFunctionPatterns() {
       for (let i = 0; i < this.size; i++) {
         this.setFunctionModule(6, i, i % 2 == 0);
@@ -133,11 +178,12 @@ var qrcodegen;
       this.drawFormatBits(0);
       this.drawVersion();
     }
+    // Draws two copies of the format bits (with its own error correction code)
+    // based on the given mask and this object's error correction level field.
     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;
+      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++)
@@ -153,12 +199,12 @@ var qrcodegen;
         this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
       this.setFunctionModule(8, this.size - 8, true);
     }
+    // Draws two copies of the version bits (with its own error correction code),
+    // based on this object's version field, iff 7 <= version <= 40.
     drawVersion() {
-      if (this.version < 7)
-        return;
+      if (this.version < 7) return;
       let rem = this.version;
-      for (let i = 0; i < 12; i++)
-        rem = rem << 1 ^ (rem >>> 11) * 7973;
+      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++) {
@@ -169,6 +215,8 @@ var qrcodegen;
         this.setFunctionModule(b, a, color);
       }
     }
+    // Draws a 9*9 finder pattern including the border separator,
+    // with the center module at (x, y). Modules can be out of bounds.
     drawFinderPattern(x, y) {
       for (let dy = -4; dy <= 4; dy++) {
         for (let dx = -4; dx <= 4; dx++) {
@@ -180,34 +228,49 @@ var qrcodegen;
         }
       }
     }
+    // Draws a 5*5 alignment pattern, with the center module
+    // at (x, y). All modules must be in bounds.
     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);
+          this.setFunctionModule(
+            x + dx,
+            y + dy,
+            Math.max(Math.abs(dx), Math.abs(dy)) != 1
+          );
       }
     }
+    // Sets the color of a module and marks it as a function module.
+    // Only used by the constructor. Coordinates must be in bounds.
     setFunctionModule(x, y, isDark) {
       this.modules[y][x] = isDark;
       this.isFunction[y][x] = true;
     }
+    /*-- Private helper methods for constructor: Codewords and masking --*/
+    // Returns a new byte string representing the given data with the appropriate error correction
+    // codewords appended to it, based on this object's version and error correction level.
     addEccAndInterleave(data) {
       const ver = this.version;
       const ecl = this.errorCorrectionLevel;
-      if (data.length != _QrCode.getNumDataCodewords(ver, ecl))
+      if (data.length != QrCode.getNumDataCodewords(ver, ecl))
         throw new RangeError("Invalid argument");
-      const numBlocks = _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
-      const blockEccLen = _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];
-      const rawCodewords = Math.floor(_QrCode.getNumRawDataModules(ver) / 8);
+      const numBlocks = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+      const blockEccLen = QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];
+      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);
+      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));
+        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);
+        const ecc = QrCode.reedSolomonComputeRemainder(dat, rsDiv);
+        if (i < numShortBlocks) dat.push(0);
         blocks.push(dat.concat(ecc));
       }
       const result = [];
@@ -220,13 +283,14 @@ var qrcodegen;
       assert(result.length == rawCodewords);
       return result;
     }
+    // Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+    // data area of this QR Code. Function modules need to be marked off before this is called.
     drawCodewords(data) {
-      if (data.length != Math.floor(_QrCode.getNumRawDataModules(this.version) / 8))
+      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;
+        if (right == 6) right = 5;
         for (let vert = 0; vert < this.size; vert++) {
           for (let j = 0; j < 2; j++) {
             const x = right - j;
@@ -241,9 +305,13 @@ var qrcodegen;
       }
       assert(i == data.length * 8);
     }
+    // XORs the codeword modules in this QR Code with the given mask pattern.
+    // The function modules must be marked and the codeword bits must be drawn
+    // before masking. Due to the arithmetic of XOR, calling applyMask() with
+    // the same mask value a second time will undo the mask. A final well-formed
+    // QR Code needs exactly one (not zero, two, etc.) mask applied.
     applyMask(mask) {
-      if (mask < 0 || mask > 7)
-        throw new RangeError("Mask value out of range");
+      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;
@@ -280,6 +348,8 @@ var qrcodegen;
         }
       }
     }
+    // Calculates and returns the penalty score based on state of this QR Code's current modules.
+    // This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
     getPenaltyScore() {
       let result = 0;
       for (let y = 0; y < this.size; y++) {
@@ -289,19 +359,17 @@ var qrcodegen;
         for (let x = 0; x < this.size; x++) {
           if (this.modules[y][x] == runColor) {
             runX++;
-            if (runX == 5)
-              result += _QrCode.PENALTY_N1;
-            else if (runX > 5)
-              result++;
+            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;
+              result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
             runColor = this.modules[y][x];
             runX = 1;
           }
         }
-        result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * _QrCode.PENALTY_N3;
+        result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * QrCode.PENALTY_N3;
       }
       for (let x = 0; x < this.size; x++) {
         let runColor = false;
@@ -310,25 +378,23 @@ var qrcodegen;
         for (let y = 0; y < this.size; y++) {
           if (this.modules[y][x] == runColor) {
             runY++;
-            if (runY == 5)
-              result += _QrCode.PENALTY_N1;
-            else if (runY > 5)
-              result++;
+            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;
+              result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
             runColor = this.modules[y][x];
             runY = 1;
           }
         }
-        result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * _QrCode.PENALTY_N3;
+        result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * QrCode.PENALTY_N3;
       }
       for (let y = 0; y < this.size - 1; y++) {
         for (let x = 0; x < this.size - 1; x++) {
           const color = this.modules[y][x];
           if (color == this.modules[y][x + 1] && color == this.modules[y + 1][x] && color == this.modules[y + 1][x + 1])
-            result += _QrCode.PENALTY_N2;
+            result += QrCode.PENALTY_N2;
         }
       }
       let dark = 0;
@@ -337,13 +403,16 @@ var qrcodegen;
       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;
+      result += k * QrCode.PENALTY_N4;
       assert(0 <= result && result <= 2568888);
       return result;
     }
+    /*-- Private helper functions --*/
+    // Returns an ascending list of positions of alignment patterns for this version number.
+    // Each position is in the range [0,177), and are used on both the x and y axes.
+    // This could be implemented as lookup table of 40 variable-length lists of integers.
     getAlignmentPatternPositions() {
-      if (this.version == 1)
-        return [];
+      if (this.version == 1) return [];
       else {
         const numAlign = Math.floor(this.version / 7) + 2;
         const step = this.version == 32 ? 26 : Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
@@ -353,49 +422,59 @@ var qrcodegen;
         return result;
       }
     }
+    // Returns the number of data bits that can be stored in a QR Code of the given version number, after
+    // all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+    // The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
     static getNumRawDataModules(ver) {
-      if (ver < _QrCode.MIN_VERSION || ver > _QrCode.MAX_VERSION)
+      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;
+        if (ver >= 7) result -= 36;
       }
       assert(208 <= result && result <= 29648);
       return result;
     }
+    // Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+    // QR Code of the given version number and error correction level, with remainder bits discarded.
+    // This stateless pure function could be implemented as a (40*4)-cell lookup table.
     static getNumDataCodewords(ver, ecl) {
-      return Math.floor(_QrCode.getNumRawDataModules(ver) / 8) - _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] * _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+      return Math.floor(QrCode.getNumRawDataModules(ver) / 8) - QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] * QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
     }
+    // Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
+    // implemented as a lookup table over all possible parameter values, instead of as an algorithm.
     static reedSolomonComputeDivisor(degree) {
       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);
+      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++) {
-          result[j] = _QrCode.reedSolomonMultiply(result[j], root);
-          if (j + 1 < result.length)
-            result[j] ^= result[j + 1];
+          result[j] = QrCode.reedSolomonMultiply(result[j], root);
+          if (j + 1 < result.length) result[j] ^= result[j + 1];
         }
-        root = _QrCode.reedSolomonMultiply(root, 2);
+        root = QrCode.reedSolomonMultiply(root, 2);
       }
       return result;
     }
+    // Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
     static reedSolomonComputeRemainder(data, divisor) {
       const result = divisor.map((_) => 0);
       for (const b of data) {
         const factor = b ^ result.shift();
         result.push(0);
-        divisor.forEach((coef, i) => result[i] ^= _QrCode.reedSolomonMultiply(coef, factor));
+        divisor.forEach(
+          (coef, i) => result[i] ^= QrCode.reedSolomonMultiply(coef, factor)
+        );
       }
       return result;
     }
+    // Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
+    // are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
     static reedSolomonMultiply(x, y) {
       if (x >>> 8 != 0 || y >>> 8 != 0)
         throw new RangeError("Byte out of range");
@@ -407,12 +486,15 @@ var qrcodegen;
       assert(z >>> 8 == 0);
       return z;
     }
+    // Can only be called immediately after a light run is added, and
+    // returns either 0, 1, or 2. A helper function for getPenaltyScore().
     finderPenaltyCountPatterns(runHistory) {
       const n = runHistory[1];
       assert(n <= this.size * 3);
       const core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
       return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0) + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
     }
+    // Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
     finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
       if (currentRunColor) {
         this.finderPenaltyAddHistory(currentRunLength, runHistory);
@@ -422,368 +504,399 @@ var qrcodegen;
       this.finderPenaltyAddHistory(currentRunLength, runHistory);
       return this.finderPenaltyCountPatterns(runHistory);
     }
+    // Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
     finderPenaltyAddHistory(currentRunLength, runHistory) {
-      if (runHistory[0] == 0)
-        currentRunLength += this.size;
+      if (runHistory[0] == 0) currentRunLength += this.size;
       runHistory.pop();
       runHistory.unshift(currentRunLength);
     }
-  };
-  let QrCode = _QrCode;
-  QrCode.MIN_VERSION = 1;
-  QrCode.MAX_VERSION = 40;
-  QrCode.PENALTY_N1 = 3;
-  QrCode.PENALTY_N2 = 3;
-  QrCode.PENALTY_N3 = 40;
-  QrCode.PENALTY_N4 = 10;
-  QrCode.ECC_CODEWORDS_PER_BLOCK = [
-    [
-      -1,
-      7,
-      10,
-      15,
-      20,
-      26,
-      18,
-      20,
-      24,
-      30,
-      18,
-      20,
-      24,
-      26,
-      30,
-      22,
-      24,
-      28,
-      30,
-      28,
-      28,
-      28,
-      28,
-      30,
-      30,
-      26,
-      28,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30
-    ],
-    [
-      -1,
-      10,
-      16,
-      26,
-      18,
-      24,
-      16,
-      18,
-      22,
-      22,
-      26,
-      30,
-      22,
-      22,
-      24,
-      24,
-      28,
-      28,
-      26,
-      26,
-      26,
-      26,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28,
-      28
-    ],
-    [
-      -1,
-      13,
-      22,
-      18,
-      26,
-      18,
-      24,
-      18,
-      22,
-      20,
-      24,
-      28,
-      26,
-      24,
-      20,
-      30,
-      24,
-      28,
-      28,
-      26,
-      30,
-      28,
-      30,
-      30,
-      30,
-      30,
-      28,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30
-    ],
-    [
-      -1,
-      17,
-      28,
-      22,
-      16,
-      22,
-      28,
-      26,
-      26,
-      24,
-      28,
-      24,
-      28,
-      22,
-      24,
-      24,
-      30,
-      28,
-      28,
-      26,
-      28,
-      30,
-      24,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30,
-      30
-    ]
-  ];
-  QrCode.NUM_ERROR_CORRECTION_BLOCKS = [
-    [
-      -1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      2,
-      2,
-      2,
-      2,
-      4,
-      4,
-      4,
-      4,
-      4,
-      6,
-      6,
-      6,
-      6,
-      7,
-      8,
-      8,
-      9,
-      9,
-      10,
-      12,
-      12,
-      12,
-      13,
-      14,
-      15,
-      16,
-      17,
-      18,
-      19,
-      19,
-      20,
-      21,
-      22,
-      24,
-      25
-    ],
-    [
-      -1,
-      1,
-      1,
-      1,
-      2,
-      2,
-      4,
-      4,
-      4,
-      5,
-      5,
-      5,
-      8,
-      9,
-      9,
-      10,
-      10,
-      11,
-      13,
-      14,
-      16,
-      17,
-      17,
-      18,
-      20,
-      21,
-      23,
-      25,
-      26,
-      28,
-      29,
-      31,
-      33,
-      35,
-      37,
-      38,
-      40,
-      43,
-      45,
-      47,
-      49
-    ],
-    [
-      -1,
-      1,
-      1,
-      2,
-      2,
-      4,
-      4,
-      6,
-      6,
-      8,
-      8,
-      8,
-      10,
-      12,
-      16,
-      12,
-      17,
-      16,
-      18,
-      21,
-      20,
-      23,
-      23,
-      25,
-      27,
-      29,
-      34,
-      34,
-      35,
-      38,
-      40,
-      43,
-      45,
-      48,
-      51,
-      53,
-      56,
-      59,
-      62,
-      65,
-      68
-    ],
-    [
-      -1,
-      1,
-      1,
-      2,
-      4,
-      4,
-      4,
-      5,
-      6,
-      8,
-      8,
-      11,
-      11,
-      16,
-      16,
-      18,
-      16,
-      19,
-      21,
-      25,
-      25,
-      25,
-      34,
-      30,
-      32,
-      35,
-      37,
-      40,
-      42,
-      45,
-      48,
-      51,
-      54,
-      57,
-      60,
-      63,
-      66,
-      70,
-      74,
-      77,
-      81
-    ]
-  ];
+    static {
+      /*-- Constants and tables --*/
+      // The minimum version number supported in the QR Code Model 2 standard.
+      this.MIN_VERSION = 1;
+    }
+    static {
+      // The maximum version number supported in the QR Code Model 2 standard.
+      this.MAX_VERSION = 40;
+    }
+    static {
+      // For use in getPenaltyScore(), when evaluating which mask is best.
+      this.PENALTY_N1 = 3;
+    }
+    static {
+      this.PENALTY_N2 = 3;
+    }
+    static {
+      this.PENALTY_N3 = 40;
+    }
+    static {
+      this.PENALTY_N4 = 10;
+    }
+    static {
+      this.ECC_CODEWORDS_PER_BLOCK = [
+        // Version: (note that index 0 is for padding, and is set to an illegal value)
+        //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    Error correction level
+        [
+          -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
+        ],
+        // Low
+        [
+          -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
+        ],
+        // Medium
+        [
+          -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
+        ],
+        // Quartile
+        [
+          -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
+        ]
+        // High
+      ];
+    }
+    static {
+      this.NUM_ERROR_CORRECTION_BLOCKS = [
+        // Version: (note that index 0 is for padding, and is set to an illegal value)
+        //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    Error correction level
+        [
+          -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
+        ],
+        // Low
+        [
+          -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
+        ],
+        // Medium
+        [
+          -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
+        ],
+        // Quartile
+        [
+          -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
+        ]
+        // High
+      ];
+    }
+  }
   qrcodegen2.QrCode = QrCode;
   function appendBits(val, len, bb) {
     if (len < 0 || len > 31 || val >>> len != 0)
@@ -795,18 +908,21 @@ var qrcodegen;
     return (x >>> i & 1) != 0;
   }
   function assert(cond) {
-    if (!cond)
-      throw new Error("Assertion error");
+    if (!cond) throw new Error("Assertion error");
   }
-  const _QrSegment = class {
+  class QrSegment {
+    /*-- Static factory functions (mid level) --*/
+    // Returns a segment representing the given binary data encoded in
+    // byte mode. All input byte arrays are acceptable. Any text string
+    // can be converted to UTF-8 bytes and encoded as a byte mode segment.
     static makeBytes(data) {
       const bb = [];
-      for (const b of data)
-        appendBits(b, 8, bb);
-      return new _QrSegment(_QrSegment.Mode.BYTE, data.length, bb);
+      for (const b of data) appendBits(b, 8, bb);
+      return new QrSegment(QrSegment.Mode.BYTE, data.length, bb);
     }
+    // Returns a segment representing the given string of decimal digits encoded in numeric mode.
     static makeNumeric(digits) {
-      if (!_QrSegment.isNumeric(digits))
+      if (!QrSegment.isNumeric(digits))
         throw new RangeError("String contains non-numeric characters");
       const bb = [];
       for (let i = 0; i < digits.length; ) {
@@ -814,81 +930,99 @@ var qrcodegen;
         appendBits(parseInt(digits.substr(i, n), 10), n * 3 + 1, bb);
         i += n;
       }
-      return new _QrSegment(_QrSegment.Mode.NUMERIC, digits.length, bb);
+      return new QrSegment(QrSegment.Mode.NUMERIC, digits.length, bb);
     }
+    // Returns a segment representing the given text string encoded in alphanumeric mode.
+    // The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+    // dollar, percent, asterisk, plus, hyphen, period, slash, colon.
     static makeAlphanumeric(text) {
-      if (!_QrSegment.isAlphanumeric(text))
-        throw new RangeError("String contains unencodable characters in alphanumeric mode");
+      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));
+        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(_QrSegment.Mode.ALPHANUMERIC, text.length, bb);
+        appendBits(
+          QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)),
+          6,
+          bb
+        );
+      return new QrSegment(QrSegment.Mode.ALPHANUMERIC, text.length, bb);
     }
+    // Returns a new mutable list of zero or more segments to represent the given Unicode text string.
+    // The result may use various segment modes and switch modes to optimize the length of the bit stream.
     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))];
+      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))];
     }
+    // Returns a segment representing an Extended Channel Interpretation
+    // (ECI) designator with the given assignment value.
     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 << 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(_QrSegment.Mode.ECI, 0, bb);
+      } else throw new RangeError("ECI assignment value out of range");
+      return new QrSegment(QrSegment.Mode.ECI, 0, bb);
     }
+    // Tests whether the given string can be encoded as a segment in numeric mode.
+    // A string is encodable iff each character is in the range 0 to 9.
     static isNumeric(text) {
-      return _QrSegment.NUMERIC_REGEX.test(text);
+      return QrSegment.NUMERIC_REGEX.test(text);
     }
+    // Tests whether the given string can be encoded as a segment in alphanumeric mode.
+    // A string is encodable iff each character is in the following set: 0 to 9, A to Z
+    // (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
     static isAlphanumeric(text) {
-      return _QrSegment.ALPHANUMERIC_REGEX.test(text);
+      return QrSegment.ALPHANUMERIC_REGEX.test(text);
     }
+    // Creates a new QR Code segment with the given attributes and data.
+    // The character count (numChars) must agree with the mode and the bit buffer length,
+    // but the constraint isn't checked. The given bit buffer is cloned and stored.
     constructor(mode, numChars, bitData) {
       this.mode = mode;
       this.numChars = numChars;
       this.bitData = bitData;
-      if (numChars < 0)
-        throw new RangeError("Invalid argument");
+      if (numChars < 0) throw new RangeError("Invalid argument");
       this.bitData = bitData.slice();
     }
+    /*-- Methods --*/
+    // Returns a new copy of the data bits of this segment.
     getData() {
       return this.bitData.slice();
     }
+    // (Package-private) Calculates and returns the number of bits needed to encode the given segments at
+    // the given version. The result is infinity if a segment has too many characters to fit its length field.
     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;
+        if (seg.numChars >= 1 << ccbits) return Infinity;
         result += 4 + ccbits + seg.bitData.length;
       }
       return result;
     }
+    // Returns a new array of bytes representing the given string encoded in 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));
+        if (str.charAt(i) != "%") result.push(str.charCodeAt(i));
         else {
           result.push(parseInt(str.substr(i + 1, 2), 16));
           i += 2;
@@ -896,53 +1030,84 @@ var qrcodegen;
       }
       return result;
     }
-  };
-  let QrSegment = _QrSegment;
-  QrSegment.NUMERIC_REGEX = /^[0-9]*$/;
-  QrSegment.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
-  QrSegment.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+    static {
+      /*-- Constants --*/
+      // Describes precisely all strings that are encodable in numeric mode.
+      this.NUMERIC_REGEX = /^[0-9]*$/;
+    }
+    static {
+      // Describes precisely all strings that are encodable in alphanumeric mode.
+      this.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
+    }
+    static {
+      // The set of all legal characters in alphanumeric mode,
+      // where each character value maps to the index in the string.
+      this.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+    }
+  }
   qrcodegen2.QrSegment = QrSegment;
 })(qrcodegen || (qrcodegen = {}));
-(function(qrcodegen2) {
+((qrcodegen2) => {
   let QrCode;
-  (function(QrCode2) {
-    const _Ecc = class {
+  ((QrCode2) => {
+    class Ecc {
+      static {
+        /*-- Constants --*/
+        this.LOW = new Ecc(0, 1);
+      }
+      static {
+        // The QR Code can tolerate about  7% erroneous codewords
+        this.MEDIUM = new Ecc(1, 0);
+      }
+      static {
+        // The QR Code can tolerate about 15% erroneous codewords
+        this.QUARTILE = new Ecc(2, 3);
+      }
+      static {
+        // The QR Code can tolerate about 25% erroneous codewords
+        this.HIGH = new Ecc(3, 2);
+      }
       constructor(ordinal, formatBits) {
         this.ordinal = ordinal;
         this.formatBits = formatBits;
       }
-    };
-    let Ecc = _Ecc;
-    Ecc.LOW = new _Ecc(0, 1);
-    Ecc.MEDIUM = new _Ecc(1, 0);
-    Ecc.QUARTILE = new _Ecc(2, 3);
-    Ecc.HIGH = new _Ecc(3, 2);
+    }
     QrCode2.Ecc = Ecc;
   })(QrCode = qrcodegen2.QrCode || (qrcodegen2.QrCode = {}));
 })(qrcodegen || (qrcodegen = {}));
-(function(qrcodegen2) {
+((qrcodegen2) => {
   let QrSegment;
-  (function(QrSegment2) {
-    const _Mode = class {
+  ((QrSegment2) => {
+    class Mode {
+      static {
+        /*-- Constants --*/
+        this.NUMERIC = new Mode(1, [10, 12, 14]);
+      }
+      static {
+        this.ALPHANUMERIC = new Mode(2, [9, 11, 13]);
+      }
+      static {
+        this.BYTE = new Mode(4, [8, 16, 16]);
+      }
+      static {
+        this.KANJI = new Mode(8, [8, 10, 12]);
+      }
+      static {
+        this.ECI = new Mode(7, [0, 0, 0]);
+      }
       constructor(modeBits, numBitsCharCount) {
         this.modeBits = modeBits;
         this.numBitsCharCount = numBitsCharCount;
       }
+      /*-- Method --*/
+      // (Package-private) Returns the bit width of the character count field for a segment in
+      // this mode in a QR Code at the given version number. The result is in the range [0, 16].
       numCharCountBits(ver) {
         return this.numBitsCharCount[Math.floor((ver + 7) / 17)];
       }
-    };
-    let Mode = _Mode;
-    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]);
+    }
     QrSegment2.Mode = Mode;
   })(QrSegment = qrcodegen2.QrSegment || (qrcodegen2.QrSegment = {}));
 })(qrcodegen || (qrcodegen = {}));
 var qrcodegen_default = qrcodegen;
-"use strict";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
 //# sourceMappingURL=qrcodegen.js.map