ele-admin-plus 1.4.1 → 1.5.0-beta.1

package/es/ele-qr-code/qrcodegen.js

@@ -1,31 +1,15 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var qrcodegen;
 ((qrcodegen2) => {
-  const _QrCode = class _QrCode {
+  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) {
-      /*-- Fields --*/
-      // The width and height of this QR Code, measured in modules, between
-      // 21 and 177 (inclusive). This is equal to version * 4 + 17.
-      __publicField(this, "size");
-      // The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
-      // Even if a QR Code is created with automatic masking requested (mask = -1),
-      // the resulting object still has a mask value between 0 and 7.
-      __publicField(this, "mask");
-      // The modules of this QR Code (false = light, true = dark).
-      // Immutable after constructor finishes. Accessed through getModule().
-      __publicField(this, "modules", []);
-      // Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
-      __publicField(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 "Version value out of range";
       if (msk < -1 || msk > 7) throw "Mask value out of range";
       this.size = version * 4 + 17;
@@ -65,7 +49,7 @@ var qrcodegen;
     // 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
@@ -73,7 +57,7 @@ var qrcodegen;
     // 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.
@@ -86,12 +70,12 @@ var qrcodegen;
     // 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 "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;
@@ -101,11 +85,11 @@ var qrcodegen;
           throw "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;
       }
       let bb = [];
@@ -115,7 +99,7 @@ var qrcodegen;
         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);
@@ -127,8 +111,21 @@ var qrcodegen;
       bb.forEach(
         (b, i) => dataCodewords[i >>> 3] |= b << 7 - (i & 7)
       );
-      return new _QrCode(version, ecl, dataCodewords, mask);
+      return new QrCode(version, ecl, dataCodewords, mask);
     }
+    /*-- Fields --*/
+    // The width and height of this QR Code, measured in modules, between
+    // 21 and 177 (inclusive). This is equal to version * 4 + 17.
+    size;
+    // The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+    // Even if a QR Code is created with automatic masking requested (mask = -1),
+    // the resulting object still has a mask value between 0 and 7.
+    mask;
+    // The modules of this QR Code (false = light, true = dark).
+    // Immutable after constructor finishes. Accessed through getModule().
+    modules = [];
+    // Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+    isFunction = [];
     /*-- 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).
@@ -235,24 +232,24 @@ var qrcodegen;
     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 "Invalid argument";
-      const numBlocks = _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
-      const blockEccLen = _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];
+      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
+        QrCode.getNumRawDataModules(ver) / 8
       );
       const numShortBlocks = numBlocks - rawCodewords % numBlocks;
       const shortBlockLen = Math.floor(rawCodewords / numBlocks);
       let blocks = [];
-      const rsDiv = _QrCode.reedSolomonComputeDivisor(blockEccLen);
+      const rsDiv = QrCode.reedSolomonComputeDivisor(blockEccLen);
       for (let i = 0, k = 0; i < numBlocks; i++) {
         let dat = data.slice(
           k,
           k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1)
         );
         k += dat.length;
-        const ecc = _QrCode.reedSolomonComputeRemainder(dat, rsDiv);
+        const ecc = QrCode.reedSolomonComputeRemainder(dat, rsDiv);
         if (i < numShortBlocks) dat.push(0);
         blocks.push(dat.concat(ecc));
       }
@@ -269,7 +266,7 @@ var qrcodegen;
     // 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 "Invalid argument";
       let i = 0;
       for (let right = this.size - 1; right >= 1; right -= 2) {
@@ -342,17 +339,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;
+            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;
@@ -361,23 +358,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;
+            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;
@@ -386,7 +383,7 @@ 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;
     }
@@ -409,7 +406,7 @@ var qrcodegen;
     // 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 "Version number out of range";
       let result = (16 * ver + 128) * ver + 64;
       if (ver >= 2) {
@@ -424,7 +421,7 @@ var qrcodegen;
     // 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.
@@ -436,10 +433,10 @@ var qrcodegen;
       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);
+          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;
     }
@@ -450,7 +447,7 @@ var qrcodegen;
         const factor = b ^ result.shift();
         result.push(0);
         divisor.forEach(
-          (coef, i) => result[i] ^= _QrCode.reedSolomonMultiply(coef, factor)
+          (coef, i) => result[i] ^= QrCode.reedSolomonMultiply(coef, factor)
         );
       }
       return result;
@@ -491,378 +488,377 @@ var qrcodegen;
       runHistory.pop();
       runHistory.unshift(currentRunLength);
     }
-  };
-  /*-- Constants and tables --*/
-  // The minimum version number supported in the QR Code Model 2 standard.
-  __publicField(_QrCode, "MIN_VERSION", 1);
-  // The maximum version number supported in the QR Code Model 2 standard.
-  __publicField(_QrCode, "MAX_VERSION", 40);
-  // For use in getPenaltyScore(), when evaluating which mask is best.
-  __publicField(_QrCode, "PENALTY_N1", 3);
-  __publicField(_QrCode, "PENALTY_N2", 3);
-  __publicField(_QrCode, "PENALTY_N3", 40);
-  __publicField(_QrCode, "PENALTY_N4", 10);
-  __publicField(_QrCode, "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
-  ]);
-  __publicField(_QrCode, "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
-  ]);
-  let QrCode = _QrCode;
+    /*-- Constants and tables --*/
+    // The minimum version number supported in the QR Code Model 2 standard.
+    static MIN_VERSION = 1;
+    // The maximum version number supported in the QR Code Model 2 standard.
+    static MAX_VERSION = 40;
+    // For use in getPenaltyScore(), when evaluating which mask is best.
+    static PENALTY_N1 = 3;
+    static PENALTY_N2 = 3;
+    static PENALTY_N3 = 40;
+    static PENALTY_N4 = 10;
+    static 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 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) throw "Value out of range";
@@ -875,7 +871,7 @@ var qrcodegen;
   function assert(cond) {
     if (!cond) throw "Assertion error";
   }
-  const _QrSegment = class _QrSegment {
+  class QrSegment {
     /*-- Constructor (low level) and fields --*/
     // 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,
@@ -894,11 +890,11 @@ var qrcodegen;
     static makeBytes(data) {
       let bb = [];
       for (const b of data) appendBits(b, 8, bb);
-      return new _QrSegment(_QrSegment.Mode.BYTE, data.length, 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 "String contains non-numeric characters";
       let bb = [];
       for (let i = 0; i < digits.length; ) {
@@ -906,37 +902,37 @@ var qrcodegen;
         appendBits(Number.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))
+      if (!QrSegment.isAlphanumeric(text))
         throw "String contains unencodable characters in alphanumeric mode";
       let 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)),
+          QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)),
           6,
           bb
         );
-      return new _QrSegment(_QrSegment.Mode.ALPHANUMERIC, text.length, 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))];
+      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.
@@ -951,18 +947,18 @@ var qrcodegen;
         appendBits(6, 3, bb);
         appendBits(assignVal, 21, bb);
       } else throw "ECI assignment value out of range";
-      return new _QrSegment(_QrSegment.Mode.ECI, 0, bb);
+      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);
     }
     /*-- Methods --*/
     // Returns a new copy of the data bits of this segment.
@@ -993,62 +989,59 @@ var qrcodegen;
       }
       return result;
     }
-  };
-  /*-- Constants --*/
-  // Describes precisely all strings that are encodable in numeric mode.
-  __publicField(_QrSegment, "NUMERIC_REGEX", /^[0-9]*$/);
-  // Describes precisely all strings that are encodable in alphanumeric mode.
-  __publicField(_QrSegment, "ALPHANUMERIC_REGEX", /^[A-Z0-9 $%*+.\/:-]*$/);
-  // The set of all legal characters in alphanumeric mode,
-  // where each character value maps to the index in the string.
-  __publicField(_QrSegment, "ALPHANUMERIC_CHARSET", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:");
-  let QrSegment = _QrSegment;
+    /*-- Constants --*/
+    // Describes precisely all strings that are encodable in numeric mode.
+    static NUMERIC_REGEX = /^[0-9]*$/;
+    // Describes precisely all strings that are encodable in alphanumeric mode.
+    static ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
+    // The set of all legal characters in alphanumeric mode,
+    // where each character value maps to the index in the string.
+    static ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+  }
   qrcodegen2.QrSegment = QrSegment;
 })(qrcodegen || (qrcodegen = {}));
 ((qrcodegen2) => {
   ((QrCode2) => {
-    const _Ecc = class _Ecc {
+    class Ecc {
       // The QR Code can tolerate about 30% erroneous codewords
       /*-- Constructor and fields --*/
       constructor(ordinal, formatBits) {
         this.ordinal = ordinal;
         this.formatBits = formatBits;
       }
-    };
-    /*-- Constants --*/
-    __publicField(_Ecc, "LOW", new _Ecc(0, 1));
-    // The QR Code can tolerate about  7% erroneous codewords
-    __publicField(_Ecc, "MEDIUM", new _Ecc(1, 0));
-    // The QR Code can tolerate about 15% erroneous codewords
-    __publicField(_Ecc, "QUARTILE", new _Ecc(2, 3));
-    // The QR Code can tolerate about 25% erroneous codewords
-    __publicField(_Ecc, "HIGH", new _Ecc(3, 2));
-    let Ecc = _Ecc;
+      /*-- Constants --*/
+      static LOW = new Ecc(0, 1);
+      // The QR Code can tolerate about  7% erroneous codewords
+      static MEDIUM = new Ecc(1, 0);
+      // The QR Code can tolerate about 15% erroneous codewords
+      static QUARTILE = new Ecc(2, 3);
+      // The QR Code can tolerate about 25% erroneous codewords
+      static HIGH = new Ecc(3, 2);
+    }
     QrCode2.Ecc = Ecc;
   })(qrcodegen2.QrCode || (qrcodegen2.QrCode = {}));
 })(qrcodegen || (qrcodegen = {}));
 ((qrcodegen2) => {
   ((QrSegment2) => {
-    const _Mode = class _Mode {
+    class Mode {
       /*-- Constructor and fields --*/
       constructor(modeBits, numBitsCharCount) {
         this.modeBits = modeBits;
         this.numBitsCharCount = numBitsCharCount;
       }
+      /*-- Constants --*/
+      static NUMERIC = new Mode(1, [10, 12, 14]);
+      static ALPHANUMERIC = new Mode(2, [9, 11, 13]);
+      static BYTE = new Mode(4, [8, 16, 16]);
+      static KANJI = new Mode(8, [8, 10, 12]);
+      static ECI = new Mode(7, [0, 0, 0]);
       /*-- 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)];
       }
-    };
-    /*-- Constants --*/
-    __publicField(_Mode, "NUMERIC", new _Mode(1, [10, 12, 14]));
-    __publicField(_Mode, "ALPHANUMERIC", new _Mode(2, [9, 11, 13]));
-    __publicField(_Mode, "BYTE", new _Mode(4, [8, 16, 16]));
-    __publicField(_Mode, "KANJI", new _Mode(8, [8, 10, 12]));
-    __publicField(_Mode, "ECI", new _Mode(7, [0, 0, 0]));
-    let Mode = _Mode;
+    }
     QrSegment2.Mode = Mode;
   })(qrcodegen2.QrSegment || (qrcodegen2.QrSegment = {}));
 })(qrcodegen || (qrcodegen = {}));