const t = new Uint8Array(512);

const n = new Uint8Array(256);

for (let e = 0, o = 1; e < 255; e++) {
  t[e] = o;
  n[o] = e;
  o <<= 1;
  if (256 & o) {
    o ^= 285;
  }
}

for (let n = 255; n < 512; n++) {
  t[n] = t[n - 255];
}

const gmul = (e, o) => e > 0 && o > 0 ? t[n[e] + n[o]] : 0;

const gpow = (e, o) => t[o * n[e] % 255];

const genRS = t => {
  const n = new Uint8Array(t + 2);
  const e = new Uint8Array(t + 1);
  e[0] = 1;
  for (let o = 0; o < t; o++) {
    const t = gpow(2, o);
    n.fill(0, 0, o + 2);
    for (let s = 0; s < o + 1; s++) {
      n[s] ^= e[s];
      n[s + 1] ^= gmul(e[s], t);
    }
    for (let t = 0; t < o + 2; t++) {
      e[t] = n[t];
    }
  }
  return e;
};

const encodeRS = (t, n) => {
  const e = genRS(n);
  const o = new Uint8Array(t.byteLength + e.byteLength - 1);
  o.set(t);
  for (let n = 0; n < t.byteLength; n++) {
    const t = o[n];
    if (t) {
      for (let s = 1; s < e.byteLength; s++) {
        o[n + s] ^= gmul(e[s], t);
      }
    }
  }
  return o.subarray(t.byteLength);
};

const e = [ 0, 26, 44, 70, 100, 134, 172, 196, 242, 292, 346, 404, 466, 532, 581, 655, 733, 815, 901, 991, 1085, 1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185, 2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706 ];

const o = [ [ 0, 0, 0, 0 ], [ 10, 7, 17, 13 ], [ 16, 10, 28, 22 ], [ 26, 15, 44, 36 ], [ 36, 20, 64, 52 ], [ 48, 26, 88, 72 ], [ 64, 36, 112, 96 ], [ 72, 40, 130, 108 ], [ 88, 48, 156, 132 ], [ 110, 60, 192, 160 ], [ 130, 72, 224, 192 ], [ 150, 80, 264, 224 ], [ 176, 96, 308, 260 ], [ 198, 104, 352, 288 ], [ 216, 120, 384, 320 ], [ 240, 132, 432, 360 ], [ 280, 144, 480, 408 ], [ 308, 168, 532, 448 ], [ 338, 180, 588, 504 ], [ 364, 196, 650, 546 ], [ 416, 224, 700, 600 ], [ 442, 224, 750, 644 ], [ 476, 252, 816, 690 ], [ 504, 270, 900, 750 ], [ 560, 300, 960, 810 ], [ 588, 312, 1050, 870 ], [ 644, 336, 1110, 952 ], [ 700, 360, 1200, 1020 ], [ 728, 390, 1260, 1050 ], [ 784, 420, 1350, 1140 ], [ 812, 450, 1440, 1200 ], [ 868, 480, 1530, 1290 ], [ 924, 510, 1620, 1350 ], [ 980, 540, 1710, 1440 ], [ 1036, 570, 1800, 1530 ], [ 1064, 570, 1890, 1590 ], [ 1120, 600, 1980, 1680 ], [ 1204, 630, 2100, 1770 ], [ 1260, 660, 2220, 1860 ], [ 1316, 720, 2310, 1950 ], [ 1372, 750, 2430, 2040 ] ];

const s = [ [ 0, 0, 0, 0 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 2, 2 ], [ 2, 1, 4, 2 ], [ 2, 1, 4, 4 ], [ 4, 2, 4, 4 ], [ 4, 2, 5, 6 ], [ 4, 2, 6, 6 ], [ 5, 2, 8, 8 ], [ 5, 4, 8, 8 ], [ 5, 4, 11, 8 ], [ 8, 4, 11, 10 ], [ 9, 4, 16, 12 ], [ 9, 4, 16, 16 ], [ 10, 6, 18, 12 ], [ 10, 6, 16, 17 ], [ 11, 6, 19, 16 ], [ 13, 6, 21, 18 ], [ 14, 7, 25, 21 ], [ 16, 8, 25, 20 ], [ 17, 8, 25, 23 ], [ 17, 9, 34, 23 ], [ 18, 9, 30, 25 ], [ 20, 10, 32, 27 ], [ 21, 12, 35, 29 ], [ 23, 12, 37, 34 ], [ 25, 12, 40, 34 ], [ 26, 13, 42, 35 ], [ 28, 14, 45, 38 ], [ 29, 15, 48, 40 ], [ 31, 16, 51, 43 ], [ 33, 17, 54, 45 ], [ 35, 18, 57, 48 ], [ 37, 19, 60, 51 ], [ 38, 19, 63, 53 ], [ 40, 20, 66, 56 ], [ 43, 21, 70, 59 ], [ 45, 22, 74, 62 ], [ 47, 24, 77, 65 ], [ 49, 25, 81, 68 ] ];

const r = [ 0, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177 ];

const c = [ [], [], [ 4, 16 ], [ 4, 20 ], [ 4, 24 ], [ 4, 28 ], [ 4, 32 ], [ 4, 20, 36 ], [ 4, 22, 40 ], [ 4, 24, 44 ], [ 4, 26, 48 ], [ 4, 28, 52 ], [ 4, 30, 56 ], [ 4, 32, 60 ], [ 4, 24, 44, 64 ], [ 4, 24, 46, 68 ], [ 4, 24, 48, 72 ], [ 4, 28, 52, 76 ], [ 4, 28, 54, 80 ], [ 4, 28, 56, 84 ], [ 4, 32, 60, 88 ], [ 4, 26, 48, 70, 92 ], [ 4, 24, 48, 72, 96 ], [ 4, 28, 52, 76, 100 ], [ 4, 26, 52, 78, 104 ], [ 4, 30, 56, 82, 108 ], [ 4, 28, 56, 84, 112 ], [ 4, 32, 60, 88, 116 ], [ 4, 24, 48, 72, 96, 120 ], [ 4, 28, 52, 76, 100, 124 ], [ 4, 24, 50, 76, 102, 128 ], [ 4, 28, 54, 80, 106, 132 ], [ 4, 32, 58, 84, 110, 136 ], [ 4, 28, 56, 84, 112, 140 ], [ 4, 32, 60, 88, 116, 144 ], [ 4, 28, 52, 76, 100, 124, 148 ], [ 4, 22, 48, 74, 100, 126, 152 ], [ 4, 26, 52, 78, 104, 130, 156 ], [ 4, 30, 56, 82, 108, 134, 160 ], [ 4, 24, 52, 80, 108, 136, 164 ], [ 4, 28, 56, 84, 112, 140, 168 ] ];

const makeSegments = (t, n, s) => {
  const r = e[n] - o[n][s];
  const c = new Uint8Array(r);
  let f = 0;
  let l = 0;
  if (n > 9) {
    const n = 65535 & t.byteLength;
    c[0] = 64 | n >>> 12 & 15;
    c[1] = n >>> 4 & 255;
    f = (15 & n) << 4;
    l = 2;
  } else {
    const n = 255 & t.byteLength;
    c[0] = 64 | n >>> 4 & 15;
    f = (15 & n) << 4;
    l = 1;
  }
  let i = 0;
  while (i + 1 < t.byteLength) {
    const n = t[i++] << 8 | t[i++];
    c[l++] = f | n >>> 12;
    c[l++] = n >>> 4 & 255;
    f = n << 4 & 240;
  }
  if (i < t.byteLength) {
    c[l++] = f | t[i] >>> 4;
    f = t[i] << 4 & 240;
  }
  c[l++] = f;
  for (let t = 0; l < r; t++) {
    c[l++] = 1 & t ? 17 : 236;
  }
  return c;
};

const getBestVersion = (t, n) => {
  for (let s = 1; s <= 40; s++) {
    let r = e[s] - o[s][n];
    r -= s > 9 ? 3 : 2;
    if (r >= t.byteLength) {
      return s;
    }
  }
  throw new RangeError("Bytes exceed max length");
};

const encodeData = (t, n, e) => {
  const r = t.byteLength + o[n][e];
  const c = s[n][e];
  const f = c - r % c;
  const l = t.byteLength / c | 0;
  const i = (r / c | 0) - l;
  const y = t.byteLength;
  const h = new Uint8Array(r);
  for (let n = 0, e = 0; n < c; n++) {
    const o = n < f ? l : l + 1;
    const s = encodeRS(t.subarray(e, e + o), i);
    for (let s = 0; s < o; s++) {
      h[s < l ? s * c + n : l * c + (n - f)] = t[e + s];
    }
    for (let t = 0; t < i; t++) {
      h[y + t * c + n] = s[t];
    }
    e += o;
  }
  return h;
};

const setSquare = (t, n, e, o, s) => {
  const r = (e + s) * n;
  for (let c = e * n; c < r; c += n) {
    t.fill(1, c + o, c + o + s);
  }
};

const setPattern = (t, n, e, o, s) => {
  const r = e * n + o;
  for (let e = 0; e < s; e++) {
    for (let o = 0; o < s; o++) {
      const c = o < s - 1 - o ? o : s - 1 - o;
      const f = e < s - 1 - e ? e : s - 1 - e;
      t[r + e * n + o] = 1 !== (c < f ? c : f) ? 1 : 0;
    }
  }
};

const writeFinderPatterns = (t, n, e) => {
  const o = e - 7;
  setPattern(t, e, 0, 0, 7);
  setPattern(t, e, o, 0, 7);
  setPattern(t, e, 0, o, 7);
  setSquare(n, e, 0, 0, 8);
  setSquare(n, e, o - 1, 0, 8);
  setSquare(n, e, 0, o - 1, 8);
};

const writeAlignmentPatterns = (t, n, e, o) => {
  const s = c[o];
  for (let o = 0; o < s.length; o++) {
    const r = s[o];
    for (let c = 0; c < s.length; c++) {
      if ((o || c % (s.length - 1)) && (c || o % (s.length - 1))) {
        const o = s[c];
        setPattern(t, e, r, o, 5);
        setSquare(n, e, r, o, 5);
      }
    }
  }
};

const writeTimingPatterns = (t, n, e) => {
  const o = e - 7;
  for (let s = 8; s < o; s++) {
    const o = s * e + 6;
    if (!n[o]) {
      n[o] = 1;
      t[o] = (s + 1) % 2;
    }
    const r = 6 * e + s;
    if (!n[r]) {
      n[r] = 1;
      t[r] = (s + 1) % 2;
    }
  }
};

const reserveFormatInfo = (t, n) => {
  const e = n - 7 - 1;
  t[8 * n + 8] = 1;
  for (let o = 0; o < 8; o++) {
    t[o * n + 8] = 1;
    t[8 * n + o] = 1;
    t[(e + o) * n + 8] = 1;
    t[8 * n + e + o] = 1;
  }
};

const reserveVersionInfo = (t, n, e) => {
  if (e >= 7) {
    const e = n - 7 - 4;
    for (let o = 0; o < 6; o++) {
      for (let s = 0; s < 3; s++) {
        t[(e + s) * n + o] = 1;
        t[o * n + e + s] = 1;
      }
    }
  }
};

const writeData = (t, n, e, o) => {
  let s = 0;
  let r = e - 1;
  let c = -1;
  let f = 7;
  while (s < o.byteLength) {
    if (6 === r) {
      r--;
    }
    for (let l = 0; l < e; l++) {
      for (let i = 0; i < 2; i++) {
        const y = r - i;
        const h = -1 === c ? e - l - 1 : l;
        if (n[h * e + y]) {
          continue;
        }
        t[h * e + y] = o[s] >>> f & 1;
        if (0 === f--) {
          f = 7;
          if (++s >= o.byteLength) {
            return;
          }
        }
      }
    }
    c = -c;
    r -= 2;
  }
};

const xorPatternN0 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let r = 0; r < e; r++) {
      const e = s + r;
      if (!(n[e] || o + r & 1)) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN1 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let r = 0; r < e; r++) {
      const e = s + r;
      if (!(n[e] || 1 & o)) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN2 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let o = 0; o < e; o++) {
      const e = s + o;
      if (!n[e] && o % 3 == 0) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN3 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let r = 0; r < e; r++) {
      const e = s + r;
      if (!n[e] && (o + r) % 3 == 0) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN4 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    const r = o / 2 | 0;
    for (let o = 0; o < e; o++) {
      const e = s + o;
      if (!(n[e] || r + (o / 3 | 0) & 1)) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN5 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let r = 0; r < e; r++) {
      const e = s + r;
      const c = o * r;
      if (!n[e] && (1 & c) + c % 3 == 0) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN6 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let r = 0; r < e; r++) {
      const e = s + r;
      const c = o * r;
      if (!n[e] && ((1 & c) + c % 3) % 2 == 0) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPatternN7 = (t, n, e) => {
  for (let o = 0, s = 0; o < e; o++, s += e) {
    for (let r = 0; r < e; r++) {
      const e = s + r;
      if (!(n[e] || o * r % 3 + (o + r & 1) & 1)) {
        t[e] ^= 1;
      }
    }
  }
};

const xorPattern = (t, n, e, o) => {
  switch (o) {
   case 0:
    return xorPatternN0(t, n, e);

   case 1:
    return xorPatternN1(t, n, e);

   case 2:
    return xorPatternN2(t, n, e);

   case 3:
    return xorPatternN3(t, n, e);

   case 4:
    return xorPatternN4(t, n, e);

   case 5:
    return xorPatternN5(t, n, e);

   case 6:
    return xorPatternN6(t, n, e);

   case 7:
    return xorPatternN7(t, n, e);
  }
};

const computePenalty = (t, n) => {
  let e = 0;
  let o = 0;
  for (let s = 0; s < n; s++) {
    let r = 1;
    let c = 1;
    let f = 0;
    let l = 0;
    for (let i = 0; i < n; i++) {
      const y = s * n + i;
      const h = i * n + s;
      o += t[y];
      if (i > 0) {
        if (t[y - 1] === t[y]) {
          r++;
        } else {
          if (r >= 5) {
            e += r - 5 + 3;
          }
          r = 1;
        }
        if (t[h - n] === t[h]) {
          c++;
        } else {
          if (c >= 5) {
            e += c - 5 + 3;
          }
          c = 1;
        }
      }
      if (s < n - 1 && i < n - 1 && t[y] === t[y + 1] && t[y] === t[y + n] && t[y] === t[y + n + 1]) {
        e += 3;
      }
      f = f << 1 & 2047 | t[y];
      l = l << 1 & 2047 | t[h];
      if (i >= 10) {
        if (1488 === f || 93 === f) {
          e += 40;
        }
        if (1488 === l || 93 === l) {
          e += 40;
        }
      }
    }
    if (r >= 5) {
      e += r - 5 + 3;
    }
    if (c >= 5) {
      e += c - 5 + 3;
    }
  }
  const s = 100 * Math.abs(o / t.byteLength - .5);
  e += 10 * Math.floor(s / 5);
  return e;
};

const applyBestPattern = (t, n, e) => {
  let o = 0;
  let s = 0;
  const r = new Uint8Array(t.byteLength);
  for (let c = 0; c <= 7; c += 1) {
    r.set(t);
    xorPattern(r, n, e, c);
    const f = computePenalty(r, e);
    if (0 === c || f < o) {
      o = f;
      s = c;
    }
  }
  xorPattern(t, n, e, s);
  return s;
};

const encodeFormatInfo = (t, n) => {
  const e = (t << 3 | n) << 10;
  let o = e;
  for (let t = 0; t < 5; t++) {
    if (o & 1 << 14 - t) {
      o ^= 1335 << 4 - t;
    }
  }
  return 21522 ^ (o | e);
};

const writeFormatInfo = (t, n, e, o) => {
  const s = encodeFormatInfo(e, o);
  let r = 14;
  for (let e = 0; e < 6; e++) {
    t[8 * n + e] = s >> r-- & 1;
  }
  t[8 * n + 7] = s >> r-- & 1;
  t[8 * n + 8] = s >> r-- & 1;
  t[7 * n + 8] = s >> r-- & 1;
  for (let e = 0; e < 6; e++) {
    t[(5 - e) * n + 8] = s >> r-- & 1;
  }
  r = 14;
  for (let e = 0; e < 7; e++) {
    t[(n - 1 - e) * n + 8] = s >> r-- & 1;
  }
  t[(n - 8) * n + 8] = 1;
  for (let e = 0; e < 8; e++) {
    t[8 * n + n - 8 + e] = s >> r-- & 1;
  }
};

const encodeVersionInfo = t => {
  const n = t << 12;
  let e = n;
  for (let t = 0; t < 6; t++) {
    if (e & 1 << 17 - t) {
      e ^= 7973 << 5 - t;
    }
  }
  return e | n;
};

const writeVersionInfo = (t, n, e) => {
  if (e >= 7) {
    const o = encodeVersionInfo(e);
    for (let e = 0; e < 6; e++) {
      for (let s = 0; s < 3; s++) {
        const r = o >>> 3 * e + s & 1;
        t[(n - 11 + s) * n + e] = r;
        t[e * n + n - 11 + s] = r;
      }
    }
  }
};

const encodeBytes = (t, n) => {
  const e = getBestVersion(t, n);
  const o = makeSegments(t, e, n);
  const s = encodeData(o, e, n);
  const c = r[e];
  const f = new Uint8Array(c * c);
  const l = new Uint8Array(c * c);
  writeFinderPatterns(f, l, c);
  writeAlignmentPatterns(f, l, c, e);
  writeTimingPatterns(f, l, c);
  reserveFormatInfo(l, c);
  reserveVersionInfo(l, c, e);
  writeData(f, l, c, s);
  const i = applyBestPattern(f, l, c);
  writeFormatInfo(f, c, n, i);
  writeVersionInfo(f, c, e);
  return f;
};

const f = new TextEncoder;

const toQR = (t, n = 1) => {
  const e = "string" == typeof t ? f.encode(t) : t;
  return encodeBytes(e, n);
};

export { toQR };
//# sourceMappingURL=toqr.mjs.map