@multiplatform.one/forms 7.4.1 → 7.6.0

package/dist/cjs/fields/Barcode/qr.cjs

@@ -0,0 +1,406 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var qr_exports = {};
+__export(qr_exports, {
+  QR_QUIET_ZONE_MODULES: () => QR_QUIET_ZONE_MODULES,
+  encodeQr: () => encodeQr,
+  qrRowRuns: () => qrRowRuns
+});
+module.exports = __toCommonJS(qr_exports);
+const QR_QUIET_ZONE_MODULES = 4;
+const MAX_VERSION = 10;
+const TOTAL_CODEWORDS = [26, 44, 70, 100, 134, 172, 196, 242, 292, 346];
+const 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]]]]
+};
+const ALIGNMENT_CENTERS = [[], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34], [6, 22, 38], [6, 24, 42], [6, 26, 46], [6, 28, 50]];
+const EC_INDICATOR = {
+  L: 1,
+  M: 0,
+  Q: 3,
+  H: 2
+};
+const GF_EXP = new Uint8Array(512);
+const GF_LOG = new Uint8Array(256);
+{
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    GF_EXP[i] = x;
+    GF_LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 512; i++) GF_EXP[i] = GF_EXP[i - 255];
+}
+function gfMultiply(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+}
+function rsGeneratorPoly(degree) {
+  let poly = new Uint8Array([1]);
+  for (let i = 0; i < degree; i++) {
+    const next = new Uint8Array(poly.length + 1);
+    for (let 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) {
+  const generator = rsGeneratorPoly(degree);
+  const remainder = new Uint8Array(degree);
+  for (const byte of data) {
+    const factor = byte ^ remainder[0];
+    remainder.copyWithin(0, 1);
+    remainder[degree - 1] = 0;
+    if (factor !== 0) {
+      for (let j = 0; j < degree; j++) remainder[j] ^= gfMultiply(generator[j + 1], factor);
+    }
+  }
+  return remainder;
+}
+function bitLength(value) {
+  let length = 0;
+  for (let v = value; v > 0; v >>>= 1) length++;
+  return length;
+}
+function bchRemainder(value, generator) {
+  const generatorLength = bitLength(generator);
+  let remainder = value;
+  while (bitLength(remainder) >= generatorLength) {
+    remainder ^= generator << bitLength(remainder) - generatorLength;
+  }
+  return remainder;
+}
+function formatInformation(ecLevel, mask) {
+  const 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) {
+  const bytes = [];
+  for (const char of value) {
+    const 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);
+    }
+  }
+  return bytes;
+}
+function dataCodewordCount(version, ecLevel) {
+  const [, groups] = EC_BLOCKS[ecLevel][version - 1];
+  return groups.reduce((sum, [blocks, perBlock]) => sum + blocks * perBlock, 0);
+}
+function charCountBits(version) {
+  return version <= 9 ? 8 : 16;
+}
+function pickVersion(byteCount, ecLevel) {
+  for (let version = 1; version <= MAX_VERSION; version++) {
+    const capacityBits = dataCodewordCount(version, ecLevel) * 8;
+    const neededBits = 4 + charCountBits(version) + byteCount * 8;
+    if (neededBits <= capacityBits) return version;
+  }
+  return null;
+}
+function buildDataCodewords(bytes, version, ecLevel) {
+  const bits = [];
+  const pushBits = (value, length) => {
+    for (let i = length - 1; i >= 0; i--) bits.push(value >> i & 1);
+  };
+  pushBits(4, 4);
+  pushBits(bytes.length, charCountBits(version));
+  for (const byte of bytes) pushBits(byte, 8);
+  const capacityBits = dataCodewordCount(version, ecLevel) * 8;
+  pushBits(0, Math.min(4, capacityBits - bits.length));
+  if (bits.length % 8 !== 0) pushBits(0, 8 - bits.length % 8);
+  const codewords = new Uint8Array(capacityBits / 8);
+  for (let i = 0; i < bits.length; i++) {
+    if (bits[i]) codewords[i >> 3] |= 128 >> (i & 7);
+  }
+  const padBytes = [236, 17];
+  for (let i = bits.length / 8; i < codewords.length; i++) {
+    codewords[i] = padBytes[(i - bits.length / 8) % 2];
+  }
+  return codewords;
+}
+function interleaveCodewords(data, version, ecLevel) {
+  const [ecPerBlock, groups] = EC_BLOCKS[ecLevel][version - 1];
+  const dataBlocks = [];
+  const ecBlocks = [];
+  let offset = 0;
+  for (const [blockCount, perBlock] of groups) {
+    for (let b = 0; b < blockCount; b++) {
+      const block = data.subarray(offset, offset + perBlock);
+      offset += perBlock;
+      dataBlocks.push(block);
+      ecBlocks.push(rsEncode(block, ecPerBlock));
+    }
+  }
+  const result = new Uint8Array(TOTAL_CODEWORDS[version - 1]);
+  let index = 0;
+  const maxDataLength = Math.max(...dataBlocks.map(block => block.length));
+  for (let i = 0; i < maxDataLength; i++) {
+    for (const block of dataBlocks) {
+      if (i < block.length) result[index++] = block[i];
+    }
+  }
+  for (let i = 0; i < ecPerBlock; i++) {
+    for (const block of ecBlocks) result[index++] = block[i];
+  }
+  return result;
+}
+function setModule(state, row, col, dark) {
+  const index = row * state.size + col;
+  state.modules[index] = dark;
+  state.reserved[index] = 1;
+}
+function placeFunctionPatterns(state, version) {
+  const {
+    size
+  } = state;
+  const corners = [[0, 0], [0, size - 7], [size - 7, 0]];
+  for (const [top, left] of corners) {
+    for (let r = -1; r <= 7; r++) {
+      for (let c = -1; c <= 7; c++) {
+        const row = top + r;
+        const col = left + c;
+        if (row < 0 || row >= size || col < 0 || col >= size) continue;
+        const inRing = r >= 0 && r <= 6 && c >= 0 && c <= 6;
+        const 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);
+      }
+    }
+  }
+  for (let i = 8; i < size - 8; i++) {
+    const dark = i % 2 === 0 ? 1 : 0;
+    setModule(state, 6, i, dark);
+    setModule(state, i, 6, dark);
+  }
+  const centers = ALIGNMENT_CENTERS[version - 1];
+  const last = centers[centers.length - 1];
+  for (const centerRow of centers) {
+    for (const centerCol of centers) {
+      const overlapsFinder = centerRow === 6 && centerCol === 6 || centerRow === 6 && centerCol === last || centerRow === last && centerCol === 6;
+      if (overlapsFinder) continue;
+      for (let r = -2; r <= 2; r++) {
+        for (let c = -2; c <= 2; c++) {
+          const dark = Math.max(Math.abs(r), Math.abs(c)) !== 1;
+          setModule(state, centerRow + r, centerCol + c, dark ? 1 : 0);
+        }
+      }
+    }
+  }
+  setModule(state, size - 8, 8, 1);
+  for (let i = 0; i <= 8; i++) {
+    if (i !== 6) {
+      state.reserved[8 * size + i] = 1;
+      state.reserved[i * size + 8] = 1;
+    }
+    if (i < 8) {
+      state.reserved[8 * size + (size - 1 - i)] = 1;
+      if (i < 7) state.reserved[(size - 1 - i) * size + 8] = 1;
+    }
+  }
+  if (version >= 7) {
+    const info = versionInformation(version);
+    for (let i = 0; i < 18; i++) {
+      const dark = info >> i & 1;
+      const row = size - 11 + i % 3;
+      const col = Math.floor(i / 3);
+      setModule(state, row, col, dark);
+      setModule(state, col, row, dark);
+    }
+  }
+}
+function placeData(state, codewords) {
+  const {
+    size
+  } = state;
+  const totalBits = codewords.length * 8;
+  let bitIndex = 0;
+  let upward = true;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (let i = 0; i < size; i++) {
+      const row = upward ? size - 1 - i : i;
+      for (const col of [right, right - 1]) {
+        const 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) {
+  const info = formatInformation(ecLevel, mask);
+  const bit = i => info >> i & 1;
+  for (let 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 (let i = 0; i <= 5; i++) modules[i * size + 8] = bit(i);
+  for (let i = 0; i < 7; i++) modules[(size - 1 - i) * size + 8] = bit(14 - i);
+  for (let i = 0; i < 8; i++) modules[8 * size + (size - 1 - i)] = bit(i);
+}
+function penaltyScore(modules, size) {
+  let score = 0;
+  for (let axis = 0; axis < 2; axis++) {
+    for (let a = 0; a < size; a++) {
+      let runColor = -1;
+      let runLength = 0;
+      for (let b = 0; b < size; b++) {
+        const 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 (let row = 0; row < size - 1; row++) {
+    for (let col = 0; col < size - 1; col++) {
+      const dark = modules[row * size + col];
+      if (dark === modules[row * size + col + 1] && dark === modules[(row + 1) * size + col] && dark === modules[(row + 1) * size + col + 1]) {
+        score += 3;
+      }
+    }
+  }
+  const window = 11;
+  const isFinderLike = bits => {
+    const core = [1, 0, 1, 1, 1, 0, 1];
+    const matchesAt = offset => core.every((v, i) => bits[offset + i] === v);
+    const lightRun = (from, to) => {
+      for (let i = from; i < to; i++) if (bits[i] !== 0) return false;
+      return true;
+    };
+    return matchesAt(0) && lightRun(7, 11) || matchesAt(4) && lightRun(0, 4);
+  };
+  for (let axis = 0; axis < 2; axis++) {
+    for (let a = 0; a < size; a++) {
+      for (let start = 0; start + window <= size; start++) {
+        const bits = [];
+        for (let b = start; b < start + window; b++) {
+          bits.push(axis === 0 ? modules[a * size + b] : modules[b * size + a]);
+        }
+        if (isFinderLike(bits)) score += 40;
+      }
+    }
+  }
+  let darkCount = 0;
+  for (const module2 of modules) darkCount += module2;
+  const percent = darkCount * 100 / (size * size);
+  score += Math.floor(Math.abs(percent - 50) / 5) * 10;
+  return score;
+}
+function encodeQr(value, options) {
+  const ecLevel = options?.ecLevel ?? "M";
+  if (!value) return null;
+  const bytes = utf8Bytes(value);
+  const version = pickVersion(bytes.length, ecLevel);
+  if (version === null) return null;
+  const codewords = interleaveCodewords(buildDataCodewords(bytes, version, ecLevel), version, ecLevel);
+  const size = 17 + 4 * version;
+  const base = {
+    size,
+    modules: new Uint8Array(size * size),
+    reserved: new Uint8Array(size * size)
+  };
+  placeFunctionPatterns(base, version);
+  placeData(base, codewords);
+  const candidateMasks = options?.mask !== void 0 && options.mask >= 0 && options.mask <= 7 ? [options.mask] : [0, 1, 2, 3, 4, 5, 6, 7];
+  let best = null;
+  for (const mask of candidateMasks) {
+    const masked = new Uint8Array(base.modules);
+    for (let row = 0; row < size; row++) {
+      for (let col = 0; col < size; col++) {
+        const index = row * size + col;
+        if (!base.reserved[index] && maskBit(mask, row, col)) masked[index] ^= 1;
+      }
+    }
+    placeFormatInformation(masked, size, ecLevel, mask);
+    const score = penaltyScore(masked, size);
+    if (!best || score < best.score) best = {
+      mask,
+      modules: masked,
+      score
+    };
+  }
+  const chosen = best;
+  return {
+    size,
+    version,
+    ecLevel,
+    mask: chosen.mask,
+    modules: chosen.modules
+  };
+}
+function qrRowRuns(matrix) {
+  const rows = [];
+  for (let row = 0; row < matrix.size; row++) {
+    const runs = [];
+    for (let col = 0; col < matrix.size; col++) {
+      const dark = matrix.modules[row * matrix.size + col] === 1;
+      const lastRun = runs[runs.length - 1];
+      if (lastRun && lastRun.dark === dark) lastRun.modules += 1;else runs.push({
+        dark,
+        modules: 1
+      });
+    }
+    rows.push(runs);
+  }
+  return rows;
+}