@cloudbase/weda-ui-mp 0.2.20

package/utils/qrcode/weapp.qrcode.min.js

@@ -0,0 +1,911 @@
+/**
+ * weapp.qrcode.js v1.0.0 (https://github.com/yingye/weapp-qrcode#readme)
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+!(function (t, e) {
+  'object' == typeof exports && 'undefined' != typeof module
+    ? (module.exports = e())
+    : // eslint-disable-next-line no-undef
+    'function' == typeof define && define.amd
+    ? // eslint-disable-next-line no-undef
+      define(e)
+    : (t.drawQrcode = e());
+})(this, function () {
+  'use strict';
+  var t = Object.prototype.hasOwnProperty,
+    e = Object.prototype.toString,
+    r = Object.defineProperty,
+    o = Object.getOwnPropertyDescriptor,
+    n = function (t) {
+      return 'function' == typeof Array.isArray
+        ? Array.isArray(t)
+        : '[object Array]' === e.call(t);
+    },
+    i = function (r) {
+      if (!r || '[object Object]' !== e.call(r)) return !1;
+      var o,
+        n = t.call(r, 'constructor'),
+        i =
+          r.constructor &&
+          r.constructor.prototype &&
+          t.call(r.constructor.prototype, 'isPrototypeOf');
+      if (r.constructor && !n && !i) return !1;
+      for (o in r);
+      return void 0 === o || t.call(r, o);
+    },
+    a = function (t, e) {
+      r && '__proto__' === e.name
+        ? r(t, e.name, {
+            enumerable: !0,
+            configurable: !0,
+            value: e.newValue,
+            writable: !0,
+          })
+        : (t[e.name] = e.newValue);
+    },
+    u = function (e, r) {
+      if ('__proto__' === r) {
+        if (!t.call(e, r)) return;
+        if (o) return o(e, r).value;
+      }
+      return e[r];
+    },
+    s = function t() {
+      var e,
+        r,
+        o,
+        s,
+        h,
+        l,
+        f = arguments[0],
+        g = 1,
+        c = arguments.length,
+        d = !1;
+      for (
+        'boolean' == typeof f && ((d = f), (f = arguments[1] || {}), (g = 2)),
+          (null == f || ('object' != typeof f && 'function' != typeof f)) &&
+            (f = {});
+        g < c;
+        ++g
+      )
+        if (null != (e = arguments[g]))
+          for (r in e)
+            (o = u(f, r)),
+              f !== (s = u(e, r)) &&
+                (d && s && (i(s) || (h = n(s)))
+                  ? (h
+                      ? ((h = !1), (l = o && n(o) ? o : []))
+                      : (l = o && i(o) ? o : {}),
+                    a(f, { name: r, newValue: t(d, l, s) }))
+                  : void 0 !== s && a(f, { name: r, newValue: s }));
+      return f;
+    };
+  function h(t) {
+    (this.mode = f.MODE_8BIT_BYTE), (this.data = t);
+  }
+  function l(t, e) {
+    (this.typeNumber = t),
+      (this.errorCorrectLevel = e),
+      (this.modules = null),
+      (this.moduleCount = 0),
+      (this.dataCache = null),
+      (this.dataList = []);
+  }
+  (h.prototype = {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getLength: function (t) {
+      return this.data.length;
+    },
+    write: function (t) {
+      for (var e = 0; e < this.data.length; e++)
+        t.put(this.data.charCodeAt(e), 8);
+    },
+  }),
+    (l.prototype = {
+      addData: function (t) {
+        var e = new h(t);
+        this.dataList.push(e), (this.dataCache = null);
+      },
+      isDark: function (t, e) {
+        if (t < 0 || this.moduleCount <= t || e < 0 || this.moduleCount <= e)
+          throw new Error(t + ',' + e);
+        return this.modules[t][e];
+      },
+      getModuleCount: function () {
+        return this.moduleCount;
+      },
+      make: function () {
+        if (this.typeNumber < 1) {
+          var t = 1;
+          for (t = 1; t < 40; t++) {
+            for (
+              var e = _.getRSBlocks(t, this.errorCorrectLevel),
+                r = new D(),
+                o = 0,
+                n = 0;
+              n < e.length;
+              n++
+            )
+              o += e[n].dataCount;
+            for (n = 0; n < this.dataList.length; n++) {
+              var i = this.dataList[n];
+              r.put(i.mode, 4),
+                r.put(i.getLength(), w.getLengthInBits(i.mode, t)),
+                i.write(r);
+            }
+            if (r.getLengthInBits() <= 8 * o) break;
+          }
+          this.typeNumber = t;
+        }
+        this.makeImpl(!1, this.getBestMaskPattern());
+      },
+      makeImpl: function (t, e) {
+        (this.moduleCount = 4 * this.typeNumber + 17),
+          (this.modules = new Array(this.moduleCount));
+        for (var r = 0; r < this.moduleCount; r++) {
+          this.modules[r] = new Array(this.moduleCount);
+          for (var o = 0; o < this.moduleCount; o++) this.modules[r][o] = null;
+        }
+        this.setupPositionProbePattern(0, 0),
+          this.setupPositionProbePattern(this.moduleCount - 7, 0),
+          this.setupPositionProbePattern(0, this.moduleCount - 7),
+          this.setupPositionAdjustPattern(),
+          this.setupTimingPattern(),
+          this.setupTypeInfo(t, e),
+          this.typeNumber >= 7 && this.setupTypeNumber(t),
+          null == this.dataCache &&
+            (this.dataCache = l.createData(
+              this.typeNumber,
+              this.errorCorrectLevel,
+              this.dataList
+            )),
+          this.mapData(this.dataCache, e);
+      },
+      setupPositionProbePattern: function (t, e) {
+        for (var r = -1; r <= 7; r++)
+          if (!(t + r <= -1 || this.moduleCount <= t + r))
+            for (var o = -1; o <= 7; o++)
+              e + o <= -1 ||
+                this.moduleCount <= e + o ||
+                (this.modules[t + r][e + o] =
+                  (0 <= r && r <= 6 && (0 == o || 6 == o)) ||
+                  (0 <= o && o <= 6 && (0 == r || 6 == r)) ||
+                  (2 <= r && r <= 4 && 2 <= o && o <= 4));
+      },
+      getBestMaskPattern: function () {
+        for (var t = 0, e = 0, r = 0; r < 8; r++) {
+          this.makeImpl(!0, r);
+          var o = w.getLostPoint(this);
+          (0 == r || t > o) && ((t = o), (e = r));
+        }
+        return e;
+      },
+      createMovieClip: function (t, e, r) {
+        var o = t.createEmptyMovieClip(e, r);
+        this.make();
+        for (var n = 0; n < this.modules.length; n++)
+          for (var i = 1 * n, a = 0; a < this.modules[n].length; a++) {
+            var u = 1 * a;
+            this.modules[n][a] &&
+              (o.beginFill(0, 100),
+              o.moveTo(u, i),
+              o.lineTo(u + 1, i),
+              o.lineTo(u + 1, i + 1),
+              o.lineTo(u, i + 1),
+              o.endFill());
+          }
+        return o;
+      },
+      setupTimingPattern: function () {
+        for (var t = 8; t < this.moduleCount - 8; t++)
+          null == this.modules[t][6] && (this.modules[t][6] = t % 2 == 0);
+        for (var e = 8; e < this.moduleCount - 8; e++)
+          null == this.modules[6][e] && (this.modules[6][e] = e % 2 == 0);
+      },
+      setupPositionAdjustPattern: function () {
+        for (
+          var t = w.getPatternPosition(this.typeNumber), e = 0;
+          e < t.length;
+          e++
+        )
+          for (var r = 0; r < t.length; r++) {
+            var o = t[e],
+              n = t[r];
+            if (null == this.modules[o][n])
+              for (var i = -2; i <= 2; i++)
+                for (var a = -2; a <= 2; a++)
+                  this.modules[o + i][n + a] =
+                    -2 == i ||
+                    2 == i ||
+                    -2 == a ||
+                    2 == a ||
+                    (0 == i && 0 == a);
+          }
+      },
+      setupTypeNumber: function (t) {
+        for (var e = w.getBCHTypeNumber(this.typeNumber), r = 0; r < 18; r++) {
+          var o = !t && 1 == ((e >> r) & 1);
+          this.modules[Math.floor(r / 3)][(r % 3) + this.moduleCount - 8 - 3] =
+            o;
+        }
+        for (r = 0; r < 18; r++) {
+          o = !t && 1 == ((e >> r) & 1);
+          this.modules[(r % 3) + this.moduleCount - 8 - 3][Math.floor(r / 3)] =
+            o;
+        }
+      },
+      setupTypeInfo: function (t, e) {
+        for (
+          var r = (this.errorCorrectLevel << 3) | e,
+            o = w.getBCHTypeInfo(r),
+            n = 0;
+          n < 15;
+          n++
+        ) {
+          var i = !t && 1 == ((o >> n) & 1);
+          n < 6
+            ? (this.modules[n][8] = i)
+            : n < 8
+            ? (this.modules[n + 1][8] = i)
+            : (this.modules[this.moduleCount - 15 + n][8] = i);
+        }
+        for (n = 0; n < 15; n++) {
+          i = !t && 1 == ((o >> n) & 1);
+          n < 8
+            ? (this.modules[8][this.moduleCount - n - 1] = i)
+            : n < 9
+            ? (this.modules[8][15 - n - 1 + 1] = i)
+            : (this.modules[8][15 - n - 1] = i);
+        }
+        this.modules[this.moduleCount - 8][8] = !t;
+      },
+      mapData: function (t, e) {
+        for (
+          var r = -1,
+            o = this.moduleCount - 1,
+            n = 7,
+            i = 0,
+            a = this.moduleCount - 1;
+          a > 0;
+          a -= 2
+        )
+          for (6 == a && a--; ; ) {
+            for (var u = 0; u < 2; u++)
+              if (null == this.modules[o][a - u]) {
+                var s = !1;
+                i < t.length && (s = 1 == ((t[i] >>> n) & 1)),
+                  w.getMask(e, o, a - u) && (s = !s),
+                  (this.modules[o][a - u] = s),
+                  -1 == --n && (i++, (n = 7));
+              }
+            if ((o += r) < 0 || this.moduleCount <= o) {
+              (o -= r), (r = -r);
+              break;
+            }
+          }
+      },
+    }),
+    (l.PAD0 = 236),
+    (l.PAD1 = 17),
+    (l.createData = function (t, e, r) {
+      for (var o = _.getRSBlocks(t, e), n = new D(), i = 0; i < r.length; i++) {
+        var a = r[i];
+        n.put(a.mode, 4),
+          n.put(a.getLength(), w.getLengthInBits(a.mode, t)),
+          a.write(n);
+      }
+      var u = 0;
+      for (i = 0; i < o.length; i++) u += o[i].dataCount;
+      if (n.getLengthInBits() > 8 * u)
+        throw new Error(
+          'code length overflow. (' + n.getLengthInBits() + '>' + 8 * u + ')'
+        );
+      for (
+        n.getLengthInBits() + 4 <= 8 * u && n.put(0, 4);
+        n.getLengthInBits() % 8 != 0;
+
+      )
+        n.putBit(!1);
+      for (
+        ;
+        !(
+          n.getLengthInBits() >= 8 * u ||
+          (n.put(l.PAD0, 8), n.getLengthInBits() >= 8 * u)
+        );
+
+      )
+        n.put(l.PAD1, 8);
+      return l.createBytes(n, o);
+    }),
+    (l.createBytes = function (t, e) {
+      for (
+        var r = 0,
+          o = 0,
+          n = 0,
+          i = new Array(e.length),
+          a = new Array(e.length),
+          u = 0;
+        u < e.length;
+        u++
+      ) {
+        var s = e[u].dataCount,
+          h = e[u].totalCount - s;
+        (o = Math.max(o, s)), (n = Math.max(n, h)), (i[u] = new Array(s));
+        for (var l = 0; l < i[u].length; l++) i[u][l] = 255 & t.buffer[l + r];
+        r += s;
+        var f = w.getErrorCorrectPolynomial(h),
+          g = new A(i[u], f.getLength() - 1).mod(f);
+        a[u] = new Array(f.getLength() - 1);
+        for (l = 0; l < a[u].length; l++) {
+          var c = l + g.getLength() - a[u].length;
+          a[u][l] = c >= 0 ? g.get(c) : 0;
+        }
+      }
+      var d = 0;
+      for (l = 0; l < e.length; l++) d += e[l].totalCount;
+      var m = new Array(d),
+        v = 0;
+      for (l = 0; l < o; l++)
+        for (u = 0; u < e.length; u++) l < i[u].length && (m[v++] = i[u][l]);
+      for (l = 0; l < n; l++)
+        for (u = 0; u < e.length; u++) l < a[u].length && (m[v++] = a[u][l]);
+      return m;
+    });
+  for (
+    var f = {
+        MODE_NUMBER: 1,
+        MODE_ALPHA_NUM: 2,
+        MODE_8BIT_BYTE: 4,
+        MODE_KANJI: 8,
+      },
+      g = { L: 1, M: 0, Q: 3, H: 2 },
+      c = 0,
+      d = 1,
+      m = 2,
+      v = 3,
+      p = 4,
+      C = 5,
+      B = 6,
+      L = 7,
+      w = {
+        PATTERN_POSITION_TABLE: [
+          [],
+          [6, 18],
+          [6, 22],
+          [6, 26],
+          [6, 30],
+          [6, 34],
+          [6, 22, 38],
+          [6, 24, 42],
+          [6, 26, 46],
+          [6, 28, 50],
+          [6, 30, 54],
+          [6, 32, 58],
+          [6, 34, 62],
+          [6, 26, 46, 66],
+          [6, 26, 48, 70],
+          [6, 26, 50, 74],
+          [6, 30, 54, 78],
+          [6, 30, 56, 82],
+          [6, 30, 58, 86],
+          [6, 34, 62, 90],
+          [6, 28, 50, 72, 94],
+          [6, 26, 50, 74, 98],
+          [6, 30, 54, 78, 102],
+          [6, 28, 54, 80, 106],
+          [6, 32, 58, 84, 110],
+          [6, 30, 58, 86, 114],
+          [6, 34, 62, 90, 118],
+          [6, 26, 50, 74, 98, 122],
+          [6, 30, 54, 78, 102, 126],
+          [6, 26, 52, 78, 104, 130],
+          [6, 30, 56, 82, 108, 134],
+          [6, 34, 60, 86, 112, 138],
+          [6, 30, 58, 86, 114, 142],
+          [6, 34, 62, 90, 118, 146],
+          [6, 30, 54, 78, 102, 126, 150],
+          [6, 24, 50, 76, 102, 128, 154],
+          [6, 28, 54, 80, 106, 132, 158],
+          [6, 32, 58, 84, 110, 136, 162],
+          [6, 26, 54, 82, 110, 138, 166],
+          [6, 30, 58, 86, 114, 142, 170],
+        ],
+        G15: 1335,
+        G18: 7973,
+        G15_MASK: 21522,
+        getBCHTypeInfo: function (t) {
+          for (var e = t << 10; w.getBCHDigit(e) - w.getBCHDigit(w.G15) >= 0; )
+            e ^= w.G15 << (w.getBCHDigit(e) - w.getBCHDigit(w.G15));
+          return ((t << 10) | e) ^ w.G15_MASK;
+        },
+        getBCHTypeNumber: function (t) {
+          for (var e = t << 12; w.getBCHDigit(e) - w.getBCHDigit(w.G18) >= 0; )
+            e ^= w.G18 << (w.getBCHDigit(e) - w.getBCHDigit(w.G18));
+          return (t << 12) | e;
+        },
+        getBCHDigit: function (t) {
+          for (var e = 0; 0 != t; ) e++, (t >>>= 1);
+          return e;
+        },
+        getPatternPosition: function (t) {
+          return w.PATTERN_POSITION_TABLE[t - 1];
+        },
+        getMask: function (t, e, r) {
+          switch (t) {
+            case c:
+              return (e + r) % 2 == 0;
+            case d:
+              return e % 2 == 0;
+            case m:
+              return r % 3 == 0;
+            case v:
+              return (e + r) % 3 == 0;
+            case p:
+              return (Math.floor(e / 2) + Math.floor(r / 3)) % 2 == 0;
+            case C:
+              return ((e * r) % 2) + ((e * r) % 3) == 0;
+            case B:
+              return (((e * r) % 2) + ((e * r) % 3)) % 2 == 0;
+            case L:
+              return (((e * r) % 3) + ((e + r) % 2)) % 2 == 0;
+            default:
+              throw new Error('bad maskPattern:' + t);
+          }
+        },
+        getErrorCorrectPolynomial: function (t) {
+          for (var e = new A([1], 0), r = 0; r < t; r++)
+            e = e.multiply(new A([1, y.gexp(r)], 0));
+          return e;
+        },
+        getLengthInBits: function (t, e) {
+          if (1 <= e && e < 10)
+            switch (t) {
+              case f.MODE_NUMBER:
+                return 10;
+              case f.MODE_ALPHA_NUM:
+                return 9;
+              case f.MODE_8BIT_BYTE:
+              case f.MODE_KANJI:
+                return 8;
+              default:
+                throw new Error('mode:' + t);
+            }
+          else if (e < 27)
+            switch (t) {
+              case f.MODE_NUMBER:
+                return 12;
+              case f.MODE_ALPHA_NUM:
+                return 11;
+              case f.MODE_8BIT_BYTE:
+                return 16;
+              case f.MODE_KANJI:
+                return 10;
+              default:
+                throw new Error('mode:' + t);
+            }
+          else {
+            if (!(e < 41)) throw new Error('type:' + e);
+            switch (t) {
+              case f.MODE_NUMBER:
+                return 14;
+              case f.MODE_ALPHA_NUM:
+                return 13;
+              case f.MODE_8BIT_BYTE:
+                return 16;
+              case f.MODE_KANJI:
+                return 12;
+              default:
+                throw new Error('mode:' + t);
+            }
+          }
+        },
+        getLostPoint: function (t) {
+          for (var e = t.getModuleCount(), r = 0, o = 0; o < e; o++)
+            for (var n = 0; n < e; n++) {
+              for (var i = 0, a = t.isDark(o, n), u = -1; u <= 1; u++)
+                if (!(o + u < 0 || e <= o + u))
+                  for (var s = -1; s <= 1; s++)
+                    n + s < 0 ||
+                      e <= n + s ||
+                      (0 == u && 0 == s) ||
+                      (a == t.isDark(o + u, n + s) && i++);
+              i > 5 && (r += 3 + i - 5);
+            }
+          for (o = 0; o < e - 1; o++)
+            for (n = 0; n < e - 1; n++) {
+              var h = 0;
+              t.isDark(o, n) && h++,
+                t.isDark(o + 1, n) && h++,
+                t.isDark(o, n + 1) && h++,
+                t.isDark(o + 1, n + 1) && h++,
+                (0 != h && 4 != h) || (r += 3);
+            }
+          for (o = 0; o < e; o++)
+            for (n = 0; n < e - 6; n++)
+              t.isDark(o, n) &&
+                !t.isDark(o, n + 1) &&
+                t.isDark(o, n + 2) &&
+                t.isDark(o, n + 3) &&
+                t.isDark(o, n + 4) &&
+                !t.isDark(o, n + 5) &&
+                t.isDark(o, n + 6) &&
+                (r += 40);
+          for (n = 0; n < e; n++)
+            for (o = 0; o < e - 6; o++)
+              t.isDark(o, n) &&
+                !t.isDark(o + 1, n) &&
+                t.isDark(o + 2, n) &&
+                t.isDark(o + 3, n) &&
+                t.isDark(o + 4, n) &&
+                !t.isDark(o + 5, n) &&
+                t.isDark(o + 6, n) &&
+                (r += 40);
+          var l = 0;
+          for (n = 0; n < e; n++) for (o = 0; o < e; o++) t.isDark(o, n) && l++;
+          return (r += 10 * (Math.abs((100 * l) / e / e - 50) / 5));
+        },
+      },
+      y = {
+        glog: function (t) {
+          if (t < 1) throw new Error('glog(' + t + ')');
+          return y.LOG_TABLE[t];
+        },
+        gexp: function (t) {
+          for (; t < 0; ) t += 255;
+          for (; t >= 256; ) t -= 255;
+          return y.EXP_TABLE[t];
+        },
+        EXP_TABLE: new Array(256),
+        LOG_TABLE: new Array(256),
+      },
+      E = 0;
+    E < 8;
+    E++
+  )
+    y.EXP_TABLE[E] = 1 << E;
+  for (E = 8; E < 256; E++)
+    y.EXP_TABLE[E] =
+      y.EXP_TABLE[E - 4] ^
+      y.EXP_TABLE[E - 5] ^
+      y.EXP_TABLE[E - 6] ^
+      y.EXP_TABLE[E - 8];
+  for (E = 0; E < 255; E++) y.LOG_TABLE[y.EXP_TABLE[E]] = E;
+  function A(t, e) {
+    if (void 0 == t.length) throw new Error(t.length + '/' + e);
+    for (var r = 0; r < t.length && 0 == t[r]; ) r++;
+    this.num = new Array(t.length - r + e);
+    for (var o = 0; o < t.length - r; o++) this.num[o] = t[o + r];
+  }
+  function _(t, e) {
+    (this.totalCount = t), (this.dataCount = e);
+  }
+  function D() {
+    (this.buffer = []), (this.length = 0);
+  }
+  return (
+    (A.prototype = {
+      get: function (t) {
+        return this.num[t];
+      },
+      getLength: function () {
+        return this.num.length;
+      },
+      multiply: function (t) {
+        for (
+          var e = new Array(this.getLength() + t.getLength() - 1), r = 0;
+          r < this.getLength();
+          r++
+        )
+          for (var o = 0; o < t.getLength(); o++)
+            e[r + o] ^= y.gexp(y.glog(this.get(r)) + y.glog(t.get(o)));
+        return new A(e, 0);
+      },
+      mod: function (t) {
+        if (this.getLength() - t.getLength() < 0) return this;
+        for (
+          var e = y.glog(this.get(0)) - y.glog(t.get(0)),
+            r = new Array(this.getLength()),
+            o = 0;
+          o < this.getLength();
+          o++
+        )
+          r[o] = this.get(o);
+        for (o = 0; o < t.getLength(); o++)
+          r[o] ^= y.gexp(y.glog(t.get(o)) + e);
+        return new A(r, 0).mod(t);
+      },
+    }),
+    (_.RS_BLOCK_TABLE = [
+      [1, 26, 19],
+      [1, 26, 16],
+      [1, 26, 13],
+      [1, 26, 9],
+      [1, 44, 34],
+      [1, 44, 28],
+      [1, 44, 22],
+      [1, 44, 16],
+      [1, 70, 55],
+      [1, 70, 44],
+      [2, 35, 17],
+      [2, 35, 13],
+      [1, 100, 80],
+      [2, 50, 32],
+      [2, 50, 24],
+      [4, 25, 9],
+      [1, 134, 108],
+      [2, 67, 43],
+      [2, 33, 15, 2, 34, 16],
+      [2, 33, 11, 2, 34, 12],
+      [2, 86, 68],
+      [4, 43, 27],
+      [4, 43, 19],
+      [4, 43, 15],
+      [2, 98, 78],
+      [4, 49, 31],
+      [2, 32, 14, 4, 33, 15],
+      [4, 39, 13, 1, 40, 14],
+      [2, 121, 97],
+      [2, 60, 38, 2, 61, 39],
+      [4, 40, 18, 2, 41, 19],
+      [4, 40, 14, 2, 41, 15],
+      [2, 146, 116],
+      [3, 58, 36, 2, 59, 37],
+      [4, 36, 16, 4, 37, 17],
+      [4, 36, 12, 4, 37, 13],
+      [2, 86, 68, 2, 87, 69],
+      [4, 69, 43, 1, 70, 44],
+      [6, 43, 19, 2, 44, 20],
+      [6, 43, 15, 2, 44, 16],
+      [4, 101, 81],
+      [1, 80, 50, 4, 81, 51],
+      [4, 50, 22, 4, 51, 23],
+      [3, 36, 12, 8, 37, 13],
+      [2, 116, 92, 2, 117, 93],
+      [6, 58, 36, 2, 59, 37],
+      [4, 46, 20, 6, 47, 21],
+      [7, 42, 14, 4, 43, 15],
+      [4, 133, 107],
+      [8, 59, 37, 1, 60, 38],
+      [8, 44, 20, 4, 45, 21],
+      [12, 33, 11, 4, 34, 12],
+      [3, 145, 115, 1, 146, 116],
+      [4, 64, 40, 5, 65, 41],
+      [11, 36, 16, 5, 37, 17],
+      [11, 36, 12, 5, 37, 13],
+      [5, 109, 87, 1, 110, 88],
+      [5, 65, 41, 5, 66, 42],
+      [5, 54, 24, 7, 55, 25],
+      [11, 36, 12],
+      [5, 122, 98, 1, 123, 99],
+      [7, 73, 45, 3, 74, 46],
+      [15, 43, 19, 2, 44, 20],
+      [3, 45, 15, 13, 46, 16],
+      [1, 135, 107, 5, 136, 108],
+      [10, 74, 46, 1, 75, 47],
+      [1, 50, 22, 15, 51, 23],
+      [2, 42, 14, 17, 43, 15],
+      [5, 150, 120, 1, 151, 121],
+      [9, 69, 43, 4, 70, 44],
+      [17, 50, 22, 1, 51, 23],
+      [2, 42, 14, 19, 43, 15],
+      [3, 141, 113, 4, 142, 114],
+      [3, 70, 44, 11, 71, 45],
+      [17, 47, 21, 4, 48, 22],
+      [9, 39, 13, 16, 40, 14],
+      [3, 135, 107, 5, 136, 108],
+      [3, 67, 41, 13, 68, 42],
+      [15, 54, 24, 5, 55, 25],
+      [15, 43, 15, 10, 44, 16],
+      [4, 144, 116, 4, 145, 117],
+      [17, 68, 42],
+      [17, 50, 22, 6, 51, 23],
+      [19, 46, 16, 6, 47, 17],
+      [2, 139, 111, 7, 140, 112],
+      [17, 74, 46],
+      [7, 54, 24, 16, 55, 25],
+      [34, 37, 13],
+      [4, 151, 121, 5, 152, 122],
+      [4, 75, 47, 14, 76, 48],
+      [11, 54, 24, 14, 55, 25],
+      [16, 45, 15, 14, 46, 16],
+      [6, 147, 117, 4, 148, 118],
+      [6, 73, 45, 14, 74, 46],
+      [11, 54, 24, 16, 55, 25],
+      [30, 46, 16, 2, 47, 17],
+      [8, 132, 106, 4, 133, 107],
+      [8, 75, 47, 13, 76, 48],
+      [7, 54, 24, 22, 55, 25],
+      [22, 45, 15, 13, 46, 16],
+      [10, 142, 114, 2, 143, 115],
+      [19, 74, 46, 4, 75, 47],
+      [28, 50, 22, 6, 51, 23],
+      [33, 46, 16, 4, 47, 17],
+      [8, 152, 122, 4, 153, 123],
+      [22, 73, 45, 3, 74, 46],
+      [8, 53, 23, 26, 54, 24],
+      [12, 45, 15, 28, 46, 16],
+      [3, 147, 117, 10, 148, 118],
+      [3, 73, 45, 23, 74, 46],
+      [4, 54, 24, 31, 55, 25],
+      [11, 45, 15, 31, 46, 16],
+      [7, 146, 116, 7, 147, 117],
+      [21, 73, 45, 7, 74, 46],
+      [1, 53, 23, 37, 54, 24],
+      [19, 45, 15, 26, 46, 16],
+      [5, 145, 115, 10, 146, 116],
+      [19, 75, 47, 10, 76, 48],
+      [15, 54, 24, 25, 55, 25],
+      [23, 45, 15, 25, 46, 16],
+      [13, 145, 115, 3, 146, 116],
+      [2, 74, 46, 29, 75, 47],
+      [42, 54, 24, 1, 55, 25],
+      [23, 45, 15, 28, 46, 16],
+      [17, 145, 115],
+      [10, 74, 46, 23, 75, 47],
+      [10, 54, 24, 35, 55, 25],
+      [19, 45, 15, 35, 46, 16],
+      [17, 145, 115, 1, 146, 116],
+      [14, 74, 46, 21, 75, 47],
+      [29, 54, 24, 19, 55, 25],
+      [11, 45, 15, 46, 46, 16],
+      [13, 145, 115, 6, 146, 116],
+      [14, 74, 46, 23, 75, 47],
+      [44, 54, 24, 7, 55, 25],
+      [59, 46, 16, 1, 47, 17],
+      [12, 151, 121, 7, 152, 122],
+      [12, 75, 47, 26, 76, 48],
+      [39, 54, 24, 14, 55, 25],
+      [22, 45, 15, 41, 46, 16],
+      [6, 151, 121, 14, 152, 122],
+      [6, 75, 47, 34, 76, 48],
+      [46, 54, 24, 10, 55, 25],
+      [2, 45, 15, 64, 46, 16],
+      [17, 152, 122, 4, 153, 123],
+      [29, 74, 46, 14, 75, 47],
+      [49, 54, 24, 10, 55, 25],
+      [24, 45, 15, 46, 46, 16],
+      [4, 152, 122, 18, 153, 123],
+      [13, 74, 46, 32, 75, 47],
+      [48, 54, 24, 14, 55, 25],
+      [42, 45, 15, 32, 46, 16],
+      [20, 147, 117, 4, 148, 118],
+      [40, 75, 47, 7, 76, 48],
+      [43, 54, 24, 22, 55, 25],
+      [10, 45, 15, 67, 46, 16],
+      [19, 148, 118, 6, 149, 119],
+      [18, 75, 47, 31, 76, 48],
+      [34, 54, 24, 34, 55, 25],
+      [20, 45, 15, 61, 46, 16],
+    ]),
+    (_.getRSBlocks = function (t, e) {
+      var r = _.getRsBlockTable(t, e);
+      if (void 0 == r)
+        throw new Error(
+          'bad rs block @ typeNumber:' + t + '/errorCorrectLevel:' + e
+        );
+      for (var o = r.length / 3, n = [], i = 0; i < o; i++)
+        for (
+          var a = r[3 * i + 0], u = r[3 * i + 1], s = r[3 * i + 2], h = 0;
+          h < a;
+          h++
+        )
+          n.push(new _(u, s));
+      return n;
+    }),
+    (_.getRsBlockTable = function (t, e) {
+      switch (e) {
+        case g.L:
+          return _.RS_BLOCK_TABLE[4 * (t - 1) + 0];
+        case g.M:
+          return _.RS_BLOCK_TABLE[4 * (t - 1) + 1];
+        case g.Q:
+          return _.RS_BLOCK_TABLE[4 * (t - 1) + 2];
+        case g.H:
+          return _.RS_BLOCK_TABLE[4 * (t - 1) + 3];
+        default:
+          return;
+      }
+    }),
+    (D.prototype = {
+      get: function (t) {
+        var e = Math.floor(t / 8);
+        return 1 == ((this.buffer[e] >>> (7 - (t % 8))) & 1);
+      },
+      put: function (t, e) {
+        for (var r = 0; r < e; r++) this.putBit(1 == ((t >>> (e - r - 1)) & 1));
+      },
+      getLengthInBits: function () {
+        return this.length;
+      },
+      putBit: function (t) {
+        var e = Math.floor(this.length / 8);
+        this.buffer.length <= e && this.buffer.push(0),
+          t && (this.buffer[e] |= 128 >>> this.length % 8),
+          this.length++;
+      },
+    }),
+    function (t) {
+      (t = t || {}),
+        (t = s(
+          !0,
+          {
+            width: 256,
+            height: 256,
+            x: 0,
+            y: 0,
+            typeNumber: -1,
+            correctLevel: g.H,
+            background: '#ffffff',
+            foreground: '#000000',
+            image: {
+              imageResource: '',
+              dx: 0,
+              dy: 0,
+              dWidth: 100,
+              dHeight: 100,
+            },
+          },
+          t
+        )).canvasId || t.ctx
+          ? (function () {
+              var e,
+                r = new l(t.typeNumber, t.correctLevel);
+              r.addData(
+                (function (t) {
+                  var e, r, o, n;
+                  for (e = '', o = t.length, r = 0; r < o; r++)
+                    (n = t.charCodeAt(r)) >= 1 && n <= 127
+                      ? (e += t.charAt(r))
+                      : n > 2047
+                      ? ((e += String.fromCharCode(224 | ((n >> 12) & 15))),
+                        (e += String.fromCharCode(128 | ((n >> 6) & 63))),
+                        (e += String.fromCharCode(128 | ((n >> 0) & 63))))
+                      : ((e += String.fromCharCode(192 | ((n >> 6) & 31))),
+                        (e += String.fromCharCode(128 | ((n >> 0) & 63))));
+                  return e;
+                })(t.text)
+              ),
+                r.make(),
+                (e = t.ctx
+                  ? t.ctx
+                  : t._this
+                  ? wx.createCanvasContext &&
+                    wx.createCanvasContext(t.canvasId, t._this)
+                  : wx.createCanvasContext &&
+                    wx.createCanvasContext(t.canvasId));
+              for (
+                var o = t.width / r.getModuleCount(),
+                  n = t.height / r.getModuleCount(),
+                  i = 0;
+                i < r.getModuleCount();
+                i++
+              )
+                for (var a = 0; a < r.getModuleCount(); a++) {
+                  var u = r.isDark(i, a) ? t.foreground : t.background;
+                  e.setFillStyle(u);
+                  var s = Math.ceil((a + 1) * o) - Math.floor(a * o),
+                    h = Math.ceil((i + 1) * o) - Math.floor(i * o);
+                  e.fillRect(
+                    Math.round(a * o) + t.x,
+                    Math.round(i * n) + t.y,
+                    s,
+                    h
+                  );
+                }
+              t.image.imageResource &&
+                e.drawImage(
+                  t.image.imageResource,
+                  t.image.dx,
+                  t.image.dy,
+                  t.image.dWidth,
+                  t.image.dHeight
+                ),
+                e.draw(!1, function (e) {
+                  t.callback && t.callback(e);
+                });
+            })()
+          : console.warn('please set canvasId or ctx!');
+    }
+  );
+});