@bigbinary/neeto-molecules 4.1.41 → 4.1.43

package/dist/cjs/ShareViaLink.js

@@ -806,11 +806,19 @@ var __objRest = (source, exclude) => {
  */
 var qrcodegen;
 ((qrcodegen2) => {
-  const _QrCode = class {
+  const _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) {
       this.version = version;
       this.errorCorrectionLevel = errorCorrectionLevel;
+      // 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 = [];
       if (version < _QrCode.MIN_VERSION || version > _QrCode.MAX_VERSION)
         throw new RangeError("Version value out of range");
@@ -846,14 +854,34 @@ 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);
     }
+    // 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);
     }
+    /*-- 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)
         throw new RangeError("Invalid value");
@@ -894,12 +922,19 @@ var qrcodegen;
       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);
@@ -919,6 +954,8 @@ 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;
@@ -939,6 +976,8 @@ 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;
@@ -955,6 +994,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++) {
@@ -966,16 +1007,23 @@ 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);
       }
     }
+    // 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;
@@ -1006,6 +1054,8 @@ 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))
         throw new RangeError("Invalid argument");
@@ -1027,6 +1077,11 @@ 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");
@@ -1066,6 +1121,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++) {
@@ -1127,6 +1184,10 @@ var qrcodegen;
       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 [];
@@ -1139,6 +1200,9 @@ 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)
         throw new RangeError("Version number out of range");
@@ -1152,9 +1216,14 @@ var qrcodegen;
       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];
     }
+    // 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");
@@ -1173,6 +1242,7 @@ var qrcodegen;
       }
       return result;
     }
+    // Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
     static reedSolomonComputeRemainder(data, divisor) {
       let result = divisor.map((_) => 0);
       for (const b of data) {
@@ -1182,6 +1252,8 @@ var qrcodegen;
       }
       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");
@@ -1193,12 +1265,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);
@@ -1208,6 +1283,7 @@ 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;
@@ -1215,26 +1291,41 @@ var qrcodegen;
       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 = [
+  /*-- Constants and tables --*/
+  // The minimum version number supported in the QR Code Model 2 standard.
+  _QrCode.MIN_VERSION = 1;
+  // The maximum version number supported in the QR Code Model 2 standard.
+  _QrCode.MAX_VERSION = 40;
+  // For use in getPenaltyScore(), when evaluating which mask is best.
+  _QrCode.PENALTY_N1 = 3;
+  _QrCode.PENALTY_N2 = 3;
+  _QrCode.PENALTY_N3 = 40;
+  _QrCode.PENALTY_N4 = 10;
+  _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
   ];
-  QrCode.NUM_ERROR_CORRECTION_BLOCKS = [
+  _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
   ];
-  qrcodegen2.QrCode = QrCode;
+  qrcodegen2.QrCode = _QrCode;
   function appendBits(val, len, bb) {
     if (len < 0 || len > 31 || val >>> len != 0)
       throw new RangeError("Value out of range");
@@ -1248,7 +1339,11 @@ var qrcodegen;
     if (!cond)
       throw new Error("Assertion error");
   }
-  const _QrSegment = class {
+  const _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,
+    // but the constraint isn't checked. The given bit buffer is cloned and stored.
     constructor(mode, numChars, bitData) {
       this.mode = mode;
       this.numChars = numChars;
@@ -1257,23 +1352,31 @@ var qrcodegen;
         throw new RangeError("Invalid argument");
       this.bitData = bitData.slice();
     }
+    /*-- 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) {
       let 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))
         throw new RangeError("String contains non-numeric characters");
       let bb = [];
       for (let i = 0; i < digits.length; ) {
         const n = Math.min(digits.length - i, 3);
-        appendBits(parseInt(digits.substr(i, n), 10), n * 3 + 1, bb);
+        appendBits(parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
         i += n;
       }
       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");
@@ -1288,6 +1391,8 @@ var qrcodegen;
         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 [];
@@ -1298,6 +1403,8 @@ var qrcodegen;
       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) {
       let bb = [];
       if (assignVal < 0)
@@ -1314,15 +1421,24 @@ var qrcodegen;
         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);
     }
+    // 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);
     }
+    /*-- 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) {
@@ -1333,6 +1449,7 @@ var qrcodegen;
       }
       return result;
     }
+    // Returns a new array of bytes representing the given string encoded in UTF-8.
     static toUtf8ByteArray(str) {
       str = encodeURI(str);
       let result = [];
@@ -1340,53 +1457,67 @@ var qrcodegen;
         if (str.charAt(i) != "%")
           result.push(str.charCodeAt(i));
         else {
-          result.push(parseInt(str.substr(i + 1, 2), 16));
+          result.push(parseInt(str.substring(i + 1, i + 3), 16));
           i += 2;
         }
       }
       return result;
     }
   };
+  /*-- Constants --*/
+  // Describes precisely all strings that are encodable in numeric mode.
+  _QrSegment.NUMERIC_REGEX = /^[0-9]*$/;
+  // Describes precisely all strings that are encodable in alphanumeric mode.
+  _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.
+  _QrSegment.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
   let QrSegment = _QrSegment;
-  QrSegment.NUMERIC_REGEX = /^[0-9]*$/;
-  QrSegment.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
-  QrSegment.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
-  qrcodegen2.QrSegment = QrSegment;
+  qrcodegen2.QrSegment = _QrSegment;
 })(qrcodegen || (qrcodegen = {}));
 ((qrcodegen2) => {
   ((QrCode2) => {
-    const _Ecc = class {
+    const _Ecc = class _Ecc {
+      // The QR Code can tolerate about 30% erroneous codewords
+      /*-- Constructor and fields --*/
       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;
+    /*-- Constants --*/
+    _Ecc.LOW = new _Ecc(0, 1);
+    // The QR Code can tolerate about  7% erroneous codewords
+    _Ecc.MEDIUM = new _Ecc(1, 0);
+    // The QR Code can tolerate about 15% erroneous codewords
+    _Ecc.QUARTILE = new _Ecc(2, 3);
+    // The QR Code can tolerate about 25% erroneous codewords
+    _Ecc.HIGH = new _Ecc(3, 2);
+    QrCode2.Ecc = _Ecc;
   })(qrcodegen2.QrCode || (qrcodegen2.QrCode = {}));
 })(qrcodegen || (qrcodegen = {}));
 ((qrcodegen2) => {
   ((QrSegment2) => {
-    const _Mode = class {
+    const _Mode = class _Mode {
+      /*-- Constructor and fields --*/
       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;
+    /*-- Constants --*/
+    _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;
   })(qrcodegen2.QrSegment || (qrcodegen2.QrSegment = {}));
 })(qrcodegen || (qrcodegen = {}));
 var qrcodegen_default = qrcodegen;
@@ -1408,7 +1539,9 @@ var DEFAULT_LEVEL = "L";
 var DEFAULT_BGCOLOR = "#FFFFFF";
 var DEFAULT_FGCOLOR = "#000000";
 var DEFAULT_INCLUDEMARGIN = false;
-var MARGIN_SIZE = 4;
+var DEFAULT_MINVERSION = 1;
+var SPEC_MARGIN_SIZE = 4;
+var DEFAULT_MARGIN_SIZE = 0;
 var DEFAULT_IMG_SCALE = 0.1;
 function generatePath(modules, margin = 0) {
   const ops = [];
@@ -1416,7 +1549,9 @@ function generatePath(modules, margin = 0) {
     let start = null;
     row.forEach(function(cell, x) {
       if (!cell && start !== null) {
-        ops.push(`M${start + margin} ${y + margin}h${x - start}v1H${start + margin}z`);
+        ops.push(
+          `M${start + margin} ${y + margin}h${x - start}v1H${start + margin}z`
+        );
         start = null;
         return;
       }
@@ -1427,7 +1562,9 @@ function generatePath(modules, margin = 0) {
         if (start === null) {
           ops.push(`M${x + margin},${y + margin} h1v1H${x + margin}z`);
         } else {
-          ops.push(`M${start + margin},${y + margin} h${x + 1 - start}v1H${start + margin}z`);
+          ops.push(
+            `M${start + margin},${y + margin} h${x + 1 - start}v1H${start + margin}z`
+          );
         }
         return;
       }
@@ -1451,11 +1588,10 @@ function excavateModules(modules, excavation) {
     });
   });
 }
-function getImageSettings(cells, size, includeMargin, imageSettings) {
+function getImageSettings(cells, size, margin, imageSettings) {
   if (imageSettings == null) {
     return null;
   }
-  const margin = includeMargin ? MARGIN_SIZE : 0;
   const numCells = cells.length + margin * 2;
   const defaultSize = Math.floor(size * DEFAULT_IMG_SCALE);
   const scale = numCells / size;
@@ -1463,6 +1599,7 @@ function getImageSettings(cells, size, includeMargin, imageSettings) {
   const h = (imageSettings.height || defaultSize) * scale;
   const x = imageSettings.x == null ? cells.length / 2 - w / 2 : imageSettings.x * scale;
   const y = imageSettings.y == null ? cells.length / 2 - h / 2 : imageSettings.y * scale;
+  const opacity = imageSettings.opacity == null ? 1 : imageSettings.opacity;
   let excavation = null;
   if (imageSettings.excavate) {
     let floorX = Math.floor(x);
@@ -1471,7 +1608,64 @@ function getImageSettings(cells, size, includeMargin, imageSettings) {
     let ceilH = Math.ceil(h + y - floorY);
     excavation = { x: floorX, y: floorY, w: ceilW, h: ceilH };
   }
-  return { x, y, h, w, excavation };
+  const crossOrigin = imageSettings.crossOrigin;
+  return { x, y, h, w, excavation, opacity, crossOrigin };
+}
+function getMarginSize(includeMargin, marginSize) {
+  if (marginSize != null) {
+    return Math.max(Math.floor(marginSize), 0);
+  }
+  return includeMargin ? SPEC_MARGIN_SIZE : DEFAULT_MARGIN_SIZE;
+}
+function useQRCode({
+  value,
+  level,
+  minVersion,
+  includeMargin,
+  marginSize,
+  imageSettings,
+  size,
+  boostLevel
+}) {
+  let qrcode = React.useMemo(() => {
+    const values = Array.isArray(value) ? value : [value];
+    const segments = values.reduce((accum, v) => {
+      accum.push(...qrcodegen_default.QrSegment.makeSegments(v));
+      return accum;
+    }, []);
+    return qrcodegen_default.QrCode.encodeSegments(
+      segments,
+      ERROR_LEVEL_MAP[level],
+      minVersion,
+      void 0,
+      void 0,
+      boostLevel
+    );
+  }, [value, level, minVersion, boostLevel]);
+  const { cells, margin, numCells, calculatedImageSettings } = React.useMemo(() => {
+    let cells2 = qrcode.getModules();
+    const margin2 = getMarginSize(includeMargin, marginSize);
+    const numCells2 = cells2.length + margin2 * 2;
+    const calculatedImageSettings2 = getImageSettings(
+      cells2,
+      size,
+      margin2,
+      imageSettings
+    );
+    return {
+      cells: cells2,
+      margin: margin2,
+      numCells: numCells2,
+      calculatedImageSettings: calculatedImageSettings2
+    };
+  }, [qrcode, size, imageSettings, includeMargin, marginSize]);
+  return {
+    qrcode,
+    margin,
+    cells,
+    numCells,
+    calculatedImageSettings
+  };
 }
 var SUPPORTS_PATH2D = function() {
   try {
@@ -1481,152 +1675,225 @@ var SUPPORTS_PATH2D = function() {
   }
   return true;
 }();
-function QRCodeCanvas(props) {
-  const _a = props, {
-    value,
-    size = DEFAULT_SIZE,
-    level = DEFAULT_LEVEL,
-    bgColor = DEFAULT_BGCOLOR,
-    fgColor = DEFAULT_FGCOLOR,
-    includeMargin = DEFAULT_INCLUDEMARGIN,
-    style,
-    imageSettings
-  } = _a, otherProps = __objRest(_a, [
-    "value",
-    "size",
-    "level",
-    "bgColor",
-    "fgColor",
-    "includeMargin",
-    "style",
-    "imageSettings"
-  ]);
-  const imgSrc = imageSettings == null ? void 0 : imageSettings.src;
-  const _canvas = React.useRef(null);
-  const _image = React.useRef(null);
-  const [isImgLoaded, setIsImageLoaded] = React.useState(false);
-  React.useEffect(() => {
-    if (_canvas.current != null) {
-      const canvas = _canvas.current;
-      const ctx = canvas.getContext("2d");
-      if (!ctx) {
-        return;
-      }
-      let cells = qrcodegen_default.QrCode.encodeText(value, ERROR_LEVEL_MAP[level]).getModules();
-      const margin = includeMargin ? MARGIN_SIZE : 0;
-      const numCells = cells.length + margin * 2;
-      const calculatedImageSettings = getImageSettings(cells, size, includeMargin, imageSettings);
-      const image = _image.current;
-      const haveImageToRender = calculatedImageSettings != null && image !== null && image.complete && image.naturalHeight !== 0 && image.naturalWidth !== 0;
-      if (haveImageToRender) {
-        if (calculatedImageSettings.excavation != null) {
-          cells = excavateModules(cells, calculatedImageSettings.excavation);
+var QRCodeCanvas = React.forwardRef(
+  function QRCodeCanvas2(props, forwardedRef) {
+    const _a = props, {
+      value,
+      size = DEFAULT_SIZE,
+      level = DEFAULT_LEVEL,
+      bgColor = DEFAULT_BGCOLOR,
+      fgColor = DEFAULT_FGCOLOR,
+      includeMargin = DEFAULT_INCLUDEMARGIN,
+      minVersion = DEFAULT_MINVERSION,
+      boostLevel,
+      marginSize,
+      imageSettings
+    } = _a, extraProps = __objRest(_a, [
+      "value",
+      "size",
+      "level",
+      "bgColor",
+      "fgColor",
+      "includeMargin",
+      "minVersion",
+      "boostLevel",
+      "marginSize",
+      "imageSettings"
+    ]);
+    const _b = extraProps, { style } = _b, otherProps = __objRest(_b, ["style"]);
+    const imgSrc = imageSettings == null ? void 0 : imageSettings.src;
+    const _canvas = React.useRef(null);
+    const _image = React.useRef(null);
+    const setCanvasRef = React.useCallback(
+      (node) => {
+        _canvas.current = node;
+        if (typeof forwardedRef === "function") {
+          forwardedRef(node);
+        } else if (forwardedRef) {
+          forwardedRef.current = node;
         }
-      }
-      const pixelRatio = window.devicePixelRatio || 1;
-      canvas.height = canvas.width = size * pixelRatio;
-      const scale = size / numCells * pixelRatio;
-      ctx.scale(scale, scale);
-      ctx.fillStyle = bgColor;
-      ctx.fillRect(0, 0, numCells, numCells);
-      ctx.fillStyle = fgColor;
-      if (SUPPORTS_PATH2D) {
-        ctx.fill(new Path2D(generatePath(cells, margin)));
-      } else {
-        cells.forEach(function(row, rdx) {
-          row.forEach(function(cell, cdx) {
-            if (cell) {
-              ctx.fillRect(cdx + margin, rdx + margin, 1, 1);
-            }
+      },
+      [forwardedRef]
+    );
+    const [isImgLoaded, setIsImageLoaded] = React.useState(false);
+    const { margin, cells, numCells, calculatedImageSettings } = useQRCode({
+      value,
+      level,
+      minVersion,
+      boostLevel,
+      includeMargin,
+      marginSize,
+      imageSettings,
+      size
+    });
+    React.useEffect(() => {
+      if (_canvas.current != null) {
+        const canvas = _canvas.current;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          return;
+        }
+        let cellsToDraw = cells;
+        const image = _image.current;
+        const haveImageToRender = calculatedImageSettings != null && image !== null && image.complete && image.naturalHeight !== 0 && image.naturalWidth !== 0;
+        if (haveImageToRender) {
+          if (calculatedImageSettings.excavation != null) {
+            cellsToDraw = excavateModules(
+              cells,
+              calculatedImageSettings.excavation
+            );
+          }
+        }
+        const pixelRatio = window.devicePixelRatio || 1;
+        canvas.height = canvas.width = size * pixelRatio;
+        const scale = size / numCells * pixelRatio;
+        ctx.scale(scale, scale);
+        ctx.fillStyle = bgColor;
+        ctx.fillRect(0, 0, numCells, numCells);
+        ctx.fillStyle = fgColor;
+        if (SUPPORTS_PATH2D) {
+          ctx.fill(new Path2D(generatePath(cellsToDraw, margin)));
+        } else {
+          cells.forEach(function(row, rdx) {
+            row.forEach(function(cell, cdx) {
+              if (cell) {
+                ctx.fillRect(cdx + margin, rdx + margin, 1, 1);
+              }
+            });
           });
-        });
-      }
-      if (haveImageToRender) {
-        ctx.drawImage(image, calculatedImageSettings.x + margin, calculatedImageSettings.y + margin, calculatedImageSettings.w, calculatedImageSettings.h);
+        }
+        if (calculatedImageSettings) {
+          ctx.globalAlpha = calculatedImageSettings.opacity;
+        }
+        if (haveImageToRender) {
+          ctx.drawImage(
+            image,
+            calculatedImageSettings.x + margin,
+            calculatedImageSettings.y + margin,
+            calculatedImageSettings.w,
+            calculatedImageSettings.h
+          );
+        }
       }
-    }
-  });
-  React.useEffect(() => {
-    setIsImageLoaded(false);
-  }, [imgSrc]);
-  const canvasStyle = __spreadValues({ height: size, width: size }, style);
-  let img = null;
-  if (imgSrc != null) {
-    img = /* @__PURE__ */ React.createElement("img", {
-      src: imgSrc,
-      key: imgSrc,
-      style: { display: "none" },
-      onLoad: () => {
-        setIsImageLoaded(true);
-      },
-      ref: _image
     });
-  }
-  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("canvas", __spreadValues({
-    style: canvasStyle,
-    height: size,
-    width: size,
-    ref: _canvas
-  }, otherProps)), img);
-}
-function QRCodeSVG(props) {
-  const _a = props, {
-    value,
-    size = DEFAULT_SIZE,
-    level = DEFAULT_LEVEL,
-    bgColor = DEFAULT_BGCOLOR,
-    fgColor = DEFAULT_FGCOLOR,
-    includeMargin = DEFAULT_INCLUDEMARGIN,
-    imageSettings
-  } = _a, otherProps = __objRest(_a, [
-    "value",
-    "size",
-    "level",
-    "bgColor",
-    "fgColor",
-    "includeMargin",
-    "imageSettings"
-  ]);
-  let cells = qrcodegen_default.QrCode.encodeText(value, ERROR_LEVEL_MAP[level]).getModules();
-  const margin = includeMargin ? MARGIN_SIZE : 0;
-  const numCells = cells.length + margin * 2;
-  const calculatedImageSettings = getImageSettings(cells, size, includeMargin, imageSettings);
-  let image = null;
-  if (imageSettings != null && calculatedImageSettings != null) {
-    if (calculatedImageSettings.excavation != null) {
-      cells = excavateModules(cells, calculatedImageSettings.excavation);
+    React.useEffect(() => {
+      setIsImageLoaded(false);
+    }, [imgSrc]);
+    const canvasStyle = __spreadValues({ height: size, width: size }, style);
+    let img = null;
+    if (imgSrc != null) {
+      img = /* @__PURE__ */ React.createElement(
+        "img",
+        {
+          src: imgSrc,
+          key: imgSrc,
+          style: { display: "none" },
+          onLoad: () => {
+            setIsImageLoaded(true);
+          },
+          ref: _image,
+          crossOrigin: calculatedImageSettings == null ? void 0 : calculatedImageSettings.crossOrigin
+        }
+      );
     }
-    image = /* @__PURE__ */ React.createElement("image", {
-      xlinkHref: imageSettings.src,
-      height: calculatedImageSettings.h,
-      width: calculatedImageSettings.w,
-      x: calculatedImageSettings.x + margin,
-      y: calculatedImageSettings.y + margin,
-      preserveAspectRatio: "none"
-    });
+    return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+      "canvas",
+      __spreadValues({
+        style: canvasStyle,
+        height: size,
+        width: size,
+        ref: setCanvasRef,
+        role: "img"
+      }, otherProps)
+    ), img);
   }
-  const fgPath = generatePath(cells, margin);
-  return /* @__PURE__ */ React.createElement("svg", __spreadValues({
-    height: size,
-    width: size,
-    viewBox: `0 0 ${numCells} ${numCells}`
-  }, otherProps), /* @__PURE__ */ React.createElement("path", {
-    fill: bgColor,
-    d: `M0,0 h${numCells}v${numCells}H0z`,
-    shapeRendering: "crispEdges"
-  }), /* @__PURE__ */ React.createElement("path", {
-    fill: fgColor,
-    d: fgPath,
-    shapeRendering: "crispEdges"
-  }), image);
-}
-var QRCode$1 = (props) => {
-  const _a = props, { renderAs } = _a, otherProps = __objRest(_a, ["renderAs"]);
-  if (renderAs === "svg") {
-    return /* @__PURE__ */ React.createElement(QRCodeSVG, __spreadValues({}, otherProps));
+);
+QRCodeCanvas.displayName = "QRCodeCanvas";
+var QRCodeSVG = React.forwardRef(
+  function QRCodeSVG2(props, forwardedRef) {
+    const _a = props, {
+      value,
+      size = DEFAULT_SIZE,
+      level = DEFAULT_LEVEL,
+      bgColor = DEFAULT_BGCOLOR,
+      fgColor = DEFAULT_FGCOLOR,
+      includeMargin = DEFAULT_INCLUDEMARGIN,
+      minVersion = DEFAULT_MINVERSION,
+      boostLevel,
+      title,
+      marginSize,
+      imageSettings
+    } = _a, otherProps = __objRest(_a, [
+      "value",
+      "size",
+      "level",
+      "bgColor",
+      "fgColor",
+      "includeMargin",
+      "minVersion",
+      "boostLevel",
+      "title",
+      "marginSize",
+      "imageSettings"
+    ]);
+    const { margin, cells, numCells, calculatedImageSettings } = useQRCode({
+      value,
+      level,
+      minVersion,
+      boostLevel,
+      includeMargin,
+      marginSize,
+      imageSettings,
+      size
+    });
+    let cellsToDraw = cells;
+    let image = null;
+    if (imageSettings != null && calculatedImageSettings != null) {
+      if (calculatedImageSettings.excavation != null) {
+        cellsToDraw = excavateModules(
+          cells,
+          calculatedImageSettings.excavation
+        );
+      }
+      image = /* @__PURE__ */ React.createElement(
+        "image",
+        {
+          href: imageSettings.src,
+          height: calculatedImageSettings.h,
+          width: calculatedImageSettings.w,
+          x: calculatedImageSettings.x + margin,
+          y: calculatedImageSettings.y + margin,
+          preserveAspectRatio: "none",
+          opacity: calculatedImageSettings.opacity,
+          crossOrigin: calculatedImageSettings.crossOrigin
+        }
+      );
+    }
+    const fgPath = generatePath(cellsToDraw, margin);
+    return /* @__PURE__ */ React.createElement(
+      "svg",
+      __spreadValues({
+        height: size,
+        width: size,
+        viewBox: `0 0 ${numCells} ${numCells}`,
+        ref: forwardedRef,
+        role: "img"
+      }, otherProps),
+      !!title && /* @__PURE__ */ React.createElement("title", null, title),
+      /* @__PURE__ */ React.createElement(
+        "path",
+        {
+          fill: bgColor,
+          d: `M0,0 h${numCells}v${numCells}H0z`,
+          shapeRendering: "crispEdges"
+        }
+      ),
+      /* @__PURE__ */ React.createElement("path", { fill: fgColor, d: fgPath, shapeRendering: "crispEdges" }),
+      image
+    );
   }
-  return /* @__PURE__ */ React.createElement(QRCodeCanvas, __spreadValues({}, otherProps));
-};
+);
+QRCodeSVG.displayName = "QRCodeSVG";
 
 var QRCode = function QRCode(_ref) {
   var entity = _ref.entity,
@@ -1682,7 +1949,7 @@ var QRCode = function QRCode(_ref) {
           onClick: handleCopyQRCode
         })]
       }),
-      children: /*#__PURE__*/jsxRuntime.jsx(QRCode$1, {
+      children: /*#__PURE__*/jsxRuntime.jsx(QRCodeCanvas, {
         className: "mt-6 cursor-pointer",
         "data-testid": "qr-code-image",
         id: canvasId,