@multiplatform.one/forms 7.4.1 → 7.6.0

package/dist/esm/fields/Barcode/qr.native.js

@@ -0,0 +1,607 @@
+var QR_QUIET_ZONE_MODULES = 4;
+var MAX_VERSION = 10;
+var TOTAL_CODEWORDS = [26, 44, 70, 100, 134, 172, 196, 242, 292, 346];
+var EC_BLOCKS = {
+  L: [[7, [[1, 19]]], [10, [[1, 34]]], [15, [[1, 55]]], [20, [[1, 80]]], [26, [[1, 108]]], [18, [[2, 68]]], [20, [[2, 78]]], [24, [[2, 97]]], [30, [[2, 116]]], [18, [[2, 68], [2, 69]]]],
+  M: [[10, [[1, 16]]], [16, [[1, 28]]], [26, [[1, 44]]], [18, [[2, 32]]], [24, [[2, 43]]], [16, [[4, 27]]], [18, [[4, 31]]], [22, [[2, 38], [2, 39]]], [22, [[3, 36], [2, 37]]], [26, [[4, 43], [1, 44]]]],
+  Q: [[13, [[1, 13]]], [22, [[1, 22]]], [18, [[2, 17]]], [26, [[2, 24]]], [18, [[2, 15], [2, 16]]], [24, [[4, 19]]], [18, [[2, 14], [4, 15]]], [22, [[4, 18], [2, 19]]], [20, [[4, 16], [4, 17]]], [24, [[6, 19], [2, 20]]]],
+  H: [[17, [[1, 9]]], [28, [[1, 16]]], [22, [[2, 13]]], [16, [[4, 9]]], [22, [[2, 11], [2, 12]]], [28, [[4, 15]]], [26, [[4, 13], [1, 14]]], [26, [[4, 14], [2, 15]]], [24, [[4, 12], [4, 13]]], [28, [[6, 15], [2, 16]]]]
+};
+var ALIGNMENT_CENTERS = [[], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34], [6, 22, 38], [6, 24, 42], [6, 26, 46], [6, 28, 50]];
+var EC_INDICATOR = {
+  L: 1,
+  M: 0,
+  Q: 3,
+  H: 2
+};
+var GF_EXP = new Uint8Array(512);
+var GF_LOG = new Uint8Array(256);
+{
+  var x = 1;
+  for (var i = 0; i < 255; i++) {
+    GF_EXP[i] = x;
+    GF_LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (var i1 = 255; i1 < 512; i1++) GF_EXP[i1] = GF_EXP[i1 - 255];
+}
+function gfMultiply(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+}
+function rsGeneratorPoly(degree) {
+  var poly = new Uint8Array([1]);
+  for (var i = 0; i < degree; i++) {
+    var next = new Uint8Array(poly.length + 1);
+    for (var j = 0; j < poly.length; j++) {
+      next[j] ^= poly[j];
+      next[j + 1] ^= gfMultiply(poly[j], GF_EXP[i]);
+    }
+    poly = next;
+  }
+  return poly;
+}
+function rsEncode(data, degree) {
+  var generator = rsGeneratorPoly(degree);
+  var remainder = new Uint8Array(degree);
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var byte = _step.value;
+      var factor = byte ^ remainder[0];
+      remainder.copyWithin(0, 1);
+      remainder[degree - 1] = 0;
+      if (factor !== 0) {
+        for (var j = 0; j < degree; j++) remainder[j] ^= gfMultiply(generator[j + 1], factor);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return remainder;
+}
+function bitLength(value) {
+  var length = 0;
+  for (var v = value; v > 0; v >>>= 1) length++;
+  return length;
+}
+function bchRemainder(value, generator) {
+  var generatorLength = bitLength(generator);
+  var remainder = value;
+  while (bitLength(remainder) >= generatorLength) {
+    remainder ^= generator << bitLength(remainder) - generatorLength;
+  }
+  return remainder;
+}
+function formatInformation(ecLevel, mask) {
+  var data = EC_INDICATOR[ecLevel] << 3 | mask;
+  return (data << 10 | bchRemainder(data << 10, 1335)) ^ 21522;
+}
+function versionInformation(version) {
+  return version << 12 | bchRemainder(version << 12, 7973);
+}
+function utf8Bytes(value) {
+  var bytes = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var char = _step.value;
+      var cp = char.codePointAt(0);
+      if (cp < 128) bytes.push(cp);else if (cp < 2048) bytes.push(192 | cp >> 6, 128 | cp & 63);else if (cp < 65536) {
+        bytes.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+      } else {
+        bytes.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return bytes;
+}
+function dataCodewordCount(version, ecLevel) {
+  var [, groups] = EC_BLOCKS[ecLevel][version - 1];
+  return groups.reduce(function (sum, param) {
+    var [blocks, perBlock] = param;
+    return sum + blocks * perBlock;
+  }, 0);
+}
+function charCountBits(version) {
+  return version <= 9 ? 8 : 16;
+}
+function pickVersion(byteCount, ecLevel) {
+  for (var version = 1; version <= MAX_VERSION; version++) {
+    var capacityBits = dataCodewordCount(version, ecLevel) * 8;
+    var neededBits = 4 + charCountBits(version) + byteCount * 8;
+    if (neededBits <= capacityBits) return version;
+  }
+  return null;
+}
+function buildDataCodewords(bytes, version, ecLevel) {
+  var bits = [];
+  var pushBits = function pushBits2(value, length) {
+    for (var i2 = length - 1; i2 >= 0; i2--) bits.push(value >> i2 & 1);
+  };
+  pushBits(4, 4);
+  pushBits(bytes.length, charCountBits(version));
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = bytes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var byte = _step.value;
+      pushBits(byte, 8);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var capacityBits = dataCodewordCount(version, ecLevel) * 8;
+  pushBits(0, Math.min(4, capacityBits - bits.length));
+  if (bits.length % 8 !== 0) pushBits(0, 8 - bits.length % 8);
+  var codewords = new Uint8Array(capacityBits / 8);
+  for (var i = 0; i < bits.length; i++) {
+    if (bits[i]) codewords[i >> 3] |= 128 >> (i & 7);
+  }
+  var padBytes = [236, 17];
+  for (var i1 = bits.length / 8; i1 < codewords.length; i1++) {
+    codewords[i1] = padBytes[(i1 - bits.length / 8) % 2];
+  }
+  return codewords;
+}
+function interleaveCodewords(data, version, ecLevel) {
+  var [ecPerBlock, groups] = EC_BLOCKS[ecLevel][version - 1];
+  var dataBlocks = [];
+  var ecBlocks = [];
+  var offset = 0;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = groups[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [blockCount, perBlock] = _step.value;
+      for (var b = 0; b < blockCount; b++) {
+        var block = data.subarray(offset, offset + perBlock);
+        offset += perBlock;
+        dataBlocks.push(block);
+        ecBlocks.push(rsEncode(block, ecPerBlock));
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var result = new Uint8Array(TOTAL_CODEWORDS[version - 1]);
+  var index = 0;
+  var maxDataLength = Math.max(...dataBlocks.map(function (block3) {
+    return block3.length;
+  }));
+  for (var i = 0; i < maxDataLength; i++) {
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = dataBlocks[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var block1 = _step1.value;
+        if (i < block1.length) result[index++] = block1[i];
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+  }
+  for (var i1 = 0; i1 < ecPerBlock; i1++) {
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = ecBlocks[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var block2 = _step2.value;
+        result[index++] = block2[i1];
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  }
+  return result;
+}
+function setModule(state, row, col, dark) {
+  var index = row * state.size + col;
+  state.modules[index] = dark;
+  state.reserved[index] = 1;
+}
+function placeFunctionPatterns(state, version) {
+  var {
+    size
+  } = state;
+  var corners = [[0, 0], [0, size - 7], [size - 7, 0]];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = corners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [top, left] = _step.value;
+      for (var r = -1; r <= 7; r++) {
+        for (var c = -1; c <= 7; c++) {
+          var row = top + r;
+          var col = left + c;
+          if (row < 0 || row >= size || col < 0 || col >= size) continue;
+          var inRing = r >= 0 && r <= 6 && c >= 0 && c <= 6;
+          var dark = inRing && (r === 0 || r === 6 || c === 0 || c === 6 || r >= 2 && r <= 4 && c >= 2 && c <= 4);
+          setModule(state, row, col, dark ? 1 : 0);
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  for (var i = 8; i < size - 8; i++) {
+    var dark1 = i % 2 === 0 ? 1 : 0;
+    setModule(state, 6, i, dark1);
+    setModule(state, i, 6, dark1);
+  }
+  var centers = ALIGNMENT_CENTERS[version - 1];
+  var last = centers[centers.length - 1];
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = centers[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var centerRow = _step1.value;
+      var _iteratorNormalCompletion2 = true,
+        _didIteratorError2 = false,
+        _iteratorError2 = void 0;
+      try {
+        for (var _iterator2 = centers[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var centerCol = _step2.value;
+          var overlapsFinder = centerRow === 6 && centerCol === 6 || centerRow === 6 && centerCol === last || centerRow === last && centerCol === 6;
+          if (overlapsFinder) continue;
+          for (var r1 = -2; r1 <= 2; r1++) {
+            for (var c1 = -2; c1 <= 2; c1++) {
+              var dark2 = Math.max(Math.abs(r1), Math.abs(c1)) !== 1;
+              setModule(state, centerRow + r1, centerCol + c1, dark2 ? 1 : 0);
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  setModule(state, size - 8, 8, 1);
+  for (var i1 = 0; i1 <= 8; i1++) {
+    if (i1 !== 6) {
+      state.reserved[8 * size + i1] = 1;
+      state.reserved[i1 * size + 8] = 1;
+    }
+    if (i1 < 8) {
+      state.reserved[8 * size + (size - 1 - i1)] = 1;
+      if (i1 < 7) state.reserved[(size - 1 - i1) * size + 8] = 1;
+    }
+  }
+  if (version >= 7) {
+    var info = versionInformation(version);
+    for (var i2 = 0; i2 < 18; i2++) {
+      var dark3 = info >> i2 & 1;
+      var row1 = size - 11 + i2 % 3;
+      var col1 = Math.floor(i2 / 3);
+      setModule(state, row1, col1, dark3);
+      setModule(state, col1, row1, dark3);
+    }
+  }
+}
+function placeData(state, codewords) {
+  var {
+    size
+  } = state;
+  var totalBits = codewords.length * 8;
+  var bitIndex = 0;
+  var upward = true;
+  for (var right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (var i = 0; i < size; i++) {
+      var row = upward ? size - 1 - i : i;
+      for (var _i = 0, _iter = [right, right - 1]; _i < _iter.length; _i++) {
+        var col = _iter[_i];
+        var index = row * size + col;
+        if (state.reserved[index]) continue;
+        state.modules[index] = bitIndex < totalBits ? codewords[bitIndex >> 3] >> 7 - (bitIndex & 7) & 1 : 0;
+        bitIndex++;
+      }
+    }
+    upward = !upward;
+  }
+}
+function maskBit(mask, row, col) {
+  switch (mask) {
+    case 0:
+      return (row + col) % 2 === 0;
+    case 1:
+      return row % 2 === 0;
+    case 2:
+      return col % 3 === 0;
+    case 3:
+      return (row + col) % 3 === 0;
+    case 4:
+      return (Math.floor(row / 2) + Math.floor(col / 3)) % 2 === 0;
+    case 5:
+      return row * col % 2 + row * col % 3 === 0;
+    case 6:
+      return (row * col % 2 + row * col % 3) % 2 === 0;
+    default:
+      return ((row + col) % 2 + row * col % 3) % 2 === 0;
+  }
+}
+function placeFormatInformation(modules, size, ecLevel, mask) {
+  var info = formatInformation(ecLevel, mask);
+  var bit = function bit2(i4) {
+    return info >> i4 & 1;
+  };
+  for (var i = 0; i <= 5; i++) modules[8 * size + i] = bit(14 - i);
+  modules[8 * size + 7] = bit(8);
+  modules[8 * size + 8] = bit(7);
+  modules[7 * size + 8] = bit(6);
+  for (var i1 = 0; i1 <= 5; i1++) modules[i1 * size + 8] = bit(i1);
+  for (var i2 = 0; i2 < 7; i2++) modules[(size - 1 - i2) * size + 8] = bit(14 - i2);
+  for (var i3 = 0; i3 < 8; i3++) modules[8 * size + (size - 1 - i3)] = bit(i3);
+}
+function penaltyScore(modules, size) {
+  var score = 0;
+  for (var axis = 0; axis < 2; axis++) {
+    for (var a = 0; a < size; a++) {
+      var runColor = -1;
+      var runLength = 0;
+      for (var b = 0; b < size; b++) {
+        var dark = axis === 0 ? modules[a * size + b] : modules[b * size + a];
+        if (dark === runColor) {
+          runLength++;
+          if (runLength === 5) score += 3;else if (runLength > 5) score += 1;
+        } else {
+          runColor = dark;
+          runLength = 1;
+        }
+      }
+    }
+  }
+  for (var row = 0; row < size - 1; row++) {
+    for (var col = 0; col < size - 1; col++) {
+      var dark1 = modules[row * size + col];
+      if (dark1 === modules[row * size + col + 1] && dark1 === modules[(row + 1) * size + col] && dark1 === modules[(row + 1) * size + col + 1]) {
+        score += 3;
+      }
+    }
+  }
+  var window = 11;
+  var isFinderLike = function isFinderLike2(bits2) {
+    var core = [1, 0, 1, 1, 1, 0, 1];
+    var matchesAt = function matchesAt2(offset) {
+      return core.every(function (v, i) {
+        return bits2[offset + i] === v;
+      });
+    };
+    var lightRun = function lightRun2(from, to) {
+      for (var i = from; i < to; i++) if (bits2[i] !== 0) return false;
+      return true;
+    };
+    return matchesAt(0) && lightRun(7, 11) || matchesAt(4) && lightRun(0, 4);
+  };
+  for (var axis1 = 0; axis1 < 2; axis1++) {
+    for (var a1 = 0; a1 < size; a1++) {
+      for (var start = 0; start + window <= size; start++) {
+        var bits = [];
+        for (var b1 = start; b1 < start + window; b1++) {
+          bits.push(axis1 === 0 ? modules[a1 * size + b1] : modules[b1 * size + a1]);
+        }
+        if (isFinderLike(bits)) score += 40;
+      }
+    }
+  }
+  var darkCount = 0;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = modules[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var module = _step.value;
+      darkCount += module;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var percent = darkCount * 100 / (size * size);
+  score += Math.floor(Math.abs(percent - 50) / 5) * 10;
+  return score;
+}
+function encodeQr(value, options) {
+  var _ref;
+  var ecLevel = (_ref = options === null || options === void 0 ? void 0 : options.ecLevel) !== null && _ref !== void 0 ? _ref : "M";
+  if (!value) return null;
+  var bytes = utf8Bytes(value);
+  var version = pickVersion(bytes.length, ecLevel);
+  if (version === null) return null;
+  var codewords = interleaveCodewords(buildDataCodewords(bytes, version, ecLevel), version, ecLevel);
+  var size = 17 + 4 * version;
+  var base = {
+    size,
+    modules: new Uint8Array(size * size),
+    reserved: new Uint8Array(size * size)
+  };
+  placeFunctionPatterns(base, version);
+  placeData(base, codewords);
+  var candidateMasks = (options === null || options === void 0 ? void 0 : options.mask) !== void 0 && options.mask >= 0 && options.mask <= 7 ? [options.mask] : [0, 1, 2, 3, 4, 5, 6, 7];
+  var best = null;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = candidateMasks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var mask = _step.value;
+      var masked = new Uint8Array(base.modules);
+      for (var row = 0; row < size; row++) {
+        for (var col = 0; col < size; col++) {
+          var index = row * size + col;
+          if (!base.reserved[index] && maskBit(mask, row, col)) masked[index] ^= 1;
+        }
+      }
+      placeFormatInformation(masked, size, ecLevel, mask);
+      var score = penaltyScore(masked, size);
+      if (!best || score < best.score) best = {
+        mask,
+        modules: masked,
+        score
+      };
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var chosen = best;
+  return {
+    size,
+    version,
+    ecLevel,
+    mask: chosen.mask,
+    modules: chosen.modules
+  };
+}
+function qrRowRuns(matrix) {
+  var rows = [];
+  for (var row = 0; row < matrix.size; row++) {
+    var runs = [];
+    for (var col = 0; col < matrix.size; col++) {
+      var dark = matrix.modules[row * matrix.size + col] === 1;
+      var lastRun = runs[runs.length - 1];
+      if (lastRun && lastRun.dark === dark) lastRun.modules += 1;else runs.push({
+        dark,
+        modules: 1
+      });
+    }
+    rows.push(runs);
+  }
+  return rows;
+}
+export { QR_QUIET_ZONE_MODULES, encodeQr, qrRowRuns };
+//# sourceMappingURL=qr.native.js.map