wk-ie-ai-customer 1.0.1

package/dist/wk-ai-customer.esm.js

@@ -0,0 +1,3584 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+    writable: false
+  }), e;
+}
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: true,
+      configurable: true
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: false
+  }), e && _setPrototypeOf(t, e);
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == typeof e || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var jsbn$1 = {exports: {}};
+
+var jsbn = jsbn$1.exports;
+
+var hasRequiredJsbn;
+
+function requireJsbn () {
+	if (hasRequiredJsbn) return jsbn$1.exports;
+	hasRequiredJsbn = 1;
+	(function (module, exports) {
+		(function(){
+
+		    // Copyright (c) 2005  Tom Wu
+		    // All Rights Reserved.
+		    // See "LICENSE" for details.
+
+		    // Basic JavaScript BN library - subset useful for RSA encryption.
+
+		    // Bits per digit
+		    var dbits;
+
+		    // JavaScript engine analysis
+		    var canary = 0xdeadbeefcafe;
+		    var j_lm = ((canary&0xffffff)==0xefcafe);
+
+		    // (public) Constructor
+		    function BigInteger(a,b,c) {
+		      if(a != null)
+		        if("number" == typeof a) this.fromNumber(a,b,c);
+		        else if(b == null && "string" != typeof a) this.fromString(a,256);
+		        else this.fromString(a,b);
+		    }
+
+		    // return new, unset BigInteger
+		    function nbi() { return new BigInteger(null); }
+
+		    // am: Compute w_j += (x*this_i), propagate carries,
+		    // c is initial carry, returns final carry.
+		    // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
+		    // We need to select the fastest one that works in this environment.
+
+		    // am1: use a single mult and divide to get the high bits,
+		    // max digit bits should be 26 because
+		    // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
+		    function am1(i,x,w,j,c,n) {
+		      while(--n >= 0) {
+		        var v = x*this[i++]+w[j]+c;
+		        c = Math.floor(v/0x4000000);
+		        w[j++] = v&0x3ffffff;
+		      }
+		      return c;
+		    }
+		    // am2 avoids a big mult-and-extract completely.
+		    // Max digit bits should be <= 30 because we do bitwise ops
+		    // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
+		    function am2(i,x,w,j,c,n) {
+		      var xl = x&0x7fff, xh = x>>15;
+		      while(--n >= 0) {
+		        var l = this[i]&0x7fff;
+		        var h = this[i++]>>15;
+		        var m = xh*l+h*xl;
+		        l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);
+		        c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
+		        w[j++] = l&0x3fffffff;
+		      }
+		      return c;
+		    }
+		    // Alternately, set max digit bits to 28 since some
+		    // browsers slow down when dealing with 32-bit numbers.
+		    function am3(i,x,w,j,c,n) {
+		      var xl = x&0x3fff, xh = x>>14;
+		      while(--n >= 0) {
+		        var l = this[i]&0x3fff;
+		        var h = this[i++]>>14;
+		        var m = xh*l+h*xl;
+		        l = xl*l+((m&0x3fff)<<14)+w[j]+c;
+		        c = (l>>28)+(m>>14)+xh*h;
+		        w[j++] = l&0xfffffff;
+		      }
+		      return c;
+		    }
+		    var inBrowser = typeof navigator !== "undefined";
+		    if(inBrowser && j_lm && (navigator.appName == "Microsoft Internet Explorer")) {
+		      BigInteger.prototype.am = am2;
+		      dbits = 30;
+		    }
+		    else if(inBrowser && j_lm && (navigator.appName != "Netscape")) {
+		      BigInteger.prototype.am = am1;
+		      dbits = 26;
+		    }
+		    else { // Mozilla/Netscape seems to prefer am3
+		      BigInteger.prototype.am = am3;
+		      dbits = 28;
+		    }
+
+		    BigInteger.prototype.DB = dbits;
+		    BigInteger.prototype.DM = ((1<<dbits)-1);
+		    BigInteger.prototype.DV = (1<<dbits);
+
+		    var BI_FP = 52;
+		    BigInteger.prototype.FV = Math.pow(2,BI_FP);
+		    BigInteger.prototype.F1 = BI_FP-dbits;
+		    BigInteger.prototype.F2 = 2*dbits-BI_FP;
+
+		    // Digit conversions
+		    var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+		    var BI_RC = new Array();
+		    var rr,vv;
+		    rr = "0".charCodeAt(0);
+		    for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
+		    rr = "a".charCodeAt(0);
+		    for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
+		    rr = "A".charCodeAt(0);
+		    for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
+
+		    function int2char(n) { return BI_RM.charAt(n); }
+		    function intAt(s,i) {
+		      var c = BI_RC[s.charCodeAt(i)];
+		      return (c==null)?-1:c;
+		    }
+
+		    // (protected) copy this to r
+		    function bnpCopyTo(r) {
+		      for(var i = this.t-1; i >= 0; --i) r[i] = this[i];
+		      r.t = this.t;
+		      r.s = this.s;
+		    }
+
+		    // (protected) set from integer value x, -DV <= x < DV
+		    function bnpFromInt(x) {
+		      this.t = 1;
+		      this.s = (x<0)?-1:0;
+		      if(x > 0) this[0] = x;
+		      else if(x < -1) this[0] = x+this.DV;
+		      else this.t = 0;
+		    }
+
+		    // return bigint initialized to value
+		    function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
+
+		    // (protected) set from string and radix
+		    function bnpFromString(s,b) {
+		      var k;
+		      if(b == 16) k = 4;
+		      else if(b == 8) k = 3;
+		      else if(b == 256) k = 8; // byte array
+		      else if(b == 2) k = 1;
+		      else if(b == 32) k = 5;
+		      else if(b == 4) k = 2;
+		      else { this.fromRadix(s,b); return; }
+		      this.t = 0;
+		      this.s = 0;
+		      var i = s.length, mi = false, sh = 0;
+		      while(--i >= 0) {
+		        var x = (k==8)?s[i]&0xff:intAt(s,i);
+		        if(x < 0) {
+		          if(s.charAt(i) == "-") mi = true;
+		          continue;
+		        }
+		        mi = false;
+		        if(sh == 0)
+		          this[this.t++] = x;
+		        else if(sh+k > this.DB) {
+		          this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;
+		          this[this.t++] = (x>>(this.DB-sh));
+		        }
+		        else
+		          this[this.t-1] |= x<<sh;
+		        sh += k;
+		        if(sh >= this.DB) sh -= this.DB;
+		      }
+		      if(k == 8 && (s[0]&0x80) != 0) {
+		        this.s = -1;
+		        if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
+		      }
+		      this.clamp();
+		      if(mi) BigInteger.ZERO.subTo(this,this);
+		    }
+
+		    // (protected) clamp off excess high words
+		    function bnpClamp() {
+		      var c = this.s&this.DM;
+		      while(this.t > 0 && this[this.t-1] == c) --this.t;
+		    }
+
+		    // (public) return string representation in given radix
+		    function bnToString(b) {
+		      if(this.s < 0) return "-"+this.negate().toString(b);
+		      var k;
+		      if(b == 16) k = 4;
+		      else if(b == 8) k = 3;
+		      else if(b == 2) k = 1;
+		      else if(b == 32) k = 5;
+		      else if(b == 4) k = 2;
+		      else return this.toRadix(b);
+		      var km = (1<<k)-1, d, m = false, r = "", i = this.t;
+		      var p = this.DB-(i*this.DB)%k;
+		      if(i-- > 0) {
+		        if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }
+		        while(i >= 0) {
+		          if(p < k) {
+		            d = (this[i]&((1<<p)-1))<<(k-p);
+		            d |= this[--i]>>(p+=this.DB-k);
+		          }
+		          else {
+		            d = (this[i]>>(p-=k))&km;
+		            if(p <= 0) { p += this.DB; --i; }
+		          }
+		          if(d > 0) m = true;
+		          if(m) r += int2char(d);
+		        }
+		      }
+		      return m?r:"0";
+		    }
+
+		    // (public) -this
+		    function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
+
+		    // (public) |this|
+		    function bnAbs() { return (this.s<0)?this.negate():this; }
+
+		    // (public) return + if this > a, - if this < a, 0 if equal
+		    function bnCompareTo(a) {
+		      var r = this.s-a.s;
+		      if(r != 0) return r;
+		      var i = this.t;
+		      r = i-a.t;
+		      if(r != 0) return (this.s<0)?-r:r;
+		      while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
+		      return 0;
+		    }
+
+		    // returns bit length of the integer x
+		    function nbits(x) {
+		      var r = 1, t;
+		      if((t=x>>>16) != 0) { x = t; r += 16; }
+		      if((t=x>>8) != 0) { x = t; r += 8; }
+		      if((t=x>>4) != 0) { x = t; r += 4; }
+		      if((t=x>>2) != 0) { x = t; r += 2; }
+		      if((t=x>>1) != 0) { x = t; r += 1; }
+		      return r;
+		    }
+
+		    // (public) return the number of bits in "this"
+		    function bnBitLength() {
+		      if(this.t <= 0) return 0;
+		      return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
+		    }
+
+		    // (protected) r = this << n*DB
+		    function bnpDLShiftTo(n,r) {
+		      var i;
+		      for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
+		      for(i = n-1; i >= 0; --i) r[i] = 0;
+		      r.t = this.t+n;
+		      r.s = this.s;
+		    }
+
+		    // (protected) r = this >> n*DB
+		    function bnpDRShiftTo(n,r) {
+		      for(var i = n; i < this.t; ++i) r[i-n] = this[i];
+		      r.t = Math.max(this.t-n,0);
+		      r.s = this.s;
+		    }
+
+		    // (protected) r = this << n
+		    function bnpLShiftTo(n,r) {
+		      var bs = n%this.DB;
+		      var cbs = this.DB-bs;
+		      var bm = (1<<cbs)-1;
+		      var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;
+		      for(i = this.t-1; i >= 0; --i) {
+		        r[i+ds+1] = (this[i]>>cbs)|c;
+		        c = (this[i]&bm)<<bs;
+		      }
+		      for(i = ds-1; i >= 0; --i) r[i] = 0;
+		      r[ds] = c;
+		      r.t = this.t+ds+1;
+		      r.s = this.s;
+		      r.clamp();
+		    }
+
+		    // (protected) r = this >> n
+		    function bnpRShiftTo(n,r) {
+		      r.s = this.s;
+		      var ds = Math.floor(n/this.DB);
+		      if(ds >= this.t) { r.t = 0; return; }
+		      var bs = n%this.DB;
+		      var cbs = this.DB-bs;
+		      var bm = (1<<bs)-1;
+		      r[0] = this[ds]>>bs;
+		      for(var i = ds+1; i < this.t; ++i) {
+		        r[i-ds-1] |= (this[i]&bm)<<cbs;
+		        r[i-ds] = this[i]>>bs;
+		      }
+		      if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;
+		      r.t = this.t-ds;
+		      r.clamp();
+		    }
+
+		    // (protected) r = this - a
+		    function bnpSubTo(a,r) {
+		      var i = 0, c = 0, m = Math.min(a.t,this.t);
+		      while(i < m) {
+		        c += this[i]-a[i];
+		        r[i++] = c&this.DM;
+		        c >>= this.DB;
+		      }
+		      if(a.t < this.t) {
+		        c -= a.s;
+		        while(i < this.t) {
+		          c += this[i];
+		          r[i++] = c&this.DM;
+		          c >>= this.DB;
+		        }
+		        c += this.s;
+		      }
+		      else {
+		        c += this.s;
+		        while(i < a.t) {
+		          c -= a[i];
+		          r[i++] = c&this.DM;
+		          c >>= this.DB;
+		        }
+		        c -= a.s;
+		      }
+		      r.s = (c<0)?-1:0;
+		      if(c < -1) r[i++] = this.DV+c;
+		      else if(c > 0) r[i++] = c;
+		      r.t = i;
+		      r.clamp();
+		    }
+
+		    // (protected) r = this * a, r != this,a (HAC 14.12)
+		    // "this" should be the larger one if appropriate.
+		    function bnpMultiplyTo(a,r) {
+		      var x = this.abs(), y = a.abs();
+		      var i = x.t;
+		      r.t = i+y.t;
+		      while(--i >= 0) r[i] = 0;
+		      for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
+		      r.s = 0;
+		      r.clamp();
+		      if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
+		    }
+
+		    // (protected) r = this^2, r != this (HAC 14.16)
+		    function bnpSquareTo(r) {
+		      var x = this.abs();
+		      var i = r.t = 2*x.t;
+		      while(--i >= 0) r[i] = 0;
+		      for(i = 0; i < x.t-1; ++i) {
+		        var c = x.am(i,x[i],r,2*i,0,1);
+		        if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
+		          r[i+x.t] -= x.DV;
+		          r[i+x.t+1] = 1;
+		        }
+		      }
+		      if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
+		      r.s = 0;
+		      r.clamp();
+		    }
+
+		    // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
+		    // r != q, this != m.  q or r may be null.
+		    function bnpDivRemTo(m,q,r) {
+		      var pm = m.abs();
+		      if(pm.t <= 0) return;
+		      var pt = this.abs();
+		      if(pt.t < pm.t) {
+		        if(q != null) q.fromInt(0);
+		        if(r != null) this.copyTo(r);
+		        return;
+		      }
+		      if(r == null) r = nbi();
+		      var y = nbi(), ts = this.s, ms = m.s;
+		      var nsh = this.DB-nbits(pm[pm.t-1]);   // normalize modulus
+		      if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
+		      else { pm.copyTo(y); pt.copyTo(r); }
+		      var ys = y.t;
+		      var y0 = y[ys-1];
+		      if(y0 == 0) return;
+		      var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);
+		      var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;
+		      var i = r.t, j = i-ys, t = (q==null)?nbi():q;
+		      y.dlShiftTo(j,t);
+		      if(r.compareTo(t) >= 0) {
+		        r[r.t++] = 1;
+		        r.subTo(t,r);
+		      }
+		      BigInteger.ONE.dlShiftTo(ys,t);
+		      t.subTo(y,y);  // "negative" y so we can replace sub with am later
+		      while(y.t < ys) y[y.t++] = 0;
+		      while(--j >= 0) {
+		        // Estimate quotient digit
+		        var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
+		        if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) {   // Try it out
+		          y.dlShiftTo(j,t);
+		          r.subTo(t,r);
+		          while(r[i] < --qd) r.subTo(t,r);
+		        }
+		      }
+		      if(q != null) {
+		        r.drShiftTo(ys,q);
+		        if(ts != ms) BigInteger.ZERO.subTo(q,q);
+		      }
+		      r.t = ys;
+		      r.clamp();
+		      if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
+		      if(ts < 0) BigInteger.ZERO.subTo(r,r);
+		    }
+
+		    // (public) this mod a
+		    function bnMod(a) {
+		      var r = nbi();
+		      this.abs().divRemTo(a,null,r);
+		      if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
+		      return r;
+		    }
+
+		    // Modular reduction using "classic" algorithm
+		    function Classic(m) { this.m = m; }
+		    function cConvert(x) {
+		      if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
+		      else return x;
+		    }
+		    function cRevert(x) { return x; }
+		    function cReduce(x) { x.divRemTo(this.m,null,x); }
+		    function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+		    function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+		    Classic.prototype.convert = cConvert;
+		    Classic.prototype.revert = cRevert;
+		    Classic.prototype.reduce = cReduce;
+		    Classic.prototype.mulTo = cMulTo;
+		    Classic.prototype.sqrTo = cSqrTo;
+
+		    // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
+		    // justification:
+		    //         xy == 1 (mod m)
+		    //         xy =  1+km
+		    //   xy(2-xy) = (1+km)(1-km)
+		    // x[y(2-xy)] = 1-k^2m^2
+		    // x[y(2-xy)] == 1 (mod m^2)
+		    // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
+		    // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
+		    // JS multiply "overflows" differently from C/C++, so care is needed here.
+		    function bnpInvDigit() {
+		      if(this.t < 1) return 0;
+		      var x = this[0];
+		      if((x&1) == 0) return 0;
+		      var y = x&3;       // y == 1/x mod 2^2
+		      y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
+		      y = (y*(2-(x&0xff)*y))&0xff;   // y == 1/x mod 2^8
+		      y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff;    // y == 1/x mod 2^16
+		      // last step - calculate inverse mod DV directly;
+		      // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
+		      y = (y*(2-x*y%this.DV))%this.DV;       // y == 1/x mod 2^dbits
+		      // we really want the negative inverse, and -DV < y < DV
+		      return (y>0)?this.DV-y:-y;
+		    }
+
+		    // Montgomery reduction
+		    function Montgomery(m) {
+		      this.m = m;
+		      this.mp = m.invDigit();
+		      this.mpl = this.mp&0x7fff;
+		      this.mph = this.mp>>15;
+		      this.um = (1<<(m.DB-15))-1;
+		      this.mt2 = 2*m.t;
+		    }
+
+		    // xR mod m
+		    function montConvert(x) {
+		      var r = nbi();
+		      x.abs().dlShiftTo(this.m.t,r);
+		      r.divRemTo(this.m,null,r);
+		      if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
+		      return r;
+		    }
+
+		    // x/R mod m
+		    function montRevert(x) {
+		      var r = nbi();
+		      x.copyTo(r);
+		      this.reduce(r);
+		      return r;
+		    }
+
+		    // x = x/R mod m (HAC 14.32)
+		    function montReduce(x) {
+		      while(x.t <= this.mt2) // pad x so am has enough room later
+		        x[x.t++] = 0;
+		      for(var i = 0; i < this.m.t; ++i) {
+		        // faster way of calculating u0 = x[i]*mp mod DV
+		        var j = x[i]&0x7fff;
+		        var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
+		        // use am to combine the multiply-shift-add into one call
+		        j = i+this.m.t;
+		        x[j] += this.m.am(0,u0,x,i,0,this.m.t);
+		        // propagate carry
+		        while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
+		      }
+		      x.clamp();
+		      x.drShiftTo(this.m.t,x);
+		      if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+		    }
+
+		    // r = "x^2/R mod m"; x != r
+		    function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+		    // r = "xy/R mod m"; x,y != r
+		    function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+		    Montgomery.prototype.convert = montConvert;
+		    Montgomery.prototype.revert = montRevert;
+		    Montgomery.prototype.reduce = montReduce;
+		    Montgomery.prototype.mulTo = montMulTo;
+		    Montgomery.prototype.sqrTo = montSqrTo;
+
+		    // (protected) true iff this is even
+		    function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
+
+		    // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
+		    function bnpExp(e,z) {
+		      if(e > 0xffffffff || e < 1) return BigInteger.ONE;
+		      var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
+		      g.copyTo(r);
+		      while(--i >= 0) {
+		        z.sqrTo(r,r2);
+		        if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
+		        else { var t = r; r = r2; r2 = t; }
+		      }
+		      return z.revert(r);
+		    }
+
+		    // (public) this^e % m, 0 <= e < 2^32
+		    function bnModPowInt(e,m) {
+		      var z;
+		      if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
+		      return this.exp(e,z);
+		    }
+
+		    // protected
+		    BigInteger.prototype.copyTo = bnpCopyTo;
+		    BigInteger.prototype.fromInt = bnpFromInt;
+		    BigInteger.prototype.fromString = bnpFromString;
+		    BigInteger.prototype.clamp = bnpClamp;
+		    BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
+		    BigInteger.prototype.drShiftTo = bnpDRShiftTo;
+		    BigInteger.prototype.lShiftTo = bnpLShiftTo;
+		    BigInteger.prototype.rShiftTo = bnpRShiftTo;
+		    BigInteger.prototype.subTo = bnpSubTo;
+		    BigInteger.prototype.multiplyTo = bnpMultiplyTo;
+		    BigInteger.prototype.squareTo = bnpSquareTo;
+		    BigInteger.prototype.divRemTo = bnpDivRemTo;
+		    BigInteger.prototype.invDigit = bnpInvDigit;
+		    BigInteger.prototype.isEven = bnpIsEven;
+		    BigInteger.prototype.exp = bnpExp;
+
+		    // public
+		    BigInteger.prototype.toString = bnToString;
+		    BigInteger.prototype.negate = bnNegate;
+		    BigInteger.prototype.abs = bnAbs;
+		    BigInteger.prototype.compareTo = bnCompareTo;
+		    BigInteger.prototype.bitLength = bnBitLength;
+		    BigInteger.prototype.mod = bnMod;
+		    BigInteger.prototype.modPowInt = bnModPowInt;
+
+		    // "constants"
+		    BigInteger.ZERO = nbv(0);
+		    BigInteger.ONE = nbv(1);
+
+		    // Copyright (c) 2005-2009  Tom Wu
+		    // All Rights Reserved.
+		    // See "LICENSE" for details.
+
+		    // Extended JavaScript BN functions, required for RSA private ops.
+
+		    // Version 1.1: new BigInteger("0", 10) returns "proper" zero
+		    // Version 1.2: square() API, isProbablePrime fix
+
+		    // (public)
+		    function bnClone() { var r = nbi(); this.copyTo(r); return r; }
+
+		    // (public) return value as integer
+		    function bnIntValue() {
+		      if(this.s < 0) {
+		        if(this.t == 1) return this[0]-this.DV;
+		        else if(this.t == 0) return -1;
+		      }
+		      else if(this.t == 1) return this[0];
+		      else if(this.t == 0) return 0;
+		      // assumes 16 < DB < 32
+		      return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];
+		    }
+
+		    // (public) return value as byte
+		    function bnByteValue() { return (this.t==0)?this.s:(this[0]<<24)>>24; }
+
+		    // (public) return value as short (assumes DB>=16)
+		    function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }
+
+		    // (protected) return x s.t. r^x < DV
+		    function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }
+
+		    // (public) 0 if this == 0, 1 if this > 0
+		    function bnSigNum() {
+		      if(this.s < 0) return -1;
+		      else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
+		      else return 1;
+		    }
+
+		    // (protected) convert to radix string
+		    function bnpToRadix(b) {
+		      if(b == null) b = 10;
+		      if(this.signum() == 0 || b < 2 || b > 36) return "0";
+		      var cs = this.chunkSize(b);
+		      var a = Math.pow(b,cs);
+		      var d = nbv(a), y = nbi(), z = nbi(), r = "";
+		      this.divRemTo(d,y,z);
+		      while(y.signum() > 0) {
+		        r = (a+z.intValue()).toString(b).substr(1) + r;
+		        y.divRemTo(d,y,z);
+		      }
+		      return z.intValue().toString(b) + r;
+		    }
+
+		    // (protected) convert from radix string
+		    function bnpFromRadix(s,b) {
+		      this.fromInt(0);
+		      if(b == null) b = 10;
+		      var cs = this.chunkSize(b);
+		      var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
+		      for(var i = 0; i < s.length; ++i) {
+		        var x = intAt(s,i);
+		        if(x < 0) {
+		          if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
+		          continue;
+		        }
+		        w = b*w+x;
+		        if(++j >= cs) {
+		          this.dMultiply(d);
+		          this.dAddOffset(w,0);
+		          j = 0;
+		          w = 0;
+		        }
+		      }
+		      if(j > 0) {
+		        this.dMultiply(Math.pow(b,j));
+		        this.dAddOffset(w,0);
+		      }
+		      if(mi) BigInteger.ZERO.subTo(this,this);
+		    }
+
+		    // (protected) alternate constructor
+		    function bnpFromNumber(a,b,c) {
+		      if("number" == typeof b) {
+		        // new BigInteger(int,int,RNG)
+		        if(a < 2) this.fromInt(1);
+		        else {
+		          this.fromNumber(a,c);
+		          if(!this.testBit(a-1))    // force MSB set
+		            this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);
+		          if(this.isEven()) this.dAddOffset(1,0); // force odd
+		          while(!this.isProbablePrime(b)) {
+		            this.dAddOffset(2,0);
+		            if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);
+		          }
+		        }
+		      }
+		      else {
+		        // new BigInteger(int,RNG)
+		        var x = new Array(), t = a&7;
+		        x.length = (a>>3)+1;
+		        b.nextBytes(x);
+		        if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0;
+		        this.fromString(x,256);
+		      }
+		    }
+
+		    // (public) convert to bigendian byte array
+		    function bnToByteArray() {
+		      var i = this.t, r = new Array();
+		      r[0] = this.s;
+		      var p = this.DB-(i*this.DB)%8, d, k = 0;
+		      if(i-- > 0) {
+		        if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)
+		          r[k++] = d|(this.s<<(this.DB-p));
+		        while(i >= 0) {
+		          if(p < 8) {
+		            d = (this[i]&((1<<p)-1))<<(8-p);
+		            d |= this[--i]>>(p+=this.DB-8);
+		          }
+		          else {
+		            d = (this[i]>>(p-=8))&0xff;
+		            if(p <= 0) { p += this.DB; --i; }
+		          }
+		          if((d&0x80) != 0) d |= -256;
+		          if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;
+		          if(k > 0 || d != this.s) r[k++] = d;
+		        }
+		      }
+		      return r;
+		    }
+
+		    function bnEquals(a) { return(this.compareTo(a)==0); }
+		    function bnMin(a) { return (this.compareTo(a)<0)?this:a; }
+		    function bnMax(a) { return (this.compareTo(a)>0)?this:a; }
+
+		    // (protected) r = this op a (bitwise)
+		    function bnpBitwiseTo(a,op,r) {
+		      var i, f, m = Math.min(a.t,this.t);
+		      for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);
+		      if(a.t < this.t) {
+		        f = a.s&this.DM;
+		        for(i = m; i < this.t; ++i) r[i] = op(this[i],f);
+		        r.t = this.t;
+		      }
+		      else {
+		        f = this.s&this.DM;
+		        for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);
+		        r.t = a.t;
+		      }
+		      r.s = op(this.s,a.s);
+		      r.clamp();
+		    }
+
+		    // (public) this & a
+		    function op_and(x,y) { return x&y; }
+		    function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }
+
+		    // (public) this | a
+		    function op_or(x,y) { return x|y; }
+		    function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }
+
+		    // (public) this ^ a
+		    function op_xor(x,y) { return x^y; }
+		    function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }
+
+		    // (public) this & ~a
+		    function op_andnot(x,y) { return x&~y; }
+		    function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }
+
+		    // (public) ~this
+		    function bnNot() {
+		      var r = nbi();
+		      for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];
+		      r.t = this.t;
+		      r.s = ~this.s;
+		      return r;
+		    }
+
+		    // (public) this << n
+		    function bnShiftLeft(n) {
+		      var r = nbi();
+		      if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);
+		      return r;
+		    }
+
+		    // (public) this >> n
+		    function bnShiftRight(n) {
+		      var r = nbi();
+		      if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);
+		      return r;
+		    }
+
+		    // return index of lowest 1-bit in x, x < 2^31
+		    function lbit(x) {
+		      if(x == 0) return -1;
+		      var r = 0;
+		      if((x&0xffff) == 0) { x >>= 16; r += 16; }
+		      if((x&0xff) == 0) { x >>= 8; r += 8; }
+		      if((x&0xf) == 0) { x >>= 4; r += 4; }
+		      if((x&3) == 0) { x >>= 2; r += 2; }
+		      if((x&1) == 0) ++r;
+		      return r;
+		    }
+
+		    // (public) returns index of lowest 1-bit (or -1 if none)
+		    function bnGetLowestSetBit() {
+		      for(var i = 0; i < this.t; ++i)
+		        if(this[i] != 0) return i*this.DB+lbit(this[i]);
+		      if(this.s < 0) return this.t*this.DB;
+		      return -1;
+		    }
+
+		    // return number of 1 bits in x
+		    function cbit(x) {
+		      var r = 0;
+		      while(x != 0) { x &= x-1; ++r; }
+		      return r;
+		    }
+
+		    // (public) return number of set bits
+		    function bnBitCount() {
+		      var r = 0, x = this.s&this.DM;
+		      for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);
+		      return r;
+		    }
+
+		    // (public) true iff nth bit is set
+		    function bnTestBit(n) {
+		      var j = Math.floor(n/this.DB);
+		      if(j >= this.t) return(this.s!=0);
+		      return((this[j]&(1<<(n%this.DB)))!=0);
+		    }
+
+		    // (protected) this op (1<<n)
+		    function bnpChangeBit(n,op) {
+		      var r = BigInteger.ONE.shiftLeft(n);
+		      this.bitwiseTo(r,op,r);
+		      return r;
+		    }
+
+		    // (public) this | (1<<n)
+		    function bnSetBit(n) { return this.changeBit(n,op_or); }
+
+		    // (public) this & ~(1<<n)
+		    function bnClearBit(n) { return this.changeBit(n,op_andnot); }
+
+		    // (public) this ^ (1<<n)
+		    function bnFlipBit(n) { return this.changeBit(n,op_xor); }
+
+		    // (protected) r = this + a
+		    function bnpAddTo(a,r) {
+		      var i = 0, c = 0, m = Math.min(a.t,this.t);
+		      while(i < m) {
+		        c += this[i]+a[i];
+		        r[i++] = c&this.DM;
+		        c >>= this.DB;
+		      }
+		      if(a.t < this.t) {
+		        c += a.s;
+		        while(i < this.t) {
+		          c += this[i];
+		          r[i++] = c&this.DM;
+		          c >>= this.DB;
+		        }
+		        c += this.s;
+		      }
+		      else {
+		        c += this.s;
+		        while(i < a.t) {
+		          c += a[i];
+		          r[i++] = c&this.DM;
+		          c >>= this.DB;
+		        }
+		        c += a.s;
+		      }
+		      r.s = (c<0)?-1:0;
+		      if(c > 0) r[i++] = c;
+		      else if(c < -1) r[i++] = this.DV+c;
+		      r.t = i;
+		      r.clamp();
+		    }
+
+		    // (public) this + a
+		    function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }
+
+		    // (public) this - a
+		    function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }
+
+		    // (public) this * a
+		    function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }
+
+		    // (public) this^2
+		    function bnSquare() { var r = nbi(); this.squareTo(r); return r; }
+
+		    // (public) this / a
+		    function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }
+
+		    // (public) this % a
+		    function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }
+
+		    // (public) [this/a,this%a]
+		    function bnDivideAndRemainder(a) {
+		      var q = nbi(), r = nbi();
+		      this.divRemTo(a,q,r);
+		      return new Array(q,r);
+		    }
+
+		    // (protected) this *= n, this >= 0, 1 < n < DV
+		    function bnpDMultiply(n) {
+		      this[this.t] = this.am(0,n-1,this,0,0,this.t);
+		      ++this.t;
+		      this.clamp();
+		    }
+
+		    // (protected) this += n << w words, this >= 0
+		    function bnpDAddOffset(n,w) {
+		      if(n == 0) return;
+		      while(this.t <= w) this[this.t++] = 0;
+		      this[w] += n;
+		      while(this[w] >= this.DV) {
+		        this[w] -= this.DV;
+		        if(++w >= this.t) this[this.t++] = 0;
+		        ++this[w];
+		      }
+		    }
+
+		    // A "null" reducer
+		    function NullExp() {}
+		    function nNop(x) { return x; }
+		    function nMulTo(x,y,r) { x.multiplyTo(y,r); }
+		    function nSqrTo(x,r) { x.squareTo(r); }
+
+		    NullExp.prototype.convert = nNop;
+		    NullExp.prototype.revert = nNop;
+		    NullExp.prototype.mulTo = nMulTo;
+		    NullExp.prototype.sqrTo = nSqrTo;
+
+		    // (public) this^e
+		    function bnPow(e) { return this.exp(e,new NullExp()); }
+
+		    // (protected) r = lower n words of "this * a", a.t <= n
+		    // "this" should be the larger one if appropriate.
+		    function bnpMultiplyLowerTo(a,n,r) {
+		      var i = Math.min(this.t+a.t,n);
+		      r.s = 0; // assumes a,this >= 0
+		      r.t = i;
+		      while(i > 0) r[--i] = 0;
+		      var j;
+		      for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);
+		      for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);
+		      r.clamp();
+		    }
+
+		    // (protected) r = "this * a" without lower n words, n > 0
+		    // "this" should be the larger one if appropriate.
+		    function bnpMultiplyUpperTo(a,n,r) {
+		      --n;
+		      var i = r.t = this.t+a.t-n;
+		      r.s = 0; // assumes a,this >= 0
+		      while(--i >= 0) r[i] = 0;
+		      for(i = Math.max(n-this.t,0); i < a.t; ++i)
+		        r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);
+		      r.clamp();
+		      r.drShiftTo(1,r);
+		    }
+
+		    // Barrett modular reduction
+		    function Barrett(m) {
+		      // setup Barrett
+		      this.r2 = nbi();
+		      this.q3 = nbi();
+		      BigInteger.ONE.dlShiftTo(2*m.t,this.r2);
+		      this.mu = this.r2.divide(m);
+		      this.m = m;
+		    }
+
+		    function barrettConvert(x) {
+		      if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);
+		      else if(x.compareTo(this.m) < 0) return x;
+		      else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }
+		    }
+
+		    function barrettRevert(x) { return x; }
+
+		    // x = x mod m (HAC 14.42)
+		    function barrettReduce(x) {
+		      x.drShiftTo(this.m.t-1,this.r2);
+		      if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }
+		      this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);
+		      this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);
+		      while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);
+		      x.subTo(this.r2,x);
+		      while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+		    }
+
+		    // r = x^2 mod m; x != r
+		    function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+		    // r = x*y mod m; x,y != r
+		    function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+		    Barrett.prototype.convert = barrettConvert;
+		    Barrett.prototype.revert = barrettRevert;
+		    Barrett.prototype.reduce = barrettReduce;
+		    Barrett.prototype.mulTo = barrettMulTo;
+		    Barrett.prototype.sqrTo = barrettSqrTo;
+
+		    // (public) this^e % m (HAC 14.85)
+		    function bnModPow(e,m) {
+		      var i = e.bitLength(), k, r = nbv(1), z;
+		      if(i <= 0) return r;
+		      else if(i < 18) k = 1;
+		      else if(i < 48) k = 3;
+		      else if(i < 144) k = 4;
+		      else if(i < 768) k = 5;
+		      else k = 6;
+		      if(i < 8)
+		        z = new Classic(m);
+		      else if(m.isEven())
+		        z = new Barrett(m);
+		      else
+		        z = new Montgomery(m);
+
+		      // precomputation
+		      var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1;
+		      g[1] = z.convert(this);
+		      if(k > 1) {
+		        var g2 = nbi();
+		        z.sqrTo(g[1],g2);
+		        while(n <= km) {
+		          g[n] = nbi();
+		          z.mulTo(g2,g[n-2],g[n]);
+		          n += 2;
+		        }
+		      }
+
+		      var j = e.t-1, w, is1 = true, r2 = nbi(), t;
+		      i = nbits(e[j])-1;
+		      while(j >= 0) {
+		        if(i >= k1) w = (e[j]>>(i-k1))&km;
+		        else {
+		          w = (e[j]&((1<<(i+1))-1))<<(k1-i);
+		          if(j > 0) w |= e[j-1]>>(this.DB+i-k1);
+		        }
+
+		        n = k;
+		        while((w&1) == 0) { w >>= 1; --n; }
+		        if((i -= n) < 0) { i += this.DB; --j; }
+		        if(is1) {    // ret == 1, don't bother squaring or multiplying it
+		          g[w].copyTo(r);
+		          is1 = false;
+		        }
+		        else {
+		          while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }
+		          if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }
+		          z.mulTo(r2,g[w],r);
+		        }
+
+		        while(j >= 0 && (e[j]&(1<<i)) == 0) {
+		          z.sqrTo(r,r2); t = r; r = r2; r2 = t;
+		          if(--i < 0) { i = this.DB-1; --j; }
+		        }
+		      }
+		      return z.revert(r);
+		    }
+
+		    // (public) gcd(this,a) (HAC 14.54)
+		    function bnGCD(a) {
+		      var x = (this.s<0)?this.negate():this.clone();
+		      var y = (a.s<0)?a.negate():a.clone();
+		      if(x.compareTo(y) < 0) { var t = x; x = y; y = t; }
+		      var i = x.getLowestSetBit(), g = y.getLowestSetBit();
+		      if(g < 0) return x;
+		      if(i < g) g = i;
+		      if(g > 0) {
+		        x.rShiftTo(g,x);
+		        y.rShiftTo(g,y);
+		      }
+		      while(x.signum() > 0) {
+		        if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);
+		        if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);
+		        if(x.compareTo(y) >= 0) {
+		          x.subTo(y,x);
+		          x.rShiftTo(1,x);
+		        }
+		        else {
+		          y.subTo(x,y);
+		          y.rShiftTo(1,y);
+		        }
+		      }
+		      if(g > 0) y.lShiftTo(g,y);
+		      return y;
+		    }
+
+		    // (protected) this % n, n < 2^26
+		    function bnpModInt(n) {
+		      if(n <= 0) return 0;
+		      var d = this.DV%n, r = (this.s<0)?n-1:0;
+		      if(this.t > 0)
+		        if(d == 0) r = this[0]%n;
+		        else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;
+		      return r;
+		    }
+
+		    // (public) 1/this % m (HAC 14.61)
+		    function bnModInverse(m) {
+		      var ac = m.isEven();
+		      if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;
+		      var u = m.clone(), v = this.clone();
+		      var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
+		      while(u.signum() != 0) {
+		        while(u.isEven()) {
+		          u.rShiftTo(1,u);
+		          if(ac) {
+		            if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }
+		            a.rShiftTo(1,a);
+		          }
+		          else if(!b.isEven()) b.subTo(m,b);
+		          b.rShiftTo(1,b);
+		        }
+		        while(v.isEven()) {
+		          v.rShiftTo(1,v);
+		          if(ac) {
+		            if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }
+		            c.rShiftTo(1,c);
+		          }
+		          else if(!d.isEven()) d.subTo(m,d);
+		          d.rShiftTo(1,d);
+		        }
+		        if(u.compareTo(v) >= 0) {
+		          u.subTo(v,u);
+		          if(ac) a.subTo(c,a);
+		          b.subTo(d,b);
+		        }
+		        else {
+		          v.subTo(u,v);
+		          if(ac) c.subTo(a,c);
+		          d.subTo(b,d);
+		        }
+		      }
+		      if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
+		      if(d.compareTo(m) >= 0) return d.subtract(m);
+		      if(d.signum() < 0) d.addTo(m,d); else return d;
+		      if(d.signum() < 0) return d.add(m); else return d;
+		    }
+
+		    var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];
+		    var lplim = (1<<26)/lowprimes[lowprimes.length-1];
+
+		    // (public) test primality with certainty >= 1-.5^t
+		    function bnIsProbablePrime(t) {
+		      var i, x = this.abs();
+		      if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {
+		        for(i = 0; i < lowprimes.length; ++i)
+		          if(x[0] == lowprimes[i]) return true;
+		        return false;
+		      }
+		      if(x.isEven()) return false;
+		      i = 1;
+		      while(i < lowprimes.length) {
+		        var m = lowprimes[i], j = i+1;
+		        while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];
+		        m = x.modInt(m);
+		        while(i < j) if(m%lowprimes[i++] == 0) return false;
+		      }
+		      return x.millerRabin(t);
+		    }
+
+		    // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
+		    function bnpMillerRabin(t) {
+		      var n1 = this.subtract(BigInteger.ONE);
+		      var k = n1.getLowestSetBit();
+		      if(k <= 0) return false;
+		      var r = n1.shiftRight(k);
+		      t = (t+1)>>1;
+		      if(t > lowprimes.length) t = lowprimes.length;
+		      var a = nbi();
+		      for(var i = 0; i < t; ++i) {
+		        //Pick bases at random, instead of starting at 2
+		        a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);
+		        var y = a.modPow(r,this);
+		        if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
+		          var j = 1;
+		          while(j++ < k && y.compareTo(n1) != 0) {
+		            y = y.modPowInt(2,this);
+		            if(y.compareTo(BigInteger.ONE) == 0) return false;
+		          }
+		          if(y.compareTo(n1) != 0) return false;
+		        }
+		      }
+		      return true;
+		    }
+
+		    // protected
+		    BigInteger.prototype.chunkSize = bnpChunkSize;
+		    BigInteger.prototype.toRadix = bnpToRadix;
+		    BigInteger.prototype.fromRadix = bnpFromRadix;
+		    BigInteger.prototype.fromNumber = bnpFromNumber;
+		    BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
+		    BigInteger.prototype.changeBit = bnpChangeBit;
+		    BigInteger.prototype.addTo = bnpAddTo;
+		    BigInteger.prototype.dMultiply = bnpDMultiply;
+		    BigInteger.prototype.dAddOffset = bnpDAddOffset;
+		    BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
+		    BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
+		    BigInteger.prototype.modInt = bnpModInt;
+		    BigInteger.prototype.millerRabin = bnpMillerRabin;
+
+		    // public
+		    BigInteger.prototype.clone = bnClone;
+		    BigInteger.prototype.intValue = bnIntValue;
+		    BigInteger.prototype.byteValue = bnByteValue;
+		    BigInteger.prototype.shortValue = bnShortValue;
+		    BigInteger.prototype.signum = bnSigNum;
+		    BigInteger.prototype.toByteArray = bnToByteArray;
+		    BigInteger.prototype.equals = bnEquals;
+		    BigInteger.prototype.min = bnMin;
+		    BigInteger.prototype.max = bnMax;
+		    BigInteger.prototype.and = bnAnd;
+		    BigInteger.prototype.or = bnOr;
+		    BigInteger.prototype.xor = bnXor;
+		    BigInteger.prototype.andNot = bnAndNot;
+		    BigInteger.prototype.not = bnNot;
+		    BigInteger.prototype.shiftLeft = bnShiftLeft;
+		    BigInteger.prototype.shiftRight = bnShiftRight;
+		    BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
+		    BigInteger.prototype.bitCount = bnBitCount;
+		    BigInteger.prototype.testBit = bnTestBit;
+		    BigInteger.prototype.setBit = bnSetBit;
+		    BigInteger.prototype.clearBit = bnClearBit;
+		    BigInteger.prototype.flipBit = bnFlipBit;
+		    BigInteger.prototype.add = bnAdd;
+		    BigInteger.prototype.subtract = bnSubtract;
+		    BigInteger.prototype.multiply = bnMultiply;
+		    BigInteger.prototype.divide = bnDivide;
+		    BigInteger.prototype.remainder = bnRemainder;
+		    BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
+		    BigInteger.prototype.modPow = bnModPow;
+		    BigInteger.prototype.modInverse = bnModInverse;
+		    BigInteger.prototype.pow = bnPow;
+		    BigInteger.prototype.gcd = bnGCD;
+		    BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
+
+		    // JSBN-specific extension
+		    BigInteger.prototype.square = bnSquare;
+
+		    // Expose the Barrett function
+		    BigInteger.prototype.Barrett = Barrett;
+
+		    // BigInteger interfaces not implemented in jsbn:
+
+		    // BigInteger(int signum, byte[] magnitude)
+		    // double doubleValue()
+		    // float floatValue()
+		    // int hashCode()
+		    // long longValue()
+		    // static BigInteger valueOf(long val)
+
+		    // Random number generator - requires a PRNG backend, e.g. prng4.js
+
+		    // For best results, put code like
+		    // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>
+		    // in your main HTML document.
+
+		    var rng_state;
+		    var rng_pool;
+		    var rng_pptr;
+
+		    // Mix in a 32-bit integer into the pool
+		    function rng_seed_int(x) {
+		      rng_pool[rng_pptr++] ^= x & 255;
+		      rng_pool[rng_pptr++] ^= (x >> 8) & 255;
+		      rng_pool[rng_pptr++] ^= (x >> 16) & 255;
+		      rng_pool[rng_pptr++] ^= (x >> 24) & 255;
+		      if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;
+		    }
+
+		    // Mix in the current time (w/milliseconds) into the pool
+		    function rng_seed_time() {
+		      rng_seed_int(new Date().getTime());
+		    }
+
+		    // Initialize the pool with junk if needed.
+		    if(rng_pool == null) {
+		      rng_pool = new Array();
+		      rng_pptr = 0;
+		      var t;
+		      if(typeof window !== "undefined" && window.crypto) {
+		        if (window.crypto.getRandomValues) {
+		          // Use webcrypto if available
+		          var ua = new Uint8Array(32);
+		          window.crypto.getRandomValues(ua);
+		          for(t = 0; t < 32; ++t)
+		            rng_pool[rng_pptr++] = ua[t];
+		        }
+		        else if(navigator.appName == "Netscape" && navigator.appVersion < "5") {
+		          // Extract entropy (256 bits) from NS4 RNG if available
+		          var z = window.crypto.random(32);
+		          for(t = 0; t < z.length; ++t)
+		            rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
+		        }
+		      }
+		      while(rng_pptr < rng_psize) {  // extract some randomness from Math.random()
+		        t = Math.floor(65536 * Math.random());
+		        rng_pool[rng_pptr++] = t >>> 8;
+		        rng_pool[rng_pptr++] = t & 255;
+		      }
+		      rng_pptr = 0;
+		      rng_seed_time();
+		      //rng_seed_int(window.screenX);
+		      //rng_seed_int(window.screenY);
+		    }
+
+		    function rng_get_byte() {
+		      if(rng_state == null) {
+		        rng_seed_time();
+		        rng_state = prng_newstate();
+		        rng_state.init(rng_pool);
+		        for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
+		          rng_pool[rng_pptr] = 0;
+		        rng_pptr = 0;
+		        //rng_pool = null;
+		      }
+		      // TODO: allow reseeding after first request
+		      return rng_state.next();
+		    }
+
+		    function rng_get_bytes(ba) {
+		      var i;
+		      for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();
+		    }
+
+		    function SecureRandom() {}
+
+		    SecureRandom.prototype.nextBytes = rng_get_bytes;
+
+		    // prng4.js - uses Arcfour as a PRNG
+
+		    function Arcfour() {
+		      this.i = 0;
+		      this.j = 0;
+		      this.S = new Array();
+		    }
+
+		    // Initialize arcfour context from key, an array of ints, each from [0..255]
+		    function ARC4init(key) {
+		      var i, j, t;
+		      for(i = 0; i < 256; ++i)
+		        this.S[i] = i;
+		      j = 0;
+		      for(i = 0; i < 256; ++i) {
+		        j = (j + this.S[i] + key[i % key.length]) & 255;
+		        t = this.S[i];
+		        this.S[i] = this.S[j];
+		        this.S[j] = t;
+		      }
+		      this.i = 0;
+		      this.j = 0;
+		    }
+
+		    function ARC4next() {
+		      var t;
+		      this.i = (this.i + 1) & 255;
+		      this.j = (this.j + this.S[this.i]) & 255;
+		      t = this.S[this.i];
+		      this.S[this.i] = this.S[this.j];
+		      this.S[this.j] = t;
+		      return this.S[(t + this.S[this.i]) & 255];
+		    }
+
+		    Arcfour.prototype.init = ARC4init;
+		    Arcfour.prototype.next = ARC4next;
+
+		    // Plug in your RNG constructor here
+		    function prng_newstate() {
+		      return new Arcfour();
+		    }
+
+		    // Pool size must be a multiple of 4 and greater than 32.
+		    // An array of bytes the size of the pool will be passed to init()
+		    var rng_psize = 256;
+
+		    {
+		        module.exports = {
+		            default: BigInteger,
+		            BigInteger: BigInteger,
+		            SecureRandom: SecureRandom,
+		        };
+		    }
+
+		}).call(jsbn); 
+	} (jsbn$1));
+	return jsbn$1.exports;
+}
+
+var asn1;
+var hasRequiredAsn1;
+function requireAsn1() {
+  if (hasRequiredAsn1) return asn1;
+  hasRequiredAsn1 = 1;
+  var _require$$ = requireJsbn(),
+    BigInteger = _require$$.BigInteger;
+  function bigintToValue(bigint) {
+    var h = bigint.toString(16);
+    if (h[0] !== '-') {
+      // 正数
+      if (h.length % 2 === 1) h = '0' + h; // 补齐到整字节
+      else if (!h.match(/^[0-7]/)) h = '00' + h; // 非0开头，则补一个全0字节
+    } else {
+      // 负数
+      h = h.substr(1);
+      var len = h.length;
+      if (len % 2 === 1) len += 1; // 补齐到整字节
+      else if (!h.match(/^[0-7]/)) len += 2; // 非0开头，则补一个全0字节
+
+      var mask = '';
+      for (var i = 0; i < len; i++) mask += 'f';
+      mask = new BigInteger(mask, 16);
+
+      // 对绝对值取反，加1
+      h = mask.xor(bigint).add(BigInteger.ONE);
+      h = h.toString(16).replace(/^-/, '');
+    }
+    return h;
+  }
+  var ASN1Object = /*#__PURE__*/function () {
+    function ASN1Object() {
+      _classCallCheck(this, ASN1Object);
+      this.tlv = null;
+      this.t = '00';
+      this.l = '00';
+      this.v = '';
+    }
+
+    /**
+     * 获取 der 编码比特流16进制串
+     */
+    return _createClass(ASN1Object, [{
+      key: "getEncodedHex",
+      value: function getEncodedHex() {
+        if (!this.tlv) {
+          this.v = this.getValue();
+          this.l = this.getLength();
+          this.tlv = this.t + this.l + this.v;
+        }
+        return this.tlv;
+      }
+    }, {
+      key: "getLength",
+      value: function getLength() {
+        var n = this.v.length / 2; // 字节数
+        var nHex = n.toString(16);
+        if (nHex.length % 2 === 1) nHex = '0' + nHex; // 补齐到整字节
+
+        if (n < 128) {
+          // 短格式，以 0 开头
+          return nHex;
+        } else {
+          // 长格式，以 1 开头
+          var head = 128 + nHex.length / 2; // 1(1位) + 真正的长度占用字节数(7位) + 真正的长度
+          return head.toString(16) + nHex;
+        }
+      }
+    }, {
+      key: "getValue",
+      value: function getValue() {
+        return '';
+      }
+    }]);
+  }();
+  var DERInteger = /*#__PURE__*/function (_ASN1Object) {
+    function DERInteger(bigint) {
+      var _this;
+      _classCallCheck(this, DERInteger);
+      _this = _callSuper(this, DERInteger);
+      _this.t = '02'; // 整型标签说明
+      if (bigint) _this.v = bigintToValue(bigint);
+      return _this;
+    }
+    _inherits(DERInteger, _ASN1Object);
+    return _createClass(DERInteger, [{
+      key: "getValue",
+      value: function getValue() {
+        return this.v;
+      }
+    }]);
+  }(ASN1Object);
+  var DERSequence = /*#__PURE__*/function (_ASN1Object2) {
+    function DERSequence(asn1Array) {
+      var _this2;
+      _classCallCheck(this, DERSequence);
+      _this2 = _callSuper(this, DERSequence);
+      _this2.t = '30'; // 序列标签说明
+      _this2.asn1Array = asn1Array;
+      return _this2;
+    }
+    _inherits(DERSequence, _ASN1Object2);
+    return _createClass(DERSequence, [{
+      key: "getValue",
+      value: function getValue() {
+        this.v = this.asn1Array.map(function (asn1Object) {
+          return asn1Object.getEncodedHex();
+        }).join('');
+        return this.v;
+      }
+    }]);
+  }(ASN1Object);
+  /**
+   * 获取 l 占用字节数
+   */
+  function getLenOfL(str, start) {
+    if (+str[start + 2] < 8) return 1; // l 以0开头，则表示短格式，只占一个字节
+    return +str.substr(start + 2, 2) & 0x7f + 1; // 长格式，取第一个字节后7位作为长度真正占用字节数，再加上本身
+  }
+
+  /**
+   * 获取 l
+   */
+  function getL(str, start) {
+    // 获取 l
+    var len = getLenOfL(str, start);
+    var l = str.substr(start + 2, len * 2);
+    if (!l) return -1;
+    var bigint = +l[0] < 8 ? new BigInteger(l, 16) : new BigInteger(l.substr(2), 16);
+    return bigint.intValue();
+  }
+
+  /**
+   * 获取 v 的位置
+   */
+  function getStartOfV(str, start) {
+    var len = getLenOfL(str, start);
+    return start + (len + 1) * 2;
+  }
+  asn1 = {
+    /**
+     * ASN.1 der 编码，针对 sm2 签名
+     */
+    encodeDer: function encodeDer(r, s) {
+      var derR = new DERInteger(r);
+      var derS = new DERInteger(s);
+      var derSeq = new DERSequence([derR, derS]);
+      return derSeq.getEncodedHex();
+    },
+    /**
+     * 解析 ASN.1 der，针对 sm2 验签
+     */
+    decodeDer: function decodeDer(input) {
+      // 结构：
+      // input = | tSeq | lSeq | vSeq |
+      // vSeq = | tR | lR | vR | tS | lS | vS |
+      var start = getStartOfV(input, 0);
+      var vIndexR = getStartOfV(input, start);
+      var lR = getL(input, start);
+      var vR = input.substr(vIndexR, lR * 2);
+      var nextStart = vIndexR + vR.length;
+      var vIndexS = getStartOfV(input, nextStart);
+      var lS = getL(input, nextStart);
+      var vS = input.substr(vIndexS, lS * 2);
+      var r = new BigInteger(vR, 16);
+      var s = new BigInteger(vS, 16);
+      return {
+        r: r,
+        s: s
+      };
+    }
+  };
+  return asn1;
+}
+
+var ec;
+var hasRequiredEc;
+function requireEc() {
+  if (hasRequiredEc) return ec;
+  hasRequiredEc = 1;
+  var _require$$ = requireJsbn(),
+    BigInteger = _require$$.BigInteger;
+
+  /**
+   * thanks for Tom Wu : http://www-cs-students.stanford.edu/~tjw/jsbn/
+   *
+   * Basic Javascript Elliptic Curve implementation
+   * Ported loosely from BouncyCastle's Java EC code
+   * Only Fp curves implemented for now
+   */
+
+  var TWO = new BigInteger('2');
+  var THREE = new BigInteger('3');
+
+  /**
+   * 椭圆曲线域元素
+   */
+  var ECFieldElementFp = /*#__PURE__*/function () {
+    function ECFieldElementFp(q, x) {
+      _classCallCheck(this, ECFieldElementFp);
+      this.x = x;
+      this.q = q;
+      // TODO if (x.compareTo(q) >= 0) error
+    }
+
+    /**
+     * 判断相等
+     */
+    return _createClass(ECFieldElementFp, [{
+      key: "equals",
+      value: function equals(other) {
+        if (other === this) return true;
+        return this.q.equals(other.q) && this.x.equals(other.x);
+      }
+
+      /**
+       * 返回具体数值
+       */
+    }, {
+      key: "toBigInteger",
+      value: function toBigInteger() {
+        return this.x;
+      }
+
+      /**
+       * 取反
+       */
+    }, {
+      key: "negate",
+      value: function negate() {
+        return new ECFieldElementFp(this.q, this.x.negate().mod(this.q));
+      }
+
+      /**
+       * 相加
+       */
+    }, {
+      key: "add",
+      value: function add(b) {
+        return new ECFieldElementFp(this.q, this.x.add(b.toBigInteger()).mod(this.q));
+      }
+
+      /**
+       * 相减
+       */
+    }, {
+      key: "subtract",
+      value: function subtract(b) {
+        return new ECFieldElementFp(this.q, this.x.subtract(b.toBigInteger()).mod(this.q));
+      }
+
+      /**
+       * 相乘
+       */
+    }, {
+      key: "multiply",
+      value: function multiply(b) {
+        return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger()).mod(this.q));
+      }
+
+      /**
+       * 相除
+       */
+    }, {
+      key: "divide",
+      value: function divide(b) {
+        return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger().modInverse(this.q)).mod(this.q));
+      }
+
+      /**
+       * 平方
+       */
+    }, {
+      key: "square",
+      value: function square() {
+        return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
+      }
+    }]);
+  }();
+  var ECPointFp = /*#__PURE__*/function () {
+    function ECPointFp(curve, x, y, z) {
+      _classCallCheck(this, ECPointFp);
+      this.curve = curve;
+      this.x = x;
+      this.y = y;
+      // 标准射影坐标系：zinv == null 或 z * zinv == 1
+      this.z = z == null ? BigInteger.ONE : z;
+      this.zinv = null;
+      // TODO: compression flag
+    }
+    return _createClass(ECPointFp, [{
+      key: "getX",
+      value: function getX() {
+        if (this.zinv === null) this.zinv = this.z.modInverse(this.curve.q);
+        return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q));
+      }
+    }, {
+      key: "getY",
+      value: function getY() {
+        if (this.zinv === null) this.zinv = this.z.modInverse(this.curve.q);
+        return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q));
+      }
+
+      /**
+       * 判断相等
+       */
+    }, {
+      key: "equals",
+      value: function equals(other) {
+        if (other === this) return true;
+        if (this.isInfinity()) return other.isInfinity();
+        if (other.isInfinity()) return this.isInfinity();
+
+        // u = y2 * z1 - y1 * z2
+        var u = other.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(other.z)).mod(this.curve.q);
+        if (!u.equals(BigInteger.ZERO)) return false;
+
+        // v = x2 * z1 - x1 * z2
+        var v = other.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(other.z)).mod(this.curve.q);
+        return v.equals(BigInteger.ZERO);
+      }
+
+      /**
+       * 是否是无穷远点
+       */
+    }, {
+      key: "isInfinity",
+      value: function isInfinity() {
+        if (this.x === null && this.y === null) return true;
+        return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO);
+      }
+
+      /**
+       * 取反，x 轴对称点
+       */
+    }, {
+      key: "negate",
+      value: function negate() {
+        return new ECPointFp(this.curve, this.x, this.y.negate(), this.z);
+      }
+
+      /**
+       * 相加
+       *
+       * 标准射影坐标系：
+       *
+       * λ1 = x1 * z2
+       * λ2 = x2 * z1
+       * λ3 = λ1 − λ2
+       * λ4 = y1 * z2
+       * λ5 = y2 * z1
+       * λ6 = λ4 − λ5
+       * λ7 = λ1 + λ2
+       * λ8 = z1 * z2
+       * λ9 = λ3^2
+       * λ10 = λ3 * λ9
+       * λ11 = λ8 * λ6^2 − λ7 * λ9
+       * x3 = λ3 * λ11
+       * y3 = λ6 * (λ9 * λ1 − λ11) − λ4 * λ10
+       * z3 = λ10 * λ8
+       */
+    }, {
+      key: "add",
+      value: function add(b) {
+        if (this.isInfinity()) return b;
+        if (b.isInfinity()) return this;
+        var x1 = this.x.toBigInteger();
+        var y1 = this.y.toBigInteger();
+        var z1 = this.z;
+        var x2 = b.x.toBigInteger();
+        var y2 = b.y.toBigInteger();
+        var z2 = b.z;
+        var q = this.curve.q;
+        var w1 = x1.multiply(z2).mod(q);
+        var w2 = x2.multiply(z1).mod(q);
+        var w3 = w1.subtract(w2);
+        var w4 = y1.multiply(z2).mod(q);
+        var w5 = y2.multiply(z1).mod(q);
+        var w6 = w4.subtract(w5);
+        if (BigInteger.ZERO.equals(w3)) {
+          if (BigInteger.ZERO.equals(w6)) {
+            return this.twice(); // this == b，计算自加
+          }
+          return this.curve.infinity; // this == -b，则返回无穷远点
+        }
+        var w7 = w1.add(w2);
+        var w8 = z1.multiply(z2).mod(q);
+        var w9 = w3.square().mod(q);
+        var w10 = w3.multiply(w9).mod(q);
+        var w11 = w8.multiply(w6.square()).subtract(w7.multiply(w9)).mod(q);
+        var x3 = w3.multiply(w11).mod(q);
+        var y3 = w6.multiply(w9.multiply(w1).subtract(w11)).subtract(w4.multiply(w10)).mod(q);
+        var z3 = w10.multiply(w8).mod(q);
+        return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3);
+      }
+
+      /**
+       * 自加
+       *
+       * 标准射影坐标系：
+       *
+       * λ1 = 3 * x1^2 + a * z1^2
+       * λ2 = 2 * y1 * z1
+       * λ3 = y1^2
+       * λ4 = λ3 * x1 * z1
+       * λ5 = λ2^2
+       * λ6 = λ1^2 − 8 * λ4
+       * x3 = λ2 * λ6
+       * y3 = λ1 * (4 * λ4 − λ6) − 2 * λ5 * λ3
+       * z3 = λ2 * λ5
+       */
+    }, {
+      key: "twice",
+      value: function twice() {
+        if (this.isInfinity()) return this;
+        if (!this.y.toBigInteger().signum()) return this.curve.infinity;
+        var x1 = this.x.toBigInteger();
+        var y1 = this.y.toBigInteger();
+        var z1 = this.z;
+        var q = this.curve.q;
+        var a = this.curve.a.toBigInteger();
+        var w1 = x1.square().multiply(THREE).add(a.multiply(z1.square())).mod(q);
+        var w2 = y1.shiftLeft(1).multiply(z1).mod(q);
+        var w3 = y1.square().mod(q);
+        var w4 = w3.multiply(x1).multiply(z1).mod(q);
+        var w5 = w2.square().mod(q);
+        var w6 = w1.square().subtract(w4.shiftLeft(3)).mod(q);
+        var x3 = w2.multiply(w6).mod(q);
+        var y3 = w1.multiply(w4.shiftLeft(2).subtract(w6)).subtract(w5.shiftLeft(1).multiply(w3)).mod(q);
+        var z3 = w2.multiply(w5).mod(q);
+        return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3);
+      }
+
+      /**
+       * 倍点计算
+       */
+    }, {
+      key: "multiply",
+      value: function multiply(k) {
+        if (this.isInfinity()) return this;
+        if (!k.signum()) return this.curve.infinity;
+
+        // 使用加减法
+        var k3 = k.multiply(THREE);
+        var neg = this.negate();
+        var Q = this;
+        for (var i = k3.bitLength() - 2; i > 0; i--) {
+          Q = Q.twice();
+          var k3Bit = k3.testBit(i);
+          var kBit = k.testBit(i);
+          if (k3Bit !== kBit) {
+            Q = Q.add(k3Bit ? this : neg);
+          }
+        }
+        return Q;
+      }
+    }]);
+  }();
+  /**
+   * 椭圆曲线 y^2 = x^3 + ax + b
+   */
+  var ECCurveFp = /*#__PURE__*/function () {
+    function ECCurveFp(q, a, b) {
+      _classCallCheck(this, ECCurveFp);
+      this.q = q;
+      this.a = this.fromBigInteger(a);
+      this.b = this.fromBigInteger(b);
+      this.infinity = new ECPointFp(this, null, null); // 无穷远点
+    }
+
+    /**
+     * 判断两个椭圆曲线是否相等
+     */
+    return _createClass(ECCurveFp, [{
+      key: "equals",
+      value: function equals(other) {
+        if (other === this) return true;
+        return this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b);
+      }
+
+      /**
+       * 生成椭圆曲线域元素
+       */
+    }, {
+      key: "fromBigInteger",
+      value: function fromBigInteger(x) {
+        return new ECFieldElementFp(this.q, x);
+      }
+
+      /**
+       * 解析 16 进制串为椭圆曲线点
+       */
+    }, {
+      key: "decodePointHex",
+      value: function decodePointHex(s) {
+        switch (parseInt(s.substr(0, 2), 16)) {
+          // 第一个字节
+          case 0:
+            return this.infinity;
+          case 2:
+          case 3:
+            // 压缩
+            var x = this.fromBigInteger(new BigInteger(s.substr(2), 16));
+            // 对 p ≡ 3 (mod4)，即存在正整数 u，使得 p = 4u + 3
+            // 计算 y = (√ (x^3 + ax + b) % p)^(u + 1) modp
+            var y = this.fromBigInteger(x.multiply(x.square()).add(x.multiply(this.a)).add(this.b).toBigInteger().modPow(this.q.divide(new BigInteger('4')).add(BigInteger.ONE), this.q));
+            // 算出结果 2 进制最后 1 位不等于第 1 个字节减 2 则取反
+            if (!y.toBigInteger().mod(TWO).equals(new BigInteger(s.substr(0, 2), 16).subtract(TWO))) {
+              y = y.negate();
+            }
+            return new ECPointFp(this, x, y);
+          case 4:
+          case 6:
+          case 7:
+            var len = (s.length - 2) / 2;
+            var xHex = s.substr(2, len);
+            var yHex = s.substr(len + 2, len);
+            return new ECPointFp(this, this.fromBigInteger(new BigInteger(xHex, 16)), this.fromBigInteger(new BigInteger(yHex, 16)));
+          default:
+            // 不支持
+            return null;
+        }
+      }
+    }]);
+  }();
+  ec = {
+    ECPointFp: ECPointFp,
+    ECCurveFp: ECCurveFp
+  };
+  return ec;
+}
+
+/* eslint-disable no-bitwise, no-mixed-operators, no-use-before-define, max-len */
+var utils;
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  var _require$$ = requireJsbn(),
+    BigInteger = _require$$.BigInteger,
+    SecureRandom = _require$$.SecureRandom;
+  var _require$$2 = requireEc(),
+    ECCurveFp = _require$$2.ECCurveFp;
+  var rng = new SecureRandom();
+  var _generateEcparam = generateEcparam(),
+    curve = _generateEcparam.curve,
+    G = _generateEcparam.G,
+    n = _generateEcparam.n;
+
+  /**
+   * 获取公共椭圆曲线
+   */
+  function getGlobalCurve() {
+    return curve;
+  }
+
+  /**
+   * 生成ecparam
+   */
+  function generateEcparam() {
+    // 椭圆曲线
+    var p = new BigInteger('FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF', 16);
+    var a = new BigInteger('FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC', 16);
+    var b = new BigInteger('28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93', 16);
+    var curve = new ECCurveFp(p, a, b);
+
+    // 基点
+    var gxHex = '32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7';
+    var gyHex = 'BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0';
+    var G = curve.decodePointHex('04' + gxHex + gyHex);
+    var n = new BigInteger('FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123', 16);
+    return {
+      curve: curve,
+      G: G,
+      n: n
+    };
+  }
+
+  /**
+   * 生成密钥对：publicKey = privateKey * G
+   */
+  function generateKeyPairHex(a, b, c) {
+    var random = a ? new BigInteger(a, b, c) : new BigInteger(n.bitLength(), rng);
+    var d = random.mod(n.subtract(BigInteger.ONE)).add(BigInteger.ONE); // 随机数
+    var privateKey = leftPad(d.toString(16), 64);
+    var P = G.multiply(d); // P = dG，p 为公钥，d 为私钥
+    var Px = leftPad(P.getX().toBigInteger().toString(16), 64);
+    var Py = leftPad(P.getY().toBigInteger().toString(16), 64);
+    var publicKey = '04' + Px + Py;
+    return {
+      privateKey: privateKey,
+      publicKey: publicKey
+    };
+  }
+
+  /**
+   * 生成压缩公钥
+   */
+  function compressPublicKeyHex(s) {
+    if (s.length !== 130) throw new Error('Invalid public key to compress');
+    var len = (s.length - 2) / 2;
+    var xHex = s.substr(2, len);
+    var y = new BigInteger(s.substr(len + 2, len), 16);
+    var prefix = '03';
+    if (y.mod(new BigInteger('2')).equals(BigInteger.ZERO)) prefix = '02';
+    return prefix + xHex;
+  }
+
+  /**
+   * utf8串转16进制串
+   */
+  function utf8ToHex(input) {
+    input = unescape(encodeURIComponent(input));
+    var length = input.length;
+
+    // 转换到字数组
+    var words = [];
+    for (var i = 0; i < length; i++) {
+      words[i >>> 2] |= (input.charCodeAt(i) & 0xff) << 24 - i % 4 * 8;
+    }
+
+    // 转换到16进制
+    var hexChars = [];
+    for (var _i = 0; _i < length; _i++) {
+      var bite = words[_i >>> 2] >>> 24 - _i % 4 * 8 & 0xff;
+      hexChars.push((bite >>> 4).toString(16));
+      hexChars.push((bite & 0x0f).toString(16));
+    }
+    return hexChars.join('');
+  }
+
+  /**
+   * 补全16进制字符串
+   */
+  function leftPad(input, num) {
+    if (input.length >= num) return input;
+    return new Array(num - input.length + 1).join('0') + input;
+  }
+
+  /**
+   * 转成16进制串
+   */
+  function arrayToHex(arr) {
+    return arr.map(function (item) {
+      item = item.toString(16);
+      return item.length === 1 ? '0' + item : item;
+    }).join('');
+  }
+
+  /**
+   * 转成utf8串
+   */
+  function arrayToUtf8(arr) {
+    var words = [];
+    var j = 0;
+    for (var i = 0; i < arr.length * 2; i += 2) {
+      words[i >>> 3] |= parseInt(arr[j], 10) << 24 - i % 8 * 4;
+      j++;
+    }
+    try {
+      var latin1Chars = [];
+      for (var _i2 = 0; _i2 < arr.length; _i2++) {
+        var bite = words[_i2 >>> 2] >>> 24 - _i2 % 4 * 8 & 0xff;
+        latin1Chars.push(String.fromCharCode(bite));
+      }
+      return decodeURIComponent(escape(latin1Chars.join('')));
+    } catch (e) {
+      throw new Error('Malformed UTF-8 data');
+    }
+  }
+
+  /**
+   * 转成字节数组
+   */
+  function hexToArray(hexStr) {
+    var words = [];
+    var hexStrLength = hexStr.length;
+    if (hexStrLength % 2 !== 0) {
+      hexStr = leftPad(hexStr, hexStrLength + 1);
+    }
+    hexStrLength = hexStr.length;
+    for (var i = 0; i < hexStrLength; i += 2) {
+      words.push(parseInt(hexStr.substr(i, 2), 16));
+    }
+    return words;
+  }
+
+  /**
+   * 验证公钥是否为椭圆曲线上的点
+   */
+  function verifyPublicKey(publicKey) {
+    var point = curve.decodePointHex(publicKey);
+    if (!point) return false;
+    var x = point.getX();
+    var y = point.getY();
+
+    // 验证 y^2 是否等于 x^3 + ax + b
+    return y.square().equals(x.multiply(x.square()).add(x.multiply(curve.a)).add(curve.b));
+  }
+
+  /**
+   * 验证公钥是否等价，等价返回true
+   */
+  function comparePublicKeyHex(publicKey1, publicKey2) {
+    var point1 = curve.decodePointHex(publicKey1);
+    if (!point1) return false;
+    var point2 = curve.decodePointHex(publicKey2);
+    if (!point2) return false;
+    return point1.equals(point2);
+  }
+  utils = {
+    getGlobalCurve: getGlobalCurve,
+    generateEcparam: generateEcparam,
+    generateKeyPairHex: generateKeyPairHex,
+    compressPublicKeyHex: compressPublicKeyHex,
+    utf8ToHex: utf8ToHex,
+    leftPad: leftPad,
+    arrayToHex: arrayToHex,
+    arrayToUtf8: arrayToUtf8,
+    hexToArray: hexToArray,
+    verifyPublicKey: verifyPublicKey,
+    comparePublicKeyHex: comparePublicKeyHex
+  };
+  return utils;
+}
+
+var sm3_1$1;
+var hasRequiredSm3$1;
+function requireSm3$1() {
+  if (hasRequiredSm3$1) return sm3_1$1;
+  hasRequiredSm3$1 = 1;
+  // 消息扩展
+  var W = new Uint32Array(68);
+  var M = new Uint32Array(64); // W'
+
+  /**
+   * 循环左移
+   */
+  function rotl(x, n) {
+    var s = n & 31;
+    return x << s | x >>> 32 - s;
+  }
+
+  /**
+   * 二进制异或运算
+   */
+  function xor(x, y) {
+    var result = [];
+    for (var i = x.length - 1; i >= 0; i--) result[i] = (x[i] ^ y[i]) & 0xff;
+    return result;
+  }
+
+  /**
+   * 压缩函数中的置换函数 P0(X) = X xor (X <<< 9) xor (X <<< 17)
+   */
+  function P0(X) {
+    return X ^ rotl(X, 9) ^ rotl(X, 17);
+  }
+
+  /**
+   * 消息扩展中的置换函数 P1(X) = X xor (X <<< 15) xor (X <<< 23)
+   */
+  function P1(X) {
+    return X ^ rotl(X, 15) ^ rotl(X, 23);
+  }
+
+  /**
+   * sm3 本体
+   */
+  function sm3(array) {
+    var len = array.length * 8;
+
+    // k 是满足 len + 1 + k = 448mod512 的最小的非负整数
+    var k = len % 512;
+    // 如果 448 <= (512 % len) < 512，需要多补充 (len % 448) 比特'0'以满足总比特长度为512的倍数
+    k = k >= 448 ? 512 - k % 448 - 1 : 448 - k - 1;
+
+    // 填充
+    var kArr = new Array((k - 7) / 8);
+    var lenArr = new Array(8);
+    for (var i = 0, _len = kArr.length; i < _len; i++) kArr[i] = 0;
+    for (var _i = 0, _len2 = lenArr.length; _i < _len2; _i++) lenArr[_i] = 0;
+    len = len.toString(2);
+    for (var _i2 = 7; _i2 >= 0; _i2--) {
+      if (len.length > 8) {
+        var start = len.length - 8;
+        lenArr[_i2] = parseInt(len.substr(start), 2);
+        len = len.substr(0, start);
+      } else if (len.length > 0) {
+        lenArr[_i2] = parseInt(len, 2);
+        len = '';
+      }
+    }
+    var m = new Uint8Array([].concat(_toConsumableArray(array), [0x80], kArr, lenArr));
+    var dataView = new DataView(m.buffer, 0);
+
+    // 迭代压缩
+    var n = m.length / 64;
+    var V = new Uint32Array([0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e]);
+    for (var _i3 = 0; _i3 < n; _i3++) {
+      W.fill(0);
+      M.fill(0);
+
+      // 将消息分组B划分为 16 个字 W0， W1，……，W15
+      var _start = 16 * _i3;
+      for (var j = 0; j < 16; j++) {
+        W[j] = dataView.getUint32((_start + j) * 4, false);
+      }
+
+      // W16 ～ W67：W[j] <- P1(W[j−16] xor W[j−9] xor (W[j−3] <<< 15)) xor (W[j−13] <<< 7) xor W[j−6]
+      for (var _j = 16; _j < 68; _j++) {
+        W[_j] = P1(W[_j - 16] ^ W[_j - 9] ^ rotl(W[_j - 3], 15)) ^ rotl(W[_j - 13], 7) ^ W[_j - 6];
+      }
+
+      // W′0 ～ W′63：W′[j] = W[j] xor W[j+4]
+      for (var _j2 = 0; _j2 < 64; _j2++) {
+        M[_j2] = W[_j2] ^ W[_j2 + 4];
+      }
+
+      // 压缩
+      var T1 = 0x79cc4519;
+      var T2 = 0x7a879d8a;
+      // 字寄存器
+      var A = V[0];
+      var B = V[1];
+      var C = V[2];
+      var D = V[3];
+      var E = V[4];
+      var F = V[5];
+      var G = V[6];
+      var H = V[7];
+      // 中间变量
+      var SS1 = void 0;
+      var SS2 = void 0;
+      var TT1 = void 0;
+      var TT2 = void 0;
+      var T = void 0;
+      for (var _j3 = 0; _j3 < 64; _j3++) {
+        T = _j3 >= 0 && _j3 <= 15 ? T1 : T2;
+        SS1 = rotl(rotl(A, 12) + E + rotl(T, _j3), 7);
+        SS2 = SS1 ^ rotl(A, 12);
+        TT1 = (_j3 >= 0 && _j3 <= 15 ? A ^ B ^ C : A & B | A & C | B & C) + D + SS2 + M[_j3];
+        TT2 = (_j3 >= 0 && _j3 <= 15 ? E ^ F ^ G : E & F | ~E & G) + H + SS1 + W[_j3];
+        D = C;
+        C = rotl(B, 9);
+        B = A;
+        A = TT1;
+        H = G;
+        G = rotl(F, 19);
+        F = E;
+        E = P0(TT2);
+      }
+      V[0] ^= A;
+      V[1] ^= B;
+      V[2] ^= C;
+      V[3] ^= D;
+      V[4] ^= E;
+      V[5] ^= F;
+      V[6] ^= G;
+      V[7] ^= H;
+    }
+
+    // 转回 uint8
+    var result = [];
+    for (var _i4 = 0, _len3 = V.length; _i4 < _len3; _i4++) {
+      var word = V[_i4];
+      result.push((word & 0xff000000) >>> 24, (word & 0xff0000) >>> 16, (word & 0xff00) >>> 8, word & 0xff);
+    }
+    return result;
+  }
+
+  /**
+   * hmac 实现
+   */
+  var blockLen = 64;
+  var iPad = new Uint8Array(blockLen);
+  var oPad = new Uint8Array(blockLen);
+  for (var i = 0; i < blockLen; i++) {
+    iPad[i] = 0x36;
+    oPad[i] = 0x5c;
+  }
+  function hmac(input, key) {
+    // 密钥填充
+    if (key.length > blockLen) key = sm3(key);
+    while (key.length < blockLen) key.push(0);
+    var iPadKey = xor(key, iPad);
+    var oPadKey = xor(key, oPad);
+    var hash = sm3([].concat(_toConsumableArray(iPadKey), _toConsumableArray(input)));
+    return sm3([].concat(_toConsumableArray(oPadKey), _toConsumableArray(hash)));
+  }
+  sm3_1$1 = {
+    sm3: sm3,
+    hmac: hmac
+  };
+  return sm3_1$1;
+}
+
+var sm2;
+var hasRequiredSm2;
+function requireSm2() {
+  if (hasRequiredSm2) return sm2;
+  hasRequiredSm2 = 1;
+  var _require$$ = requireJsbn(),
+    BigInteger = _require$$.BigInteger;
+  var _require$$2 = requireAsn1(),
+    encodeDer = _require$$2.encodeDer,
+    decodeDer = _require$$2.decodeDer;
+  var _ = requireUtils();
+  var sm3 = requireSm3$1().sm3;
+  var _$generateEcparam = _.generateEcparam(),
+    G = _$generateEcparam.G,
+    curve = _$generateEcparam.curve,
+    n = _$generateEcparam.n;
+  var C1C2C3 = 0;
+
+  /**
+   * 加密
+   */
+  function doEncrypt(msg, publicKey) {
+    var cipherMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    msg = typeof msg === 'string' ? _.hexToArray(_.utf8ToHex(msg)) : Array.prototype.slice.call(msg);
+    publicKey = _.getGlobalCurve().decodePointHex(publicKey); // 先将公钥转成点
+
+    var keypair = _.generateKeyPairHex();
+    var k = new BigInteger(keypair.privateKey, 16); // 随机数 k
+
+    // c1 = k * G
+    var c1 = keypair.publicKey;
+    if (c1.length > 128) c1 = c1.substr(c1.length - 128);
+
+    // (x2, y2) = k * publicKey
+    var p = publicKey.multiply(k);
+    var x2 = _.hexToArray(_.leftPad(p.getX().toBigInteger().toRadix(16), 64));
+    var y2 = _.hexToArray(_.leftPad(p.getY().toBigInteger().toRadix(16), 64));
+
+    // c3 = hash(x2 || msg || y2)
+    var c3 = _.arrayToHex(sm3([].concat(x2, msg, y2)));
+    var ct = 1;
+    var offset = 0;
+    var t = []; // 256 位
+    var z = [].concat(x2, y2);
+    var nextT = function nextT() {
+      // (1) Hai = hash(z || ct)
+      // (2) ct++
+      t = sm3([].concat(_toConsumableArray(z), [ct >> 24 & 0x00ff, ct >> 16 & 0x00ff, ct >> 8 & 0x00ff, ct & 0x00ff]));
+      ct++;
+      offset = 0;
+    };
+    nextT(); // 先生成 Ha1
+
+    for (var i = 0, len = msg.length; i < len; i++) {
+      // t = Ha1 || Ha2 || Ha3 || Ha4
+      if (offset === t.length) nextT();
+
+      // c2 = msg ^ t
+      msg[i] ^= t[offset++] & 0xff;
+    }
+    var c2 = _.arrayToHex(msg);
+    return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2;
+  }
+
+  /**
+   * 解密
+   */
+  function doDecrypt(encryptData, privateKey) {
+    var cipherMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      _ref$output = _ref.output,
+      output = _ref$output === void 0 ? 'string' : _ref$output;
+    privateKey = new BigInteger(privateKey, 16);
+    var c3 = encryptData.substr(128, 64);
+    var c2 = encryptData.substr(128 + 64);
+    if (cipherMode === C1C2C3) {
+      c3 = encryptData.substr(encryptData.length - 64);
+      c2 = encryptData.substr(128, encryptData.length - 128 - 64);
+    }
+    var msg = _.hexToArray(c2);
+    var c1 = _.getGlobalCurve().decodePointHex('04' + encryptData.substr(0, 128));
+    var p = c1.multiply(privateKey);
+    var x2 = _.hexToArray(_.leftPad(p.getX().toBigInteger().toRadix(16), 64));
+    var y2 = _.hexToArray(_.leftPad(p.getY().toBigInteger().toRadix(16), 64));
+    var ct = 1;
+    var offset = 0;
+    var t = []; // 256 位
+    var z = [].concat(x2, y2);
+    var nextT = function nextT() {
+      // (1) Hai = hash(z || ct)
+      // (2) ct++
+      t = sm3([].concat(_toConsumableArray(z), [ct >> 24 & 0x00ff, ct >> 16 & 0x00ff, ct >> 8 & 0x00ff, ct & 0x00ff]));
+      ct++;
+      offset = 0;
+    };
+    nextT(); // 先生成 Ha1
+
+    for (var i = 0, len = msg.length; i < len; i++) {
+      // t = Ha1 || Ha2 || Ha3 || Ha4
+      if (offset === t.length) nextT();
+
+      // c2 = msg ^ t
+      msg[i] ^= t[offset++] & 0xff;
+    }
+
+    // c3 = hash(x2 || msg || y2)
+    var checkC3 = _.arrayToHex(sm3([].concat(x2, msg, y2)));
+    if (checkC3 === c3.toLowerCase()) {
+      return output === 'array' ? msg : _.arrayToUtf8(msg);
+    } else {
+      return output === 'array' ? [] : '';
+    }
+  }
+
+  /**
+   * 签名
+   */
+  function doSignature(msg, privateKey) {
+    var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      pointPool = _ref2.pointPool,
+      der = _ref2.der,
+      hash = _ref2.hash,
+      publicKey = _ref2.publicKey,
+      userId = _ref2.userId;
+    var hashHex = typeof msg === 'string' ? _.utf8ToHex(msg) : _.arrayToHex(msg);
+    if (hash) {
+      // sm3杂凑
+      publicKey = publicKey || getPublicKeyFromPrivateKey(privateKey);
+      hashHex = getHash(hashHex, publicKey, userId);
+    }
+    var dA = new BigInteger(privateKey, 16);
+    var e = new BigInteger(hashHex, 16);
+
+    // k
+    var k = null;
+    var r = null;
+    var s = null;
+    do {
+      do {
+        var point = void 0;
+        if (pointPool && pointPool.length) {
+          point = pointPool.pop();
+        } else {
+          point = getPoint();
+        }
+        k = point.k;
+
+        // r = (e + x1) mod n
+        r = e.add(point.x1).mod(n);
+      } while (r.equals(BigInteger.ZERO) || r.add(k).equals(n));
+
+      // s = ((1 + dA)^-1 * (k - r * dA)) mod n
+      s = dA.add(BigInteger.ONE).modInverse(n).multiply(k.subtract(r.multiply(dA))).mod(n);
+    } while (s.equals(BigInteger.ZERO));
+    if (der) return encodeDer(r, s); // asn.1 der 编码
+
+    return _.leftPad(r.toString(16), 64) + _.leftPad(s.toString(16), 64);
+  }
+
+  /**
+   * 验签
+   */
+  function doVerifySignature(msg, signHex, publicKey) {
+    var _ref3 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      der = _ref3.der,
+      hash = _ref3.hash,
+      userId = _ref3.userId;
+    var hashHex = typeof msg === 'string' ? _.utf8ToHex(msg) : _.arrayToHex(msg);
+    if (hash) {
+      // sm3杂凑
+      hashHex = getHash(hashHex, publicKey, userId);
+    }
+    var r;
+    var s;
+    if (der) {
+      var decodeDerObj = decodeDer(signHex); // asn.1 der 解码
+      r = decodeDerObj.r;
+      s = decodeDerObj.s;
+    } else {
+      r = new BigInteger(signHex.substring(0, 64), 16);
+      s = new BigInteger(signHex.substring(64), 16);
+    }
+    var PA = curve.decodePointHex(publicKey);
+    var e = new BigInteger(hashHex, 16);
+
+    // t = (r + s) mod n
+    var t = r.add(s).mod(n);
+    if (t.equals(BigInteger.ZERO)) return false;
+
+    // x1y1 = s * G + t * PA
+    var x1y1 = G.multiply(s).add(PA.multiply(t));
+
+    // R = (e + x1) mod n
+    var R = e.add(x1y1.getX().toBigInteger()).mod(n);
+    return r.equals(R);
+  }
+
+  /**
+   * sm3杂凑算法
+   */
+  function getHash(hashHex, publicKey) {
+    var userId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '1234567812345678';
+    // z = hash(entl || userId || a || b || gx || gy || px || py)
+    userId = _.utf8ToHex(userId);
+    var a = _.leftPad(G.curve.a.toBigInteger().toRadix(16), 64);
+    var b = _.leftPad(G.curve.b.toBigInteger().toRadix(16), 64);
+    var gx = _.leftPad(G.getX().toBigInteger().toRadix(16), 64);
+    var gy = _.leftPad(G.getY().toBigInteger().toRadix(16), 64);
+    var px;
+    var py;
+    if (publicKey.length === 128) {
+      px = publicKey.substr(0, 64);
+      py = publicKey.substr(64, 64);
+    } else {
+      var point = G.curve.decodePointHex(publicKey);
+      px = _.leftPad(point.getX().toBigInteger().toRadix(16), 64);
+      py = _.leftPad(point.getY().toBigInteger().toRadix(16), 64);
+    }
+    var data = _.hexToArray(userId + a + b + gx + gy + px + py);
+    var entl = userId.length * 4;
+    data.unshift(entl & 0x00ff);
+    data.unshift(entl >> 8 & 0x00ff);
+    var z = sm3(data);
+
+    // e = hash(z || msg)
+    return _.arrayToHex(sm3(z.concat(_.hexToArray(hashHex))));
+  }
+
+  /**
+   * 计算公钥
+   */
+  function getPublicKeyFromPrivateKey(privateKey) {
+    var PA = G.multiply(new BigInteger(privateKey, 16));
+    var x = _.leftPad(PA.getX().toBigInteger().toString(16), 64);
+    var y = _.leftPad(PA.getY().toBigInteger().toString(16), 64);
+    return '04' + x + y;
+  }
+
+  /**
+   * 获取椭圆曲线点
+   */
+  function getPoint() {
+    var keypair = _.generateKeyPairHex();
+    var PA = curve.decodePointHex(keypair.publicKey);
+    keypair.k = new BigInteger(keypair.privateKey, 16);
+    keypair.x1 = PA.getX().toBigInteger();
+    return keypair;
+  }
+  sm2 = {
+    generateKeyPairHex: _.generateKeyPairHex,
+    compressPublicKeyHex: _.compressPublicKeyHex,
+    comparePublicKeyHex: _.comparePublicKeyHex,
+    doEncrypt: doEncrypt,
+    doDecrypt: doDecrypt,
+    doSignature: doSignature,
+    doVerifySignature: doVerifySignature,
+    getPublicKeyFromPrivateKey: getPublicKeyFromPrivateKey,
+    getPoint: getPoint,
+    verifyPublicKey: _.verifyPublicKey
+  };
+  return sm2;
+}
+
+var sm3_1;
+var hasRequiredSm3;
+function requireSm3() {
+  if (hasRequiredSm3) return sm3_1;
+  hasRequiredSm3 = 1;
+  var _require$$ = requireSm3$1(),
+    sm3 = _require$$.sm3,
+    hmac = _require$$.hmac;
+
+  /**
+   * 补全16进制字符串
+   */
+  function leftPad(input, num) {
+    if (input.length >= num) return input;
+    return new Array(num - input.length + 1).join('0') + input;
+  }
+
+  /**
+   * 字节数组转 16 进制串
+   */
+  function ArrayToHex(arr) {
+    return arr.map(function (item) {
+      item = item.toString(16);
+      return item.length === 1 ? '0' + item : item;
+    }).join('');
+  }
+
+  /**
+   * 转成字节数组
+   */
+  function hexToArray(hexStr) {
+    var words = [];
+    var hexStrLength = hexStr.length;
+    if (hexStrLength % 2 !== 0) {
+      hexStr = leftPad(hexStr, hexStrLength + 1);
+    }
+    hexStrLength = hexStr.length;
+    for (var i = 0; i < hexStrLength; i += 2) {
+      words.push(parseInt(hexStr.substr(i, 2), 16));
+    }
+    return words;
+  }
+
+  /**
+   * utf8 串转字节数组
+   */
+  function utf8ToArray(str) {
+    var arr = [];
+    for (var i = 0, len = str.length; i < len; i++) {
+      var point = str.codePointAt(i);
+      if (point <= 0x007f) {
+        // 单字节，标量值：00000000 00000000 0zzzzzzz
+        arr.push(point);
+      } else if (point <= 0x07ff) {
+        // 双字节，标量值：00000000 00000yyy yyzzzzzz
+        arr.push(0xc0 | point >>> 6); // 110yyyyy（0xc0-0xdf）
+        arr.push(0x80 | point & 0x3f); // 10zzzzzz（0x80-0xbf）
+      } else if (point <= 0xD7FF || point >= 0xE000 && point <= 0xFFFF) {
+        // 三字节：标量值：00000000 xxxxyyyy yyzzzzzz
+        arr.push(0xe0 | point >>> 12); // 1110xxxx（0xe0-0xef）
+        arr.push(0x80 | point >>> 6 & 0x3f); // 10yyyyyy（0x80-0xbf）
+        arr.push(0x80 | point & 0x3f); // 10zzzzzz（0x80-0xbf）
+      } else if (point >= 0x010000 && point <= 0x10FFFF) {
+        // 四字节：标量值：000wwwxx xxxxyyyy yyzzzzzz
+        i++;
+        arr.push(0xf0 | point >>> 18 & 0x1c); // 11110www（0xf0-0xf7）
+        arr.push(0x80 | point >>> 12 & 0x3f); // 10xxxxxx（0x80-0xbf）
+        arr.push(0x80 | point >>> 6 & 0x3f); // 10yyyyyy（0x80-0xbf）
+        arr.push(0x80 | point & 0x3f); // 10zzzzzz（0x80-0xbf）
+      } else {
+        // 五、六字节，暂时不支持
+        arr.push(point);
+        throw new Error('input is not supported');
+      }
+    }
+    return arr;
+  }
+  sm3_1 = function sm3_1(input, options) {
+    input = typeof input === 'string' ? utf8ToArray(input) : Array.prototype.slice.call(input);
+    if (options) {
+      var mode = options.mode || 'hmac';
+      if (mode !== 'hmac') throw new Error('invalid mode');
+      var key = options.key;
+      if (!key) throw new Error('invalid key');
+      key = typeof key === 'string' ? hexToArray(key) : Array.prototype.slice.call(key);
+      return ArrayToHex(hmac(input, key));
+    }
+    return ArrayToHex(sm3(input));
+  };
+  return sm3_1;
+}
+
+var sm4_1;
+var hasRequiredSm4;
+function requireSm4() {
+  if (hasRequiredSm4) return sm4_1;
+  hasRequiredSm4 = 1;
+  var DECRYPT = 0;
+  var ROUND = 32;
+  var BLOCK = 16;
+  var Sbox = [0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05, 0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99, 0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62, 0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6, 0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8, 0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87, 0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e, 0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1, 0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3, 0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f, 0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51, 0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8, 0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0, 0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84, 0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48];
+  var CK = [0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269, 0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9, 0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249, 0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9, 0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229, 0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299, 0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209, 0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279];
+
+  /**
+   * 16 进制串转字节数组
+   */
+  function hexToArray(str) {
+    var arr = [];
+    for (var i = 0, len = str.length; i < len; i += 2) {
+      arr.push(parseInt(str.substr(i, 2), 16));
+    }
+    return arr;
+  }
+
+  /**
+   * 字节数组转 16 进制串
+   */
+  function ArrayToHex(arr) {
+    return arr.map(function (item) {
+      item = item.toString(16);
+      return item.length === 1 ? '0' + item : item;
+    }).join('');
+  }
+
+  /**
+   * utf8 串转字节数组
+   */
+  function utf8ToArray(str) {
+    var arr = [];
+    for (var i = 0, len = str.length; i < len; i++) {
+      var point = str.codePointAt(i);
+      if (point <= 0x007f) {
+        // 单字节，标量值：00000000 00000000 0zzzzzzz
+        arr.push(point);
+      } else if (point <= 0x07ff) {
+        // 双字节，标量值：00000000 00000yyy yyzzzzzz
+        arr.push(0xc0 | point >>> 6); // 110yyyyy（0xc0-0xdf）
+        arr.push(0x80 | point & 0x3f); // 10zzzzzz（0x80-0xbf）
+      } else if (point <= 0xD7FF || point >= 0xE000 && point <= 0xFFFF) {
+        // 三字节：标量值：00000000 xxxxyyyy yyzzzzzz
+        arr.push(0xe0 | point >>> 12); // 1110xxxx（0xe0-0xef）
+        arr.push(0x80 | point >>> 6 & 0x3f); // 10yyyyyy（0x80-0xbf）
+        arr.push(0x80 | point & 0x3f); // 10zzzzzz（0x80-0xbf）
+      } else if (point >= 0x010000 && point <= 0x10FFFF) {
+        // 四字节：标量值：000wwwxx xxxxyyyy yyzzzzzz
+        i++;
+        arr.push(0xf0 | point >>> 18 & 0x1c); // 11110www（0xf0-0xf7）
+        arr.push(0x80 | point >>> 12 & 0x3f); // 10xxxxxx（0x80-0xbf）
+        arr.push(0x80 | point >>> 6 & 0x3f); // 10yyyyyy（0x80-0xbf）
+        arr.push(0x80 | point & 0x3f); // 10zzzzzz（0x80-0xbf）
+      } else {
+        // 五、六字节，暂时不支持
+        arr.push(point);
+        throw new Error('input is not supported');
+      }
+    }
+    return arr;
+  }
+
+  /**
+   * 字节数组转 utf8 串
+   */
+  function arrayToUtf8(arr) {
+    var str = [];
+    for (var i = 0, len = arr.length; i < len; i++) {
+      if (arr[i] >= 0xf0 && arr[i] <= 0xf7) {
+        // 四字节
+        str.push(String.fromCodePoint(((arr[i] & 0x07) << 18) + ((arr[i + 1] & 0x3f) << 12) + ((arr[i + 2] & 0x3f) << 6) + (arr[i + 3] & 0x3f)));
+        i += 3;
+      } else if (arr[i] >= 0xe0 && arr[i] <= 0xef) {
+        // 三字节
+        str.push(String.fromCodePoint(((arr[i] & 0x0f) << 12) + ((arr[i + 1] & 0x3f) << 6) + (arr[i + 2] & 0x3f)));
+        i += 2;
+      } else if (arr[i] >= 0xc0 && arr[i] <= 0xdf) {
+        // 双字节
+        str.push(String.fromCodePoint(((arr[i] & 0x1f) << 6) + (arr[i + 1] & 0x3f)));
+        i++;
+      } else {
+        // 单字节
+        str.push(String.fromCodePoint(arr[i]));
+      }
+    }
+    return str.join('');
+  }
+
+  /**
+   * 32 比特循环左移
+   */
+  function rotl(x, n) {
+    var s = n & 31;
+    return x << s | x >>> 32 - s;
+  }
+
+  /**
+   * 非线性变换
+   */
+  function byteSub(a) {
+    return (Sbox[a >>> 24 & 0xFF] & 0xFF) << 24 | (Sbox[a >>> 16 & 0xFF] & 0xFF) << 16 | (Sbox[a >>> 8 & 0xFF] & 0xFF) << 8 | Sbox[a & 0xFF] & 0xFF;
+  }
+
+  /**
+   * 线性变换，加密/解密用
+   */
+  function l1(b) {
+    return b ^ rotl(b, 2) ^ rotl(b, 10) ^ rotl(b, 18) ^ rotl(b, 24);
+  }
+
+  /**
+   * 线性变换，生成轮密钥用
+   */
+  function l2(b) {
+    return b ^ rotl(b, 13) ^ rotl(b, 23);
+  }
+
+  /**
+   * 以一组 128 比特进行加密/解密操作
+   */
+  function sms4Crypt(input, output, roundKey) {
+    var x = new Array(4);
+
+    // 字节数组转成字数组（此处 1 字 = 32 比特）
+    var tmp = new Array(4);
+    for (var i = 0; i < 4; i++) {
+      tmp[0] = input[4 * i] & 0xff;
+      tmp[1] = input[4 * i + 1] & 0xff;
+      tmp[2] = input[4 * i + 2] & 0xff;
+      tmp[3] = input[4 * i + 3] & 0xff;
+      x[i] = tmp[0] << 24 | tmp[1] << 16 | tmp[2] << 8 | tmp[3];
+    }
+
+    // x[i + 4] = x[i] ^ l1(byteSub(x[i + 1] ^ x[i + 2] ^ x[i + 3] ^ roundKey[i]))
+    for (var r = 0, mid; r < 32; r += 4) {
+      mid = x[1] ^ x[2] ^ x[3] ^ roundKey[r + 0];
+      x[0] ^= l1(byteSub(mid)); // x[4]
+
+      mid = x[2] ^ x[3] ^ x[0] ^ roundKey[r + 1];
+      x[1] ^= l1(byteSub(mid)); // x[5]
+
+      mid = x[3] ^ x[0] ^ x[1] ^ roundKey[r + 2];
+      x[2] ^= l1(byteSub(mid)); // x[6]
+
+      mid = x[0] ^ x[1] ^ x[2] ^ roundKey[r + 3];
+      x[3] ^= l1(byteSub(mid)); // x[7]
+    }
+
+    // 反序变换
+    for (var j = 0; j < 16; j += 4) {
+      output[j] = x[3 - j / 4] >>> 24 & 0xff;
+      output[j + 1] = x[3 - j / 4] >>> 16 & 0xff;
+      output[j + 2] = x[3 - j / 4] >>> 8 & 0xff;
+      output[j + 3] = x[3 - j / 4] & 0xff;
+    }
+  }
+
+  /**
+   * 密钥扩展算法
+   */
+  function sms4KeyExt(key, roundKey, cryptFlag) {
+    var x = new Array(4);
+
+    // 字节数组转成字数组（此处 1 字 = 32 比特）
+    var tmp = new Array(4);
+    for (var i = 0; i < 4; i++) {
+      tmp[0] = key[0 + 4 * i] & 0xff;
+      tmp[1] = key[1 + 4 * i] & 0xff;
+      tmp[2] = key[2 + 4 * i] & 0xff;
+      tmp[3] = key[3 + 4 * i] & 0xff;
+      x[i] = tmp[0] << 24 | tmp[1] << 16 | tmp[2] << 8 | tmp[3];
+    }
+
+    // 与系统参数做异或
+    x[0] ^= 0xa3b1bac6;
+    x[1] ^= 0x56aa3350;
+    x[2] ^= 0x677d9197;
+    x[3] ^= 0xb27022dc;
+
+    // roundKey[i] = x[i + 4] = x[i] ^ l2(byteSub(x[i + 1] ^ x[i + 2] ^ x[i + 3] ^ CK[i]))
+    for (var r = 0, mid; r < 32; r += 4) {
+      mid = x[1] ^ x[2] ^ x[3] ^ CK[r + 0];
+      roundKey[r + 0] = x[0] ^= l2(byteSub(mid)); // x[4]
+
+      mid = x[2] ^ x[3] ^ x[0] ^ CK[r + 1];
+      roundKey[r + 1] = x[1] ^= l2(byteSub(mid)); // x[5]
+
+      mid = x[3] ^ x[0] ^ x[1] ^ CK[r + 2];
+      roundKey[r + 2] = x[2] ^= l2(byteSub(mid)); // x[6]
+
+      mid = x[0] ^ x[1] ^ x[2] ^ CK[r + 3];
+      roundKey[r + 3] = x[3] ^= l2(byteSub(mid)); // x[7]
+    }
+
+    // 解密时使用反序的轮密钥
+    if (cryptFlag === DECRYPT) {
+      for (var _r = 0, _mid; _r < 16; _r++) {
+        _mid = roundKey[_r];
+        roundKey[_r] = roundKey[31 - _r];
+        roundKey[31 - _r] = _mid;
+      }
+    }
+  }
+  function sm4(inArray, key, cryptFlag) {
+    var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      _ref$padding = _ref.padding,
+      padding = _ref$padding === void 0 ? 'pkcs#7' : _ref$padding,
+      mode = _ref.mode,
+      _ref$iv = _ref.iv,
+      iv = _ref$iv === void 0 ? [] : _ref$iv,
+      _ref$output = _ref.output,
+      output = _ref$output === void 0 ? 'string' : _ref$output;
+    if (mode === 'cbc') {
+      // CBC 模式，默认走 ECB 模式
+      if (typeof iv === 'string') iv = hexToArray(iv);
+      if (iv.length !== 128 / 8) {
+        // iv 不是 128 比特
+        throw new Error('iv is invalid');
+      }
+    }
+
+    // 检查 key
+    if (typeof key === 'string') key = hexToArray(key);
+    if (key.length !== 128 / 8) {
+      // key 不是 128 比特
+      throw new Error('key is invalid');
+    }
+
+    // 检查输入
+    if (typeof inArray === 'string') {
+      if (cryptFlag !== DECRYPT) {
+        // 加密，输入为 utf8 串
+        inArray = utf8ToArray(inArray);
+      } else {
+        // 解密，输入为 16 进制串
+        inArray = hexToArray(inArray);
+      }
+    } else {
+      inArray = _toConsumableArray(inArray);
+    }
+
+    // 新增填充，sm4 是 16 个字节一个分组，所以统一走到 pkcs#7
+    if ((padding === 'pkcs#5' || padding === 'pkcs#7') && cryptFlag !== DECRYPT) {
+      var paddingCount = BLOCK - inArray.length % BLOCK;
+      for (var i = 0; i < paddingCount; i++) inArray.push(paddingCount);
+    }
+
+    // 生成轮密钥
+    var roundKey = new Array(ROUND);
+    sms4KeyExt(key, roundKey, cryptFlag);
+    var outArray = [];
+    var lastVector = iv;
+    var restLen = inArray.length;
+    var point = 0;
+    while (restLen >= BLOCK) {
+      var input = inArray.slice(point, point + 16);
+      var _output = new Array(16);
+      if (mode === 'cbc') {
+        for (var _i = 0; _i < BLOCK; _i++) {
+          if (cryptFlag !== DECRYPT) {
+            // 加密过程在组加密前进行异或
+            input[_i] ^= lastVector[_i];
+          }
+        }
+      }
+      sms4Crypt(input, _output, roundKey);
+      for (var _i2 = 0; _i2 < BLOCK; _i2++) {
+        if (mode === 'cbc') {
+          if (cryptFlag === DECRYPT) {
+            // 解密过程在组解密后进行异或
+            _output[_i2] ^= lastVector[_i2];
+          }
+        }
+        outArray[point + _i2] = _output[_i2];
+      }
+      if (mode === 'cbc') {
+        if (cryptFlag !== DECRYPT) {
+          // 使用上一次输出作为加密向量
+          lastVector = _output;
+        } else {
+          // 使用上一次输入作为解密向量
+          lastVector = input;
+        }
+      }
+      restLen -= BLOCK;
+      point += BLOCK;
+    }
+
+    // 去除填充，sm4 是 16 个字节一个分组，所以统一走到 pkcs#7
+    if ((padding === 'pkcs#5' || padding === 'pkcs#7') && cryptFlag === DECRYPT) {
+      var len = outArray.length;
+      var _paddingCount = outArray[len - 1];
+      for (var _i3 = 1; _i3 <= _paddingCount; _i3++) {
+        if (outArray[len - _i3] !== _paddingCount) throw new Error('padding is invalid');
+      }
+      outArray.splice(len - _paddingCount, _paddingCount);
+    }
+
+    // 调整输出
+    if (output !== 'array') {
+      if (cryptFlag !== DECRYPT) {
+        // 加密，输出转 16 进制串
+        return ArrayToHex(outArray);
+      } else {
+        // 解密，输出转 utf8 串
+        return arrayToUtf8(outArray);
+      }
+    } else {
+      return outArray;
+    }
+  }
+  sm4_1 = {
+    encrypt: function encrypt(inArray, key, options) {
+      return sm4(inArray, key, 1, options);
+    },
+    decrypt: function decrypt(inArray, key, options) {
+      return sm4(inArray, key, 0, options);
+    }
+  };
+  return sm4_1;
+}
+
+var src;
+var hasRequiredSrc;
+function requireSrc() {
+  if (hasRequiredSrc) return src;
+  hasRequiredSrc = 1;
+  src = {
+    sm2: requireSm2(),
+    sm3: requireSm3(),
+    sm4: requireSm4()
+  };
+  return src;
+}
+
+var srcExports = requireSrc();
+
+// globalThis polyfill for IE
+(function () {
+  if (typeof globalThis === 'undefined') {
+    if (typeof window !== 'undefined') {
+      window.globalThis = window;
+    } else if (typeof global !== 'undefined') {
+      global.globalThis = global;
+    } else if (typeof self !== 'undefined') {
+      self.globalThis = self;
+    } else {
+      this.globalThis = this;
+    }
+  }
+})();
+
+// IE浏览器检测（IE11兼容）
+function isIE() {
+  var ua = window.navigator.userAgent;
+  var msie = ua.indexOf("MSIE ");
+  var trident = ua.indexOf("Trident/");
+  var edge = ua.indexOf("Edge/");
+  return (msie > 0 || trident > 0) && edge < 0;
+}
+
+// 兼容的事件监听器添加函数（IE11支持addEventListener）
+function addEventListenerCompat(element, event, handler) {
+  if (element.addEventListener) {
+    element.addEventListener(event, handler, false);
+  } else if (element.attachEvent) {
+    element.attachEvent("on" + event, handler);
+  }
+}
+
+// 兼容的事件监听器移除函数
+function removeEventListenerCompat(element, event, handler) {
+  if (element.removeEventListener) {
+    element.removeEventListener(event, handler, false);
+  } else if (element.detachEvent) {
+    element.detachEvent("on" + event, handler);
+  }
+}
+
+// 兼容的stopImmediatePropagation
+function stopImmediatePropagationCompat(e) {
+  if (e.stopImmediatePropagation) {
+    e.stopImmediatePropagation();
+  } else {
+    e.stopPropagation();
+    if (e.cancelBubble !== undefined) {
+      e.cancelBubble = true;
+    }
+  }
+}
+
+// 兼容的URL解析函数（IE不支持URL构造函数）
+function getOriginFromUrl(url) {
+  if (!isIE() && window.URL) {
+    try {
+      return new URL(url).origin;
+    } catch (e) {
+      // fallback
+    }
+  }
+  // IE兼容方案：手动解析URL
+  var link = document.createElement("a");
+  link.href = url;
+  return link.protocol + "//" + link.host;
+}
+
+// Object.entries polyfill（IE11不支持）
+function objectEntries(obj) {
+  if (Object.entries) {
+    return Object.entries(obj);
+  }
+  // IE11兼容方案
+  var keys = Object.keys(obj);
+  var result = [];
+  for (var i = 0; i < keys.length; i++) {
+    result.push([keys[i], obj[keys[i]]]);
+  }
+  return result;
+}
+
+// 兼容的样式设置（userSelect）
+function setUserSelect(element, value) {
+  if (isIE()) {
+    element.style.msUserSelect = value;
+    element.style.userSelect = value;
+  } else {
+    element.style.userSelect = value;
+  }
+}
+
+// 兼容的cursor设置（IE不支持grabbing）
+function setCursor(element, value) {
+  if (isIE() && value === "grabbing") {
+    element.style.cursor = "move";
+  } else {
+    element.style.cursor = value;
+  }
+}
+var DEFAULT_WIDTH = 80;
+var DEFAULT_HEIGHT = 80;
+var DEFAULT_RIGHT = 40;
+var DEFAULT_BOTTOM = 40;
+var bindDraggable = function bindDraggable(instance, dom, callback) {
+  var isDragging = false;
+  var moved = false;
+  var onMouseMove = function onMouseMove(e) {
+    if (!isDragging) return;
+    moved = true;
+    var rect = dom.getBoundingClientRect();
+    var widthDis = e.clientX - rect.width / 2;
+    var heightDis = e.clientY - rect.height / 2;
+    widthDis = widthDis < 0 ? 0 : widthDis;
+    heightDis = heightDis < 0 ? 0 : heightDis;
+    instance.container.style.left = widthDis + "px";
+    instance.container.style.top = heightDis + "px";
+    instance.left = widthDis;
+    instance.top = e.clientY - heightDis;
+  };
+  var _onMouseUp = function onMouseUp(e) {
+    setUserSelect(document.body, "");
+    if (!isDragging) return;
+    isDragging = false;
+    setCursor(dom, "pointer");
+    removeEventListenerCompat(document, "mousemove", onMouseMove);
+    removeEventListenerCompat(document, "mouseup", _onMouseUp);
+  };
+  addEventListenerCompat(dom, "mousedown", function (e) {
+    setUserSelect(document.body, "none");
+    isDragging = true;
+    moved = false;
+    var rect = dom.getBoundingClientRect ? dom.getBoundingClientRect() : {
+      width: dom.offsetWidth || 0,
+      height: dom.offsetHeight || 0,
+      left: dom.offsetLeft || 0,
+      top: dom.offsetTop || 0
+    };
+    e.clientX - (rect.left + rect.width / 2);
+    e.clientY - (rect.top + rect.height / 2);
+    e.clientX;
+    e.clientY;
+    instance.container.style.left = e.clientX - rect.width / 2 + "px";
+    instance.container.style.top = e.clientY - rect.height / 2 + "px";
+    instance.top = e.clientY - rect.height / 2;
+    instance.left = e.clientX - rect.width / 2;
+    setCursor(dom, "grabbing");
+    addEventListenerCompat(document, "mousemove", onMouseMove);
+    addEventListenerCompat(document, "mouseup", _onMouseUp);
+  });
+  addEventListenerCompat(dom, "click", function (e) {
+    if (moved) {
+      stopImmediatePropagationCompat(e);
+      if (e.preventDefault) {
+        e.preventDefault();
+      } else {
+        e.returnValue = false;
+      }
+      moved = false;
+    } else {
+      if (callback) {
+        callback();
+      }
+    }
+  });
+};
+
+// 客服SDK类（使用函数构造函数以兼容IE）
+function WkCustomerServiceSDK() {
+  this.options = {};
+  this.container = null;
+  this.iframe = null;
+  this.overlay = null;
+  this.eventListeners = {};
+}
+
+// DOM ready 兼容函数（IE11兼容）
+function domReady(fn) {
+  if (document.readyState === 'complete' || document.readyState === 'interactive') {
+    setTimeout(fn, 1);
+  } else {
+    document.addEventListener('DOMContentLoaded', fn, false);
+  }
+}
+
+// 获取body元素的兼容函数
+function getBody() {
+  if (document.body) {
+    return document.body;
+  }
+  if (document.getElementsByTagName('body')[0]) {
+    return document.getElementsByTagName('body')[0];
+  }
+  return null;
+}
+
+// 初始化iframe
+WkCustomerServiceSDK.prototype.init = function (options) {
+  var self = this;
+  this.options = options;
+  var initContainer = function initContainer() {
+    var body = getBody();
+    if (!body) {
+      return;
+    }
+    var isLoadCus = document.getElementById("wk-ai-customer-container");
+    if (isLoadCus) {
+      return;
+    }
+
+    // 计算位置
+    var innerWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth || 1024;
+    var innerHeight = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight || 768;
+    self.options.height = options.height || DEFAULT_HEIGHT;
+    self.options.width = options.width || DEFAULT_WIDTH;
+    self.left = innerWidth - self.options.width - DEFAULT_RIGHT;
+    self.top = innerHeight - self.options.height - DEFAULT_BOTTOM;
+    if (options.right !== undefined && options.right > 0) {
+      self.left = innerWidth - options.right - self.options.width;
+    } else if (options.left !== undefined && options.left >= 0) {
+      self.left = options.left;
+    }
+    if (options.bottom !== undefined && options.bottom > 0) {
+      self.top = innerHeight - options.bottom - self.options.height;
+    } else if (options.top !== undefined && options.top >= 0) {
+      self.top = options.top;
+    }
+
+    // 确保容器在可见区域内
+    if (self.left < 0) self.left = 10;
+    if (self.top < 0) self.top = 10;
+    if (self.left + self.options.width > innerWidth) {
+      self.left = innerWidth - self.options.width - 10;
+    }
+    if (self.top + self.options.height > innerHeight) {
+      self.top = innerHeight - self.options.height - 10;
+    }
+
+    // IE中如果位置超出屏幕，强制设置为可见位置
+    if (isIE()) {
+      if (self.left > innerWidth - 100) {
+        self.left = innerWidth - self.options.width - 20;
+      }
+      if (self.top > innerHeight - 100) {
+        self.top = innerHeight - self.options.height - 20;
+      }
+      // 确保至少有一部分在可见区域内
+      if (self.left < 0) self.left = 100;
+      if (self.top < 0) self.top = 100;
+    }
+
+    // 创建容器 - 使用最简单可靠的方式
+    self.container = document.createElement("div");
+    self.container.id = "wk-ai-customer-container";
+
+    // 设置样式 - 使用fixed定位，确保IE兼容
+    self.container.style.position = "fixed";
+    self.container.style.width = self.options.width + "px";
+    self.container.style.height = self.options.height + "px";
+    self.container.style.top = self.top + "px";
+    self.container.style.left = self.left + "px";
+    self.container.style.display = "block";
+    self.container.style.visibility = "visible";
+    self.container.style.zIndex = "999999";
+    self.container.style.overflow = "hidden";
+    self.container.style.margin = "0";
+    self.container.style.padding = "0";
+    // 确保容器有背景色，即使iframe还没加载也能看到
+    self.container.style.backgroundColor = "transparent";
+
+    // IE特定处理
+    if (isIE()) {
+      self.container.style.filter = "alpha(opacity=100)";
+      self.container.style.zoom = "1";
+      // IE中确保容器有最小尺寸
+      self.container.style.minWidth = self.options.width + "px";
+      self.container.style.minHeight = self.options.height + "px";
+      // IE中空容器可能不显示，添加一个占位元素
+      var placeholder = document.createElement("div");
+      placeholder.style.cssText = "width:100%;height:100%;position:absolute;top:0;left:0;background-color:#f0f0f0;z-index:1;";
+      self.container.appendChild(placeholder);
+    }
+
+    // 添加到body
+    body.appendChild(self.container);
+
+    // IE兼容：强制重绘
+    if (isIE()) {
+      self.container.style.display = "none";
+      self.container.offsetHeight; // 触发重排
+      self.container.style.display = "block";
+    }
+
+    // 创建iframe
+    try {
+      var baseUrl = self.options.baseUrl || "https://ai.vcolco.com/chat/";
+      var queryParams = self.buildQueryParams();
+      self.iframe = document.createElement("iframe");
+      self.iframe.src = baseUrl + "?" + queryParams;
+      self.iframe.width = "100%";
+      self.iframe.height = "100%";
+      self.iframe.frameBorder = "0";
+      self.iframe.scrolling = "no";
+      self.iframe.style.border = "none";
+      self.iframe.style.position = "absolute";
+      self.iframe.style.zIndex = "2024";
+      self.iframe.style.left = "0";
+      self.iframe.style.top = "0";
+      self.iframe.style.width = "100%";
+      self.iframe.style.height = "100%";
+      self.iframe.style.backgroundColor = "#ffffff";
+      self.container.appendChild(self.iframe);
+
+      // IE兼容：iframe加载后移除占位元素
+      if (isIE()) {
+        addEventListenerCompat(self.iframe, "load", function () {
+          var placeholder = self.container.querySelector("div[style*='background-color:#f0f0f0']");
+          if (placeholder && placeholder.parentNode) {
+            placeholder.parentNode.removeChild(placeholder);
+          }
+        });
+      }
+    } catch (e) {
+      // 如果创建iframe失败，至少容器已经显示了
+    }
+
+    // 创建覆盖元素
+    self.overlay = document.createElement("div");
+    self.overlay.style.position = "absolute";
+    self.overlay.style.width = "100%";
+    self.overlay.style.height = "100%";
+    self.overlay.style.cursor = "pointer";
+    self.overlay.style.opacity = "0";
+    self.overlay.style.zIndex = "2025";
+    self.overlay.style.left = "0";
+    self.overlay.style.top = "0";
+    self.container.appendChild(self.overlay);
+    bindDraggable(self, self.overlay, function () {
+      self.container.style.width = "500px";
+      self.container.style.height = "100%";
+      self.container.style.right = "0";
+      self.container.style.top = "0";
+      self.container.style.bottom = "auto";
+      self.container.style.left = "auto";
+      self.container.style.position = "fixed";
+      self.container.style.zIndex = "999999";
+      self.overlay.style.zIndex = "2024";
+      if (self.iframe) {
+        self.iframe.style.zIndex = "2025";
+      }
+      self.postMessage({
+        type: "clickIcon"
+      });
+    });
+
+    // 设置消息监听
+    var boundHandleMessage = function boundHandleMessage(event) {
+      self.handleMessage(event);
+    };
+    self._boundHandleMessage = boundHandleMessage;
+    addEventListenerCompat(window, "message", boundHandleMessage);
+
+    // 发送初始化消息
+    if (self.iframe) {
+      self.postMessage({
+        type: "init"
+      });
+    }
+  };
+
+  // 等待DOM ready后初始化
+  var _tryInit = function tryInit() {
+    try {
+      var body = getBody();
+      if (!body) {
+        setTimeout(_tryInit, 50);
+        return;
+      }
+      initContainer();
+    } catch (err) {
+      // 静默失败
+    }
+  };
+
+  // 立即尝试一次
+  _tryInit();
+
+  // 也使用domReady作为备用
+  domReady(function () {
+    try {
+      var body = getBody();
+      if (!body) {
+        setTimeout(function () {
+          body = getBody();
+          if (body) {
+            initContainer();
+          }
+        }, 100);
+        return;
+      }
+      if (!document.getElementById("wk-ai-customer-container")) {
+        initContainer();
+      }
+    } catch (e) {
+      // 静默失败
+    }
+  });
+};
+
+// 构建URL查询参数
+WkCustomerServiceSDK.prototype.buildQueryParams = function () {
+  var Enterprise = this.options.Enterprise;
+  var Externalid = this.options.Externalid;
+  var Role = this.options.Role;
+  var Userid = this.options.Userid;
+  var Username = this.options.Username;
+  var Knowledge = this.options.Knowledge;
+  var Privatekey = this.options.Privatekey;
+  var Usetype = this.options.Usetype;
+  if (!Enterprise || !Externalid || !Role || !Userid || !Username) {
+    throw new Error("Missing required options: Enterprise, Externalid, Role, Userid, Username");
+  }
+  var params = {
+    Enterprise: Enterprise,
+    Externalid: Externalid,
+    Knowledge: Knowledge || "",
+    Role: Role,
+    Userid: Userid,
+    Username: Username
+  };
+  if (!params.Knowledge) {
+    delete params.Knowledge;
+  }
+  var entries = objectEntries(params);
+  var signString = entries.map(function (entry) {
+    return entry[0] + "=" + entry[1];
+  }).join("&");
+  params.Sign = srcExports.sm2.doSignature(signString, Privatekey, {
+    der: true,
+    hash: true
+  });
+  if (Usetype) {
+    params.Usetype = Usetype;
+  }
+  params.Iframe = "PC";
+  var allEntries = objectEntries(params);
+  return allEntries.map(function (entry) {
+    return entry[0] + "=" + entry[1];
+  }).join("&");
+};
+
+// 处理来自iframe的消息
+WkCustomerServiceSDK.prototype.handleMessage = function (event) {
+  var baseUrl = this.options.baseUrl || "https://ai.vcolco.com/chat/";
+  var origin = getOriginFromUrl(baseUrl);
+  if (event.origin !== origin) return;
+  if (event.data && event.data.type && this.eventListeners[event.data.type]) {
+    var callbacks = this.eventListeners[event.data.type];
+    for (var i = 0; i < callbacks.length; i++) {
+      callbacks[i](event.data);
+    }
+  }
+  if (event.data && event.data.type) {
+    switch (event.data.type) {
+      case "showChat":
+        break;
+      case "hideChat":
+        this.container.style.width = this.options.width + "px";
+        this.container.style.height = this.options.height + "px";
+        this.container.style.top = this.top + "px";
+        this.container.style.left = this.left + "px";
+        this.container.style.bottom = "auto";
+        this.container.style.right = "auto";
+        this.container.style.position = "fixed";
+        this.overlay.style.zIndex = "2025";
+        if (this.iframe) {
+          this.iframe.style.zIndex = "2024";
+        }
+        break;
+    }
+  }
+};
+
+// 向iframe发送消息
+WkCustomerServiceSDK.prototype.postMessage = function (message) {
+  if (this.iframe && this.iframe.contentWindow) {
+    var targetOrigin = this.options.baseUrl || "https://ai.vcolco.com/chat/";
+    this.iframe.contentWindow.postMessage(message, targetOrigin);
+  }
+};
+
+// 注册事件监听器
+WkCustomerServiceSDK.prototype.on = function (eventType, callback) {
+  if (!this.eventListeners[eventType]) {
+    this.eventListeners[eventType] = [];
+  }
+  this.eventListeners[eventType].push(callback);
+  return this;
+};
+
+// 移除事件监听器
+WkCustomerServiceSDK.prototype.off = function (eventType, callback) {};
+
+// 显示客服窗口
+WkCustomerServiceSDK.prototype.show = function () {};
+
+// 隐藏客服窗口
+WkCustomerServiceSDK.prototype.hide = function () {};
+
+// 销毁实例
+WkCustomerServiceSDK.prototype.destroy = function () {
+  if (this._boundHandleMessage) {
+    removeEventListenerCompat(window, "message", this._boundHandleMessage);
+  }
+  var container = document.getElementById("wk-ai-customer-container");
+  if (container && container.parentNode) {
+    container.parentNode.removeChild(container);
+  }
+};
+
+// 创建SDK实例
+var wkAiCustomerService = new WkCustomerServiceSDK();
+
+export { wkAiCustomerService as default };