vite 2.0.4 → 2.1.2

package/dist/node/chunks/{dep-e293f0bf.js → dep-ce592790.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var build = require('./dep-1bdbec90.js');
+var build = require('./dep-efe32886.js');
 var require$$0 = require('crypto');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e['default'] : e; }
@@ -4385,7 +4385,7 @@ forge.aes = forge.aes || {};
  * @return the cipher.
  */
 forge.aes.startEncrypting = function(key, iv, output, mode) {
-  var cipher = _createCipher({
+  var cipher = _createCipher$1({
     key: key,
     output: output,
     decrypt: false,
@@ -4411,7 +4411,7 @@ forge.aes.startEncrypting = function(key, iv, output, mode) {
  * @return the cipher.
  */
 forge.aes.createEncryptionCipher = function(key, mode) {
-  return _createCipher({
+  return _createCipher$1({
     key: key,
     output: null,
     decrypt: false,
@@ -4439,7 +4439,7 @@ forge.aes.createEncryptionCipher = function(key, mode) {
  * @return the cipher.
  */
 forge.aes.startDecrypting = function(key, iv, output, mode) {
-  var cipher = _createCipher({
+  var cipher = _createCipher$1({
     key: key,
     output: output,
     decrypt: true,
@@ -4465,7 +4465,7 @@ forge.aes.startDecrypting = function(key, iv, output, mode) {
  * @return the cipher.
  */
 forge.aes.createDecryptionCipher = function(key, mode) {
-  return _createCipher({
+  return _createCipher$1({
     key: key,
     output: null,
     decrypt: true,
@@ -4491,10 +4491,10 @@ forge.aes.Algorithm = function(name, mode) {
     blockSize: 16,
     cipher: {
       encrypt: function(inBlock, outBlock) {
-        return _updateBlock(self._w, inBlock, outBlock, false);
+        return _updateBlock$1(self._w, inBlock, outBlock, false);
       },
       decrypt: function(inBlock, outBlock) {
-        return _updateBlock(self._w, inBlock, outBlock, true);
+        return _updateBlock$1(self._w, inBlock, outBlock, true);
       }
     }
   });
@@ -4589,18 +4589,18 @@ forge.aes._expandKey = function(key, decrypt) {
  * @param output an array of block-size 32-bit words.
  * @param decrypt true to decrypt, false to encrypt.
  */
-forge.aes._updateBlock = _updateBlock;
+forge.aes._updateBlock = _updateBlock$1;
 
 /** Register AES algorithms **/
 
-registerAlgorithm('AES-ECB', forge.cipher.modes.ecb);
-registerAlgorithm('AES-CBC', forge.cipher.modes.cbc);
-registerAlgorithm('AES-CFB', forge.cipher.modes.cfb);
-registerAlgorithm('AES-OFB', forge.cipher.modes.ofb);
-registerAlgorithm('AES-CTR', forge.cipher.modes.ctr);
-registerAlgorithm('AES-GCM', forge.cipher.modes.gcm);
+registerAlgorithm$1('AES-ECB', forge.cipher.modes.ecb);
+registerAlgorithm$1('AES-CBC', forge.cipher.modes.cbc);
+registerAlgorithm$1('AES-CFB', forge.cipher.modes.cfb);
+registerAlgorithm$1('AES-OFB', forge.cipher.modes.ofb);
+registerAlgorithm$1('AES-CTR', forge.cipher.modes.ctr);
+registerAlgorithm$1('AES-GCM', forge.cipher.modes.gcm);
 
-function registerAlgorithm(name, mode) {
+function registerAlgorithm$1(name, mode) {
   var factory = function() {
     return new forge.aes.Algorithm(name, mode);
   };
@@ -5140,7 +5140,7 @@ function _expandKey(key, decrypt) {
  * @param output the updated output block.
  * @param decrypt true to decrypt the block, false to encrypt it.
  */
-function _updateBlock(w, input, output, decrypt) {
+function _updateBlock$1(w, input, output, decrypt) {
   /*
   Cipher(byte in[4*Nb], byte out[4*Nb], word w[Nb*(Nr+1)])
   begin
@@ -5402,7 +5402,7 @@ function _updateBlock(w, input, output, decrypt) {
  *
  * @return the cipher.
  */
-function _createCipher(options) {
+function _createCipher$1(options) {
   options = options || {};
   var mode = (options.mode || 'CBC').toUpperCase();
   var algorithm = 'AES-' + mode;
@@ -7744,7 +7744,7 @@ forge.des = forge.des || {};
  * @return the cipher.
  */
 forge.des.startEncrypting = function(key, iv, output, mode) {
-  var cipher = _createCipher$1({
+  var cipher = _createCipher({
     key: key,
     output: output,
     decrypt: false,
@@ -7769,7 +7769,7 @@ forge.des.startEncrypting = function(key, iv, output, mode) {
  * @return the cipher.
  */
 forge.des.createEncryptionCipher = function(key, mode) {
-  return _createCipher$1({
+  return _createCipher({
     key: key,
     output: null,
     decrypt: false,
@@ -7798,7 +7798,7 @@ forge.des.createEncryptionCipher = function(key, mode) {
  * @return the cipher.
  */
 forge.des.startDecrypting = function(key, iv, output, mode) {
-  var cipher = _createCipher$1({
+  var cipher = _createCipher({
     key: key,
     output: output,
     decrypt: true,
@@ -7823,7 +7823,7 @@ forge.des.startDecrypting = function(key, iv, output, mode) {
  * @return the cipher.
  */
 forge.des.createDecryptionCipher = function(key, mode) {
-  return _createCipher$1({
+  return _createCipher({
     key: key,
     output: null,
     decrypt: true,
@@ -7846,10 +7846,10 @@ forge.des.Algorithm = function(name, mode) {
     blockSize: 8,
     cipher: {
       encrypt: function(inBlock, outBlock) {
-        return _updateBlock$1(self._keys, inBlock, outBlock, false);
+        return _updateBlock(self._keys, inBlock, outBlock, false);
       },
       decrypt: function(inBlock, outBlock) {
-        return _updateBlock$1(self._keys, inBlock, outBlock, true);
+        return _updateBlock(self._keys, inBlock, outBlock, true);
       }
     }
   });
@@ -7883,19 +7883,19 @@ forge.des.Algorithm.prototype.initialize = function(options) {
 
 /** Register DES algorithms **/
 
-registerAlgorithm$1('DES-ECB', forge.cipher.modes.ecb);
-registerAlgorithm$1('DES-CBC', forge.cipher.modes.cbc);
-registerAlgorithm$1('DES-CFB', forge.cipher.modes.cfb);
-registerAlgorithm$1('DES-OFB', forge.cipher.modes.ofb);
-registerAlgorithm$1('DES-CTR', forge.cipher.modes.ctr);
+registerAlgorithm('DES-ECB', forge.cipher.modes.ecb);
+registerAlgorithm('DES-CBC', forge.cipher.modes.cbc);
+registerAlgorithm('DES-CFB', forge.cipher.modes.cfb);
+registerAlgorithm('DES-OFB', forge.cipher.modes.ofb);
+registerAlgorithm('DES-CTR', forge.cipher.modes.ctr);
 
-registerAlgorithm$1('3DES-ECB', forge.cipher.modes.ecb);
-registerAlgorithm$1('3DES-CBC', forge.cipher.modes.cbc);
-registerAlgorithm$1('3DES-CFB', forge.cipher.modes.cfb);
-registerAlgorithm$1('3DES-OFB', forge.cipher.modes.ofb);
-registerAlgorithm$1('3DES-CTR', forge.cipher.modes.ctr);
+registerAlgorithm('3DES-ECB', forge.cipher.modes.ecb);
+registerAlgorithm('3DES-CBC', forge.cipher.modes.cbc);
+registerAlgorithm('3DES-CFB', forge.cipher.modes.cfb);
+registerAlgorithm('3DES-OFB', forge.cipher.modes.ofb);
+registerAlgorithm('3DES-CTR', forge.cipher.modes.ctr);
 
-function registerAlgorithm$1(name, mode) {
+function registerAlgorithm(name, mode) {
   var factory = function() {
     return new forge.des.Algorithm(name, mode);
   };
@@ -8033,7 +8033,7 @@ function _createKeys(key) {
  * @param output the updated output block.
  * @param decrypt true to decrypt the block, false to encrypt it.
  */
-function _updateBlock$1(keys, input, output, decrypt) {
+function _updateBlock(keys, input, output, decrypt) {
   // set up loops for single or triple DES
   var iterations = keys.length === 32 ? 3 : 9;
   var looping;
@@ -8151,7 +8151,7 @@ function _updateBlock$1(keys, input, output, decrypt) {
  *
  * @return the cipher.
  */
-function _createCipher$1(options) {
+function _createCipher(options) {
   options = options || {};
   var mode = (options.mode || 'CBC').toUpperCase();
   var algorithm = 'DES-' + mode;
@@ -9784,17 +9784,17 @@ forge.jsbn = forge.jsbn || {};
 var dbits;
 
 // (public) Constructor
-function BigInteger(a,b,c) {
+function BigInteger$2(a,b,c) {
   this.data = [];
   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);
 }
-forge.jsbn.BigInteger = BigInteger;
+forge.jsbn.BigInteger = BigInteger$2;
 
 // return new, unset BigInteger
-function nbi() { return new BigInteger(null); }
+function nbi() { return new BigInteger$2(null); }
 
 // am: Compute w_j += (x*this_i), propagate carries,
 // c is initial carry, returns final carry.
@@ -9845,27 +9845,27 @@ function am3(i,x,w,j,c,n) {
 // node.js (no browser)
 if(typeof(navigator) === 'undefined')
 {
-   BigInteger.prototype.am = am3;
+   BigInteger$2.prototype.am = am3;
    dbits = 28;
 } else if((navigator.appName == "Microsoft Internet Explorer")) {
-  BigInteger.prototype.am = am2;
+  BigInteger$2.prototype.am = am2;
   dbits = 30;
 } else if((navigator.appName != "Netscape")) {
-  BigInteger.prototype.am = am1;
+  BigInteger$2.prototype.am = am1;
   dbits = 26;
 } else { // Mozilla/Netscape seems to prefer am3
-  BigInteger.prototype.am = am3;
+  BigInteger$2.prototype.am = am3;
   dbits = 28;
 }
 
-BigInteger.prototype.DB = dbits;
-BigInteger.prototype.DM = ((1<<dbits)-1);
-BigInteger.prototype.DV = (1<<dbits);
+BigInteger$2.prototype.DB = dbits;
+BigInteger$2.prototype.DM = ((1<<dbits)-1);
+BigInteger$2.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;
+BigInteger$2.prototype.FV = Math.pow(2,BI_FP);
+BigInteger$2.prototype.F1 = BI_FP-dbits;
+BigInteger$2.prototype.F2 = 2*dbits-BI_FP;
 
 // Digit conversions
 var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
@@ -9938,7 +9938,7 @@ function bnpFromString(s,b) {
     if(sh > 0) this.data[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
   }
   this.clamp();
-  if(mi) BigInteger.ZERO.subTo(this,this);
+  if(mi) BigInteger$2.ZERO.subTo(this,this);
 }
 
 // (protected) clamp off excess high words
@@ -9977,7 +9977,7 @@ function bnToString(b) {
 }
 
 // (public) -this
-function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
+function bnNegate() { var r = nbi(); BigInteger$2.ZERO.subTo(this,r); return r; }
 
 // (public) |this|
 function bnAbs() { return (this.s<0)?this.negate():this; }
@@ -10103,7 +10103,7 @@ function bnpMultiplyTo(a,r) {
   for(i = 0; i < y.t; ++i) r.data[i+x.t] = x.am(0,y.data[i],r,i,0,x.t);
   r.s = 0;
   r.clamp();
-  if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
+  if(this.s != a.s) BigInteger$2.ZERO.subTo(r,r);
 }
 
 // (protected) r = this^2, r != this (HAC 14.16)
@@ -10149,7 +10149,7 @@ function bnpDivRemTo(m,q,r) {
     r.data[r.t++] = 1;
     r.subTo(t,r);
   }
-  BigInteger.ONE.dlShiftTo(ys,t);
+  BigInteger$2.ONE.dlShiftTo(ys,t);
   t.subTo(y,y);	// "negative" y so we can replace sub with am later
   while(y.t < ys) y.data[y.t++] = 0;
   while(--j >= 0) {
@@ -10163,19 +10163,19 @@ function bnpDivRemTo(m,q,r) {
   }
   if(q != null) {
     r.drShiftTo(ys,q);
-    if(ts != ms) BigInteger.ZERO.subTo(q,q);
+    if(ts != ms) BigInteger$2.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);
+  if(ts < 0) BigInteger$2.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);
+  if(this.s < 0 && r.compareTo(BigInteger$2.ZERO) > 0) a.subTo(r,r);
   return r;
 }
 
@@ -10236,7 +10236,7 @@ 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);
+  if(x.s < 0 && r.compareTo(BigInteger$2.ZERO) > 0) this.m.subTo(r,r);
   return r;
 }
 
@@ -10284,7 +10284,7 @@ function bnpIsEven() { return ((this.t>0)?(this.data[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;
+  if(e > 0xffffffff || e < 1) return BigInteger$2.ONE;
   var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
   g.copyTo(r);
   while(--i >= 0) {
@@ -10303,34 +10303,34 @@ function bnModPowInt(e,m) {
 }
 
 // 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;
+BigInteger$2.prototype.copyTo = bnpCopyTo;
+BigInteger$2.prototype.fromInt = bnpFromInt;
+BigInteger$2.prototype.fromString = bnpFromString;
+BigInteger$2.prototype.clamp = bnpClamp;
+BigInteger$2.prototype.dlShiftTo = bnpDLShiftTo;
+BigInteger$2.prototype.drShiftTo = bnpDRShiftTo;
+BigInteger$2.prototype.lShiftTo = bnpLShiftTo;
+BigInteger$2.prototype.rShiftTo = bnpRShiftTo;
+BigInteger$2.prototype.subTo = bnpSubTo;
+BigInteger$2.prototype.multiplyTo = bnpMultiplyTo;
+BigInteger$2.prototype.squareTo = bnpSquareTo;
+BigInteger$2.prototype.divRemTo = bnpDivRemTo;
+BigInteger$2.prototype.invDigit = bnpInvDigit;
+BigInteger$2.prototype.isEven = bnpIsEven;
+BigInteger$2.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;
+BigInteger$2.prototype.toString = bnToString;
+BigInteger$2.prototype.negate = bnNegate;
+BigInteger$2.prototype.abs = bnAbs;
+BigInteger$2.prototype.compareTo = bnCompareTo;
+BigInteger$2.prototype.bitLength = bnBitLength;
+BigInteger$2.prototype.mod = bnMod;
+BigInteger$2.prototype.modPowInt = bnModPowInt;
 
 // "constants"
-BigInteger.ZERO = nbv(0);
-BigInteger.ONE = nbv(1);
+BigInteger$2.ZERO = nbv(0);
+BigInteger$2.ONE = nbv(1);
 
 // jsbn2 lib
 
@@ -10411,7 +10411,7 @@ if(j > 0) {
  this.dMultiply(Math.pow(b,j));
  this.dAddOffset(w,0);
 }
-if(mi) BigInteger.ZERO.subTo(this,this);
+if(mi) BigInteger$2.ZERO.subTo(this,this);
 }
 
 //(protected) alternate constructor
@@ -10422,11 +10422,11 @@ if("number" == typeof b) {
  else {
    this.fromNumber(a,c);
    if(!this.testBit(a-1))  // force MSB set
-     this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);
+     this.bitwiseTo(BigInteger$2.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);
+     if(this.bitLength() > a) this.subTo(BigInteger$2.ONE.shiftLeft(a-1),this);
    }
  }
 } else {
@@ -10566,7 +10566,7 @@ return((this.data[j]&(1<<(n%this.DB)))!=0);
 
 //(protected) this op (1<<n)
 function bnpChangeBit(n,op) {
-var r = BigInteger.ONE.shiftLeft(n);
+var r = BigInteger$2.ONE.shiftLeft(n);
 this.bitwiseTo(r,op,r);
 return r;
 }
@@ -10698,7 +10698,7 @@ function Barrett(m) {
 // setup Barrett
 this.r2 = nbi();
 this.q3 = nbi();
-BigInteger.ONE.dlShiftTo(2*m.t,this.r2);
+BigInteger$2.ONE.dlShiftTo(2*m.t,this.r2);
 this.mu = this.r2.divide(m);
 this.m = m;
 }
@@ -10832,7 +10832,7 @@ 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;
+if((this.isEven() && ac) || m.signum() == 0) return BigInteger$2.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) {
@@ -10862,7 +10862,7 @@ while(u.signum() != 0) {
    d.subTo(b,d);
  }
 }
-if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
+if(v.compareTo(BigInteger$2.ONE) != 0) return BigInteger$2.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;
@@ -10892,7 +10892,7 @@ return x.millerRabin(t);
 
 //(protected) true if probably prime (HAC 4.24, Miller-Rabin)
 function bnpMillerRabin(t) {
-var n1 = this.subtract(BigInteger.ONE);
+var n1 = this.subtract(BigInteger$2.ONE);
 var k = n1.getLowestSetBit();
 if(k <= 0) return false;
 var r = n1.shiftRight(k);
@@ -10901,15 +10901,15 @@ var a;
 for(var i = 0; i < t; ++i) {
  // select witness 'a' at random from between 1 and n1
  do {
-   a = new BigInteger(this.bitLength(), prng);
+   a = new BigInteger$2(this.bitLength(), prng);
  }
- while(a.compareTo(BigInteger.ONE) <= 0 || a.compareTo(n1) >= 0);
+ while(a.compareTo(BigInteger$2.ONE) <= 0 || a.compareTo(n1) >= 0);
  var y = a.modPow(r,this);
- if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
+ if(y.compareTo(BigInteger$2.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(BigInteger$2.ONE) == 0) return false;
    }
    if(y.compareTo(n1) != 0) return false;
  }
@@ -10931,54 +10931,54 @@ function bnGetPrng() {
 }
 
 //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;
+BigInteger$2.prototype.chunkSize = bnpChunkSize;
+BigInteger$2.prototype.toRadix = bnpToRadix;
+BigInteger$2.prototype.fromRadix = bnpFromRadix;
+BigInteger$2.prototype.fromNumber = bnpFromNumber;
+BigInteger$2.prototype.bitwiseTo = bnpBitwiseTo;
+BigInteger$2.prototype.changeBit = bnpChangeBit;
+BigInteger$2.prototype.addTo = bnpAddTo;
+BigInteger$2.prototype.dMultiply = bnpDMultiply;
+BigInteger$2.prototype.dAddOffset = bnpDAddOffset;
+BigInteger$2.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
+BigInteger$2.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
+BigInteger$2.prototype.modInt = bnpModInt;
+BigInteger$2.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;
+BigInteger$2.prototype.clone = bnClone;
+BigInteger$2.prototype.intValue = bnIntValue;
+BigInteger$2.prototype.byteValue = bnByteValue;
+BigInteger$2.prototype.shortValue = bnShortValue;
+BigInteger$2.prototype.signum = bnSigNum;
+BigInteger$2.prototype.toByteArray = bnToByteArray;
+BigInteger$2.prototype.equals = bnEquals;
+BigInteger$2.prototype.min = bnMin;
+BigInteger$2.prototype.max = bnMax;
+BigInteger$2.prototype.and = bnAnd;
+BigInteger$2.prototype.or = bnOr;
+BigInteger$2.prototype.xor = bnXor;
+BigInteger$2.prototype.andNot = bnAndNot;
+BigInteger$2.prototype.not = bnNot;
+BigInteger$2.prototype.shiftLeft = bnShiftLeft;
+BigInteger$2.prototype.shiftRight = bnShiftRight;
+BigInteger$2.prototype.getLowestSetBit = bnGetLowestSetBit;
+BigInteger$2.prototype.bitCount = bnBitCount;
+BigInteger$2.prototype.testBit = bnTestBit;
+BigInteger$2.prototype.setBit = bnSetBit;
+BigInteger$2.prototype.clearBit = bnClearBit;
+BigInteger$2.prototype.flipBit = bnFlipBit;
+BigInteger$2.prototype.add = bnAdd;
+BigInteger$2.prototype.subtract = bnSubtract;
+BigInteger$2.prototype.multiply = bnMultiply;
+BigInteger$2.prototype.divide = bnDivide;
+BigInteger$2.prototype.remainder = bnRemainder;
+BigInteger$2.prototype.divideAndRemainder = bnDivideAndRemainder;
+BigInteger$2.prototype.modPow = bnModPow;
+BigInteger$2.prototype.modInverse = bnModInverse;
+BigInteger$2.prototype.pow = bnPow;
+BigInteger$2.prototype.gcd = bnGCD;
+BigInteger$2.prototype.isProbablePrime = bnIsProbablePrime;
 
 /**
  * Secure Hash Algorithm with 160-bit digest (SHA-1) implementation.
@@ -11938,7 +11938,7 @@ if(typeof BigInteger$1 === 'undefined') {
 var _crypto = forge.util.isNodejs ? require$$0__default : null;
 
 // shortcut for asn.1 API
-var asn1 = forge.asn1;
+var asn1$2 = forge.asn1;
 
 // shortcut for util API
 var util = forge.util;
@@ -11948,43 +11948,43 @@ var util = forge.util;
  */
 forge.pki = forge.pki || {};
 forge.pki.rsa = forge.rsa = forge.rsa || {};
-var pki = forge.pki;
+var pki$1 = forge.pki;
 
 // for finding primes, which are 30k+i for i = 1, 7, 11, 13, 17, 19, 23, 29
 var GCD_30_DELTA = [6, 4, 2, 4, 2, 4, 6, 2];
 
 // validator for a PrivateKeyInfo structure
-var privateKeyValidator = {
+var privateKeyValidator$2 = {
   // PrivateKeyInfo
   name: 'PrivateKeyInfo',
-  tagClass: asn1.Class.UNIVERSAL,
-  type: asn1.Type.SEQUENCE,
+  tagClass: asn1$2.Class.UNIVERSAL,
+  type: asn1$2.Type.SEQUENCE,
   constructed: true,
   value: [{
     // Version (INTEGER)
     name: 'PrivateKeyInfo.version',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyVersion'
   }, {
     // privateKeyAlgorithm
     name: 'PrivateKeyInfo.privateKeyAlgorithm',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.SEQUENCE,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.SEQUENCE,
     constructed: true,
     value: [{
       name: 'AlgorithmIdentifier.algorithm',
-      tagClass: asn1.Class.UNIVERSAL,
-      type: asn1.Type.OID,
+      tagClass: asn1$2.Class.UNIVERSAL,
+      type: asn1$2.Type.OID,
       constructed: false,
       capture: 'privateKeyOid'
     }]
   }, {
     // PrivateKey
     name: 'PrivateKeyInfo',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.OCTETSTRING,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.OCTETSTRING,
     constructed: false,
     capture: 'privateKey'
   }]
@@ -11994,70 +11994,70 @@ var privateKeyValidator = {
 var rsaPrivateKeyValidator = {
   // RSAPrivateKey
   name: 'RSAPrivateKey',
-  tagClass: asn1.Class.UNIVERSAL,
-  type: asn1.Type.SEQUENCE,
+  tagClass: asn1$2.Class.UNIVERSAL,
+  type: asn1$2.Type.SEQUENCE,
   constructed: true,
   value: [{
     // Version (INTEGER)
     name: 'RSAPrivateKey.version',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyVersion'
   }, {
     // modulus (n)
     name: 'RSAPrivateKey.modulus',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyModulus'
   }, {
     // publicExponent (e)
     name: 'RSAPrivateKey.publicExponent',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyPublicExponent'
   }, {
     // privateExponent (d)
     name: 'RSAPrivateKey.privateExponent',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyPrivateExponent'
   }, {
     // prime1 (p)
     name: 'RSAPrivateKey.prime1',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyPrime1'
   }, {
     // prime2 (q)
     name: 'RSAPrivateKey.prime2',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyPrime2'
   }, {
     // exponent1 (d mod (p-1))
     name: 'RSAPrivateKey.exponent1',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyExponent1'
   }, {
     // exponent2 (d mod (q-1))
     name: 'RSAPrivateKey.exponent2',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyExponent2'
   }, {
     // coefficient ((inverse of q) mod p)
     name: 'RSAPrivateKey.coefficient',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyCoefficient'
   }]
@@ -12067,21 +12067,21 @@ var rsaPrivateKeyValidator = {
 var rsaPublicKeyValidator = {
   // RSAPublicKey
   name: 'RSAPublicKey',
-  tagClass: asn1.Class.UNIVERSAL,
-  type: asn1.Type.SEQUENCE,
+  tagClass: asn1$2.Class.UNIVERSAL,
+  type: asn1$2.Type.SEQUENCE,
   constructed: true,
   value: [{
     // modulus (n)
     name: 'RSAPublicKey.modulus',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'publicKeyModulus'
   }, {
     // publicExponent (e)
     name: 'RSAPublicKey.exponent',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.INTEGER,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.INTEGER,
     constructed: false,
     capture: 'publicKeyExponent'
   }]
@@ -12089,35 +12089,35 @@ var rsaPublicKeyValidator = {
 
 // validator for an SubjectPublicKeyInfo structure
 // Note: Currently only works with an RSA public key
-var publicKeyValidator = forge.pki.rsa.publicKeyValidator = {
+var publicKeyValidator$2 = forge.pki.rsa.publicKeyValidator = {
   name: 'SubjectPublicKeyInfo',
-  tagClass: asn1.Class.UNIVERSAL,
-  type: asn1.Type.SEQUENCE,
+  tagClass: asn1$2.Class.UNIVERSAL,
+  type: asn1$2.Type.SEQUENCE,
   constructed: true,
   captureAsn1: 'subjectPublicKeyInfo',
   value: [{
     name: 'SubjectPublicKeyInfo.AlgorithmIdentifier',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.SEQUENCE,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.SEQUENCE,
     constructed: true,
     value: [{
       name: 'AlgorithmIdentifier.algorithm',
-      tagClass: asn1.Class.UNIVERSAL,
-      type: asn1.Type.OID,
+      tagClass: asn1$2.Class.UNIVERSAL,
+      type: asn1$2.Type.OID,
       constructed: false,
       capture: 'publicKeyOid'
     }]
   }, {
     // subjectPublicKey
     name: 'SubjectPublicKeyInfo.subjectPublicKey',
-    tagClass: asn1.Class.UNIVERSAL,
-    type: asn1.Type.BITSTRING,
+    tagClass: asn1$2.Class.UNIVERSAL,
+    type: asn1$2.Type.BITSTRING,
     constructed: false,
     value: [{
       // RSAPublicKey
       name: 'SubjectPublicKeyInfo.subjectPublicKey.RSAPublicKey',
-      tagClass: asn1.Class.UNIVERSAL,
-      type: asn1.Type.SEQUENCE,
+      tagClass: asn1$2.Class.UNIVERSAL,
+      type: asn1$2.Type.SEQUENCE,
       constructed: true,
       optional: true,
       captureAsn1: 'rsaPublicKey'
@@ -12145,32 +12145,32 @@ var publicKeyValidator = forge.pki.rsa.publicKeyValidator = {
 var emsaPkcs1v15encode = function(md) {
   // get the oid for the algorithm
   var oid;
-  if(md.algorithm in pki.oids) {
-    oid = pki.oids[md.algorithm];
+  if(md.algorithm in pki$1.oids) {
+    oid = pki$1.oids[md.algorithm];
   } else {
     var error = new Error('Unknown message digest algorithm.');
     error.algorithm = md.algorithm;
     throw error;
   }
-  var oidBytes = asn1.oidToDer(oid).getBytes();
+  var oidBytes = asn1$2.oidToDer(oid).getBytes();
 
   // create the digest info
-  var digestInfo = asn1.create(
-    asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
-  var digestAlgorithm = asn1.create(
-    asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
-  digestAlgorithm.value.push(asn1.create(
-    asn1.Class.UNIVERSAL, asn1.Type.OID, false, oidBytes));
-  digestAlgorithm.value.push(asn1.create(
-    asn1.Class.UNIVERSAL, asn1.Type.NULL, false, ''));
-  var digest = asn1.create(
-    asn1.Class.UNIVERSAL, asn1.Type.OCTETSTRING,
+  var digestInfo = asn1$2.create(
+    asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, []);
+  var digestAlgorithm = asn1$2.create(
+    asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, []);
+  digestAlgorithm.value.push(asn1$2.create(
+    asn1$2.Class.UNIVERSAL, asn1$2.Type.OID, false, oidBytes));
+  digestAlgorithm.value.push(asn1$2.create(
+    asn1$2.Class.UNIVERSAL, asn1$2.Type.NULL, false, ''));
+  var digest = asn1$2.create(
+    asn1$2.Class.UNIVERSAL, asn1$2.Type.OCTETSTRING,
     false, md.digest().getBytes());
   digestInfo.value.push(digestAlgorithm);
   digestInfo.value.push(digest);
 
   // encode digest info
-  return asn1.toDer(digestInfo).getBytes();
+  return asn1$2.toDer(digestInfo).getBytes();
 };
 
 /**
@@ -12338,7 +12338,7 @@ var _modPow = function(x, key, pub) {
  *
  * @return the encrypted bytes as a string.
  */
-pki.rsa.encrypt = function(m, key, bt) {
+pki$1.rsa.encrypt = function(m, key, bt) {
   var pub = bt;
   var eb;
 
@@ -12393,7 +12393,7 @@ pki.rsa.encrypt = function(m, key, bt) {
  *
  * @return the decrypted message as a byte string.
  */
-pki.rsa.decrypt = function(ed, key, pub, ml) {
+pki$1.rsa.decrypt = function(ed, key, pub, ml) {
   // get the length of the modulus in bytes
   var k = Math.ceil(key.n.bitLength() / 8);
 
@@ -12453,7 +12453,7 @@ pki.rsa.decrypt = function(ed, key, pub, ml) {
  *
  * @return the state object to use to generate the key-pair.
  */
-pki.rsa.createKeyPairGenerationState = function(bits, e, options) {
+pki$1.rsa.createKeyPairGenerationState = function(bits, e, options) {
   // TODO: migrate step-based prime generation code to forge.prime
 
   // set default bits
@@ -12532,7 +12532,7 @@ pki.rsa.createKeyPairGenerationState = function(bits, e, options) {
  *
  * @return true if the key-generation completed, false if not.
  */
-pki.rsa.stepKeyPairGenerationState = function(state, n) {
+pki$1.rsa.stepKeyPairGenerationState = function(state, n) {
   // set default algorithm if not set
   if(!('algorithm' in state)) {
     state.algorithm = 'PRIMEINC';
@@ -12655,11 +12655,11 @@ pki.rsa.stepKeyPairGenerationState = function(state, n) {
       // set keys
       var d = state.e.modInverse(state.phi);
       state.keys = {
-        privateKey: pki.rsa.setPrivateKey(
+        privateKey: pki$1.rsa.setPrivateKey(
           state.n, state.e, d, state.p, state.q,
           d.mod(state.p1), d.mod(state.q1),
           state.q.modInverse(state.p)),
-        publicKey: pki.rsa.setPublicKey(state.n, state.e)
+        publicKey: pki$1.rsa.setPublicKey(state.n, state.e)
       };
     }
 
@@ -12702,7 +12702,7 @@ pki.rsa.stepKeyPairGenerationState = function(state, n) {
  *
  * @return an object with privateKey and publicKey properties.
  */
-pki.rsa.generateKeyPair = function(bits, e, options, callback) {
+pki$1.rsa.generateKeyPair = function(bits, e, options, callback) {
   // (bits), (options), (callback)
   if(arguments.length === 1) {
     if(typeof bits === 'object') {
@@ -12771,8 +12771,8 @@ pki.rsa.generateKeyPair = function(bits, e, options, callback) {
             return callback(err);
           }
           callback(null, {
-            privateKey: pki.privateKeyFromPem(priv),
-            publicKey: pki.publicKeyFromPem(pub)
+            privateKey: pki$1.privateKeyFromPem(priv),
+            publicKey: pki$1.publicKeyFromPem(pub)
           });
         });
       }
@@ -12793,11 +12793,11 @@ pki.rsa.generateKeyPair = function(bits, e, options, callback) {
           callback(err);
         }).then(function(pkcs8) {
           if(pkcs8) {
-            var privateKey = pki.privateKeyFromAsn1(
-              asn1.fromDer(forge.util.createBuffer(pkcs8)));
+            var privateKey = pki$1.privateKeyFromAsn1(
+              asn1$2.fromDer(forge.util.createBuffer(pkcs8)));
             callback(null, {
               privateKey: privateKey,
-              publicKey: pki.setRsaPublicKey(privateKey.n, privateKey.e)
+              publicKey: pki$1.setRsaPublicKey(privateKey.n, privateKey.e)
             });
           }
         });
@@ -12816,11 +12816,11 @@ pki.rsa.generateKeyPair = function(bits, e, options, callback) {
             'pkcs8', pair.privateKey);
           exportOp.oncomplete = function(e) {
             var pkcs8 = e.target.result;
-            var privateKey = pki.privateKeyFromAsn1(
-              asn1.fromDer(forge.util.createBuffer(pkcs8)));
+            var privateKey = pki$1.privateKeyFromAsn1(
+              asn1$2.fromDer(forge.util.createBuffer(pkcs8)));
             callback(null, {
               privateKey: privateKey,
-              publicKey: pki.setRsaPublicKey(privateKey.n, privateKey.e)
+              publicKey: pki$1.setRsaPublicKey(privateKey.n, privateKey.e)
             });
           };
           exportOp.onerror = function(err) {
@@ -12848,17 +12848,17 @@ pki.rsa.generateKeyPair = function(bits, e, options, callback) {
           }
         });
         return {
-          privateKey: pki.privateKeyFromPem(keypair.privateKey),
-          publicKey: pki.publicKeyFromPem(keypair.publicKey)
+          privateKey: pki$1.privateKeyFromPem(keypair.privateKey),
+          publicKey: pki$1.publicKeyFromPem(keypair.publicKey)
         };
       }
     }
   }
 
   // use JavaScript implementation
-  var state = pki.rsa.createKeyPairGenerationState(bits, e, options);
+  var state = pki$1.rsa.createKeyPairGenerationState(bits, e, options);
   if(!callback) {
-    pki.rsa.stepKeyPairGenerationState(state, 0);
+    pki$1.rsa.stepKeyPairGenerationState(state, 0);
     return state.keys;
   }
   _generateKeyPair(state, options, callback);
@@ -12872,7 +12872,7 @@ pki.rsa.generateKeyPair = function(bits, e, options, callback) {
  *
  * @return the public key.
  */
-pki.setRsaPublicKey = pki.rsa.setPublicKey = function(n, e) {
+pki$1.setRsaPublicKey = pki$1.rsa.setPublicKey = function(n, e) {
   var key = {
     n: n,
     e: e
@@ -12922,7 +12922,7 @@ pki.setRsaPublicKey = pki.rsa.setPublicKey = function(n, e) {
 
     // do scheme-based encoding then rsa encryption
     var e = scheme.encode(data, key, true);
-    return pki.rsa.encrypt(e, key, true);
+    return pki$1.rsa.encrypt(e, key, true);
   };
 
   /**
@@ -12969,7 +12969,7 @@ pki.setRsaPublicKey = pki.rsa.setPublicKey = function(n, e) {
           // remove padding
           d = _decodePkcs1_v1_5(d, key, true);
           // d is ASN.1 BER-encoded DigestInfo
-          var obj = asn1.fromDer(d);
+          var obj = asn1$2.fromDer(d);
           // compare the given digest to the decrypted one
           return digest === obj.value[1].value;
         }
@@ -12985,7 +12985,7 @@ pki.setRsaPublicKey = pki.rsa.setPublicKey = function(n, e) {
     }
 
     // do rsa decryption w/o any decoding, then verify -- which does decoding
-    var d = pki.rsa.decrypt(signature, key, true, false);
+    var d = pki$1.rsa.decrypt(signature, key, true, false);
     return scheme.verify(digest, d, key.n.bitLength());
   };
 
@@ -13007,7 +13007,7 @@ pki.setRsaPublicKey = pki.rsa.setPublicKey = function(n, e) {
  *
  * @return the private key.
  */
-pki.setRsaPrivateKey = pki.rsa.setPrivateKey = function(
+pki$1.setRsaPrivateKey = pki$1.rsa.setPrivateKey = function(
   n, e, d, p, q, dP, dQ, qInv) {
   var key = {
     n: n,
@@ -13041,7 +13041,7 @@ pki.setRsaPrivateKey = pki.rsa.setPrivateKey = function(
     }
 
     // do rsa decryption w/o any decoding
-    var d = pki.rsa.decrypt(data, key, false, false);
+    var d = pki$1.rsa.decrypt(data, key, false, false);
 
     if(scheme === 'RSAES-PKCS1-V1_5') {
       scheme = {decode: _decodePkcs1_v1_5};
@@ -13103,7 +13103,7 @@ pki.setRsaPrivateKey = pki.rsa.setPrivateKey = function(
 
     // encode and then encrypt
     var d = scheme.encode(md, key.n.bitLength());
-    return pki.rsa.encrypt(d, key, bt);
+    return pki$1.rsa.encrypt(d, key, bt);
   };
 
   return key;
@@ -13116,22 +13116,22 @@ pki.setRsaPrivateKey = pki.rsa.setPrivateKey = function(
  *
  * @return the ASN.1 PrivateKeyInfo.
  */
-pki.wrapRsaPrivateKey = function(rsaKey) {
+pki$1.wrapRsaPrivateKey = function(rsaKey) {
   // PrivateKeyInfo
-  return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
+  return asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, [
     // version (0)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
-      asn1.integerToDer(0).getBytes()),
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
+      asn1$2.integerToDer(0).getBytes()),
     // privateKeyAlgorithm
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
-      asn1.create(
-        asn1.Class.UNIVERSAL, asn1.Type.OID, false,
-        asn1.oidToDer(pki.oids.rsaEncryption).getBytes()),
-      asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, '')
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, [
+      asn1$2.create(
+        asn1$2.Class.UNIVERSAL, asn1$2.Type.OID, false,
+        asn1$2.oidToDer(pki$1.oids.rsaEncryption).getBytes()),
+      asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.NULL, false, '')
     ]),
     // PrivateKey
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.OCTETSTRING, false,
-      asn1.toDer(rsaKey).getBytes())
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.OCTETSTRING, false,
+      asn1$2.toDer(rsaKey).getBytes())
   ]);
 };
 
@@ -13143,18 +13143,18 @@ pki.wrapRsaPrivateKey = function(rsaKey) {
  *
  * @return the private key.
  */
-pki.privateKeyFromAsn1 = function(obj) {
+pki$1.privateKeyFromAsn1 = function(obj) {
   // get PrivateKeyInfo
   var capture = {};
   var errors = [];
-  if(asn1.validate(obj, privateKeyValidator, capture, errors)) {
-    obj = asn1.fromDer(forge.util.createBuffer(capture.privateKey));
+  if(asn1$2.validate(obj, privateKeyValidator$2, capture, errors)) {
+    obj = asn1$2.fromDer(forge.util.createBuffer(capture.privateKey));
   }
 
   // get RSAPrivateKey
   capture = {};
   errors = [];
-  if(!asn1.validate(obj, rsaPrivateKeyValidator, capture, errors)) {
+  if(!asn1$2.validate(obj, rsaPrivateKeyValidator, capture, errors)) {
     var error = new Error('Cannot read private key. ' +
       'ASN.1 object does not contain an RSAPrivateKey.');
     error.errors = errors;
@@ -13175,7 +13175,7 @@ pki.privateKeyFromAsn1 = function(obj) {
   qInv = forge.util.createBuffer(capture.privateKeyCoefficient).toHex();
 
   // set private key
-  return pki.setRsaPrivateKey(
+  return pki$1.setRsaPrivateKey(
     new BigInteger$1(n, 16),
     new BigInteger$1(e, 16),
     new BigInteger$1(d, 16),
@@ -13193,35 +13193,35 @@ pki.privateKeyFromAsn1 = function(obj) {
  *
  * @return the ASN.1 representation of an RSAPrivateKey.
  */
-pki.privateKeyToAsn1 = pki.privateKeyToRSAPrivateKey = function(key) {
+pki$1.privateKeyToAsn1 = pki$1.privateKeyToRSAPrivateKey = function(key) {
   // RSAPrivateKey
-  return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
+  return asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, [
     // version (0 = only 2 primes, 1 multiple primes)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
-      asn1.integerToDer(0).getBytes()),
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
+      asn1$2.integerToDer(0).getBytes()),
     // modulus (n)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.n)),
     // publicExponent (e)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.e)),
     // privateExponent (d)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.d)),
     // privateKeyPrime1 (p)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.p)),
     // privateKeyPrime2 (q)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.q)),
     // privateKeyExponent1 (dP)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.dP)),
     // privateKeyExponent2 (dQ)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.dQ)),
     // coefficient (qInv)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.qInv))
   ]);
 };
@@ -13233,14 +13233,14 @@ pki.privateKeyToAsn1 = pki.privateKeyToRSAPrivateKey = function(key) {
  *
  * @return the public key.
  */
-pki.publicKeyFromAsn1 = function(obj) {
+pki$1.publicKeyFromAsn1 = function(obj) {
   // get SubjectPublicKeyInfo
   var capture = {};
   var errors = [];
-  if(asn1.validate(obj, publicKeyValidator, capture, errors)) {
+  if(asn1$2.validate(obj, publicKeyValidator$2, capture, errors)) {
     // get oid
-    var oid = asn1.derToOid(capture.publicKeyOid);
-    if(oid !== pki.oids.rsaEncryption) {
+    var oid = asn1$2.derToOid(capture.publicKeyOid);
+    if(oid !== pki$1.oids.rsaEncryption) {
       var error = new Error('Cannot read public key. Unknown OID.');
       error.oid = oid;
       throw error;
@@ -13250,7 +13250,7 @@ pki.publicKeyFromAsn1 = function(obj) {
 
   // get RSA params
   errors = [];
-  if(!asn1.validate(obj, rsaPublicKeyValidator, capture, errors)) {
+  if(!asn1$2.validate(obj, rsaPublicKeyValidator, capture, errors)) {
     var error = new Error('Cannot read public key. ' +
       'ASN.1 object does not contain an RSAPublicKey.');
     error.errors = errors;
@@ -13262,7 +13262,7 @@ pki.publicKeyFromAsn1 = function(obj) {
   var e = forge.util.createBuffer(capture.publicKeyExponent).toHex();
 
   // set public key
-  return pki.setRsaPublicKey(
+  return pki$1.setRsaPublicKey(
     new BigInteger$1(n, 16),
     new BigInteger$1(e, 16));
 };
@@ -13274,20 +13274,20 @@ pki.publicKeyFromAsn1 = function(obj) {
  *
  * @return the asn1 representation of a SubjectPublicKeyInfo.
  */
-pki.publicKeyToAsn1 = pki.publicKeyToSubjectPublicKeyInfo = function(key) {
+pki$1.publicKeyToAsn1 = pki$1.publicKeyToSubjectPublicKeyInfo = function(key) {
   // SubjectPublicKeyInfo
-  return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
+  return asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, [
     // AlgorithmIdentifier
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, [
       // algorithm
-      asn1.create(asn1.Class.UNIVERSAL, asn1.Type.OID, false,
-        asn1.oidToDer(pki.oids.rsaEncryption).getBytes()),
+      asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.OID, false,
+        asn1$2.oidToDer(pki$1.oids.rsaEncryption).getBytes()),
       // parameters (null)
-      asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, '')
+      asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.NULL, false, '')
     ]),
     // subjectPublicKey
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.BITSTRING, false, [
-      pki.publicKeyToRSAPublicKey(key)
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.BITSTRING, false, [
+      pki$1.publicKeyToRSAPublicKey(key)
     ])
   ]);
 };
@@ -13299,14 +13299,14 @@ pki.publicKeyToAsn1 = pki.publicKeyToSubjectPublicKeyInfo = function(key) {
  *
  * @return the asn1 representation of a RSAPublicKey.
  */
-pki.publicKeyToRSAPublicKey = function(key) {
+pki$1.publicKeyToRSAPublicKey = function(key) {
   // RSAPublicKey
-  return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
+  return asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.SEQUENCE, true, [
     // modulus (n)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.n)),
     // publicExponent (e)
-    asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false,
+    asn1$2.create(asn1$2.Class.UNIVERSAL, asn1$2.Type.INTEGER, false,
       _bnToBytes(key.e))
   ]);
 };
@@ -13575,11 +13575,11 @@ function _generateKeyPair(state, options, callback) {
     // set keys
     var d = state.e.modInverse(state.phi);
     state.keys = {
-      privateKey: pki.rsa.setPrivateKey(
+      privateKey: pki$1.rsa.setPrivateKey(
         state.n, state.e, d, state.p, state.q,
         d.mod(state.p1), d.mod(state.q1),
         state.q.modInverse(state.p)),
-      publicKey: pki.rsa.setPublicKey(state.n, state.e)
+      publicKey: pki$1.rsa.setPublicKey(state.n, state.e)
     };
 
     callback(null, state.keys);
@@ -13713,9 +13713,9 @@ function _intToUint8Array(x) {
 var asn1$1 = forge.asn1;
 
 /* Password-based encryption implementation. */
-var pki$1 = forge.pki = forge.pki || {};
-pki$1.pbe = forge.pbe = forge.pbe || {};
-var oids = pki$1.oids;
+var pki = forge.pki = forge.pki || {};
+pki.pbe = forge.pbe = forge.pbe || {};
+var oids = pki.oids;
 
 // validator for an EncryptedPrivateKeyInfo structure
 // Note: Currently only works w/algorithm params
@@ -13891,7 +13891,7 @@ var pkcs12PbeParamsValidator = {
  *
  * @return the ASN.1 EncryptedPrivateKeyInfo.
  */
-pki$1.encryptPrivateKeyInfo = function(obj, password, options) {
+pki.encryptPrivateKeyInfo = function(obj, password, options) {
   // set default options
   options = options || {};
   options.saltSize = options.saltSize || 8;
@@ -13983,8 +13983,8 @@ pki$1.encryptPrivateKeyInfo = function(obj, password, options) {
     dkLen = 24;
 
     var saltBytes = new forge.util.ByteBuffer(salt);
-    var dk = pki$1.pbe.generatePkcs12Key(password, saltBytes, 1, count, dkLen);
-    var iv = pki$1.pbe.generatePkcs12Key(password, saltBytes, 2, count, dkLen);
+    var dk = pki.pbe.generatePkcs12Key(password, saltBytes, 1, count, dkLen);
+    var iv = pki.pbe.generatePkcs12Key(password, saltBytes, 2, count, dkLen);
     var cipher = forge.des.createEncryptionCipher(dk);
     cipher.start(iv);
     cipher.update(asn1$1.toDer(obj));
@@ -14029,7 +14029,7 @@ pki$1.encryptPrivateKeyInfo = function(obj, password, options) {
  *
  * @return the ASN.1 PrivateKeyInfo on success, null on failure.
  */
-pki$1.decryptPrivateKeyInfo = function(obj, password) {
+pki.decryptPrivateKeyInfo = function(obj, password) {
   var rval = null;
 
   // get PBE params
@@ -14044,7 +14044,7 @@ pki$1.decryptPrivateKeyInfo = function(obj, password) {
 
   // get cipher
   var oid = asn1$1.derToOid(capture.encryptionOid);
-  var cipher = pki$1.pbe.getCipher(oid, capture.encryptionParams, password);
+  var cipher = pki.pbe.getCipher(oid, capture.encryptionParams, password);
 
   // get encrypted data
   var encrypted = forge.util.createBuffer(capture.encryptedData);
@@ -14065,7 +14065,7 @@ pki$1.decryptPrivateKeyInfo = function(obj, password) {
  *
  * @return the PEM-formatted encrypted private key.
  */
-pki$1.encryptedPrivateKeyToPem = function(epki, maxline) {
+pki.encryptedPrivateKeyToPem = function(epki, maxline) {
   // convert to DER, then PEM-encode
   var msg = {
     type: 'ENCRYPTED PRIVATE KEY',
@@ -14082,7 +14082,7 @@ pki$1.encryptedPrivateKeyToPem = function(epki, maxline) {
  *
  * @return the ASN.1 EncryptedPrivateKeyInfo.
  */
-pki$1.encryptedPrivateKeyFromPem = function(pem) {
+pki.encryptedPrivateKeyFromPem = function(pem) {
   var msg = forge.pem.decode(pem)[0];
 
   if(msg.type !== 'ENCRYPTED PRIVATE KEY') {
@@ -14126,14 +14126,14 @@ pki$1.encryptedPrivateKeyFromPem = function(pem) {
  *
  * @return the PEM-encoded ASN.1 EncryptedPrivateKeyInfo.
  */
-pki$1.encryptRsaPrivateKey = function(rsaKey, password, options) {
+pki.encryptRsaPrivateKey = function(rsaKey, password, options) {
   // standard PKCS#8
   options = options || {};
   if(!options.legacy) {
     // encrypt PrivateKeyInfo
-    var rval = pki$1.wrapRsaPrivateKey(pki$1.privateKeyToAsn1(rsaKey));
-    rval = pki$1.encryptPrivateKeyInfo(rval, password, options);
-    return pki$1.encryptedPrivateKeyToPem(rval);
+    var rval = pki.wrapRsaPrivateKey(pki.privateKeyToAsn1(rsaKey));
+    rval = pki.encryptPrivateKeyInfo(rval, password, options);
+    return pki.encryptedPrivateKeyToPem(rval);
   }
 
   // legacy non-PKCS#8
@@ -14183,7 +14183,7 @@ pki$1.encryptRsaPrivateKey = function(rsaKey, password, options) {
   var dk = forge.pbe.opensslDeriveBytes(password, iv.substr(0, 8), dkLen);
   var cipher = cipherFn(dk);
   cipher.start(iv);
-  cipher.update(asn1$1.toDer(pki$1.privateKeyToAsn1(rsaKey)));
+  cipher.update(asn1$1.toDer(pki.privateKeyToAsn1(rsaKey)));
   cipher.finish();
 
   var msg = {
@@ -14209,7 +14209,7 @@ pki$1.encryptRsaPrivateKey = function(rsaKey, password, options) {
  *
  * @return the RSA key on success, null on failure.
  */
-pki$1.decryptRsaPrivateKey = function(pem, password) {
+pki.decryptRsaPrivateKey = function(pem, password) {
   var rval = null;
 
   var msg = forge.pem.decode(pem)[0];
@@ -14288,14 +14288,14 @@ pki$1.decryptRsaPrivateKey = function(pem, password) {
   }
 
   if(msg.type === 'ENCRYPTED PRIVATE KEY') {
-    rval = pki$1.decryptPrivateKeyInfo(asn1$1.fromDer(rval), password);
+    rval = pki.decryptPrivateKeyInfo(asn1$1.fromDer(rval), password);
   } else {
     // decryption already performed above
     rval = asn1$1.fromDer(rval);
   }
 
   if(rval !== null) {
-    rval = pki$1.privateKeyFromAsn1(rval);
+    rval = pki.privateKeyFromAsn1(rval);
   }
 
   return rval;
@@ -14314,7 +14314,7 @@ pki$1.decryptRsaPrivateKey = function(pem, password) {
  *
  * @return a ByteBuffer with the bytes derived from the password.
  */
-pki$1.pbe.generatePkcs12Key = function(password, salt, id, iter, n, md) {
+pki.pbe.generatePkcs12Key = function(password, salt, id, iter, n, md) {
   var j, l;
 
   if(typeof md === 'undefined' || md === null) {
@@ -14426,14 +14426,14 @@ pki$1.pbe.generatePkcs12Key = function(password, salt, id, iter, n, md) {
  *
  * @return new cipher object instance.
  */
-pki$1.pbe.getCipher = function(oid, params, password) {
+pki.pbe.getCipher = function(oid, params, password) {
   switch(oid) {
-  case pki$1.oids['pkcs5PBES2']:
-    return pki$1.pbe.getCipherForPBES2(oid, params, password);
+  case pki.oids['pkcs5PBES2']:
+    return pki.pbe.getCipherForPBES2(oid, params, password);
 
-  case pki$1.oids['pbeWithSHAAnd3-KeyTripleDES-CBC']:
-  case pki$1.oids['pbewithSHAAnd40BitRC2-CBC']:
-    return pki$1.pbe.getCipherForPKCS12PBE(oid, params, password);
+  case pki.oids['pbeWithSHAAnd3-KeyTripleDES-CBC']:
+  case pki.oids['pbewithSHAAnd40BitRC2-CBC']:
+    return pki.pbe.getCipherForPKCS12PBE(oid, params, password);
 
   default:
     var error = new Error('Cannot read encrypted PBE data block. Unsupported OID.');
@@ -14459,7 +14459,7 @@ pki$1.pbe.getCipher = function(oid, params, password) {
  *
  * @return new cipher object instance.
  */
-pki$1.pbe.getCipherForPBES2 = function(oid, params, password) {
+pki.pbe.getCipherForPBES2 = function(oid, params, password) {
   // get PBE params
   var capture = {};
   var errors = [];
@@ -14472,7 +14472,7 @@ pki$1.pbe.getCipherForPBES2 = function(oid, params, password) {
 
   // check oids
   oid = asn1$1.derToOid(capture.kdfOid);
-  if(oid !== pki$1.oids['pkcs5PBKDF2']) {
+  if(oid !== pki.oids['pkcs5PBKDF2']) {
     var error = new Error('Cannot read encrypted private key. ' +
       'Unsupported key derivation function OID.');
     error.oid = oid;
@@ -14480,11 +14480,11 @@ pki$1.pbe.getCipherForPBES2 = function(oid, params, password) {
     throw error;
   }
   oid = asn1$1.derToOid(capture.encOid);
-  if(oid !== pki$1.oids['aes128-CBC'] &&
-    oid !== pki$1.oids['aes192-CBC'] &&
-    oid !== pki$1.oids['aes256-CBC'] &&
-    oid !== pki$1.oids['des-EDE3-CBC'] &&
-    oid !== pki$1.oids['desCBC']) {
+  if(oid !== pki.oids['aes128-CBC'] &&
+    oid !== pki.oids['aes192-CBC'] &&
+    oid !== pki.oids['aes256-CBC'] &&
+    oid !== pki.oids['des-EDE3-CBC'] &&
+    oid !== pki.oids['desCBC']) {
     var error = new Error('Cannot read encrypted private key. ' +
       'Unsupported encryption scheme OID.');
     error.oid = oid;
@@ -14499,7 +14499,7 @@ pki$1.pbe.getCipherForPBES2 = function(oid, params, password) {
   count = count.getInt(count.length() << 3);
   var dkLen;
   var cipherFn;
-  switch(pki$1.oids[oid]) {
+  switch(pki.oids[oid]) {
   case 'aes128-CBC':
     dkLen = 16;
     cipherFn = forge.aes.createDecryptionCipher;
@@ -14546,7 +14546,7 @@ pki$1.pbe.getCipherForPBES2 = function(oid, params, password) {
  *
  * @return the new cipher object instance.
  */
-pki$1.pbe.getCipherForPKCS12PBE = function(oid, params, password) {
+pki.pbe.getCipherForPKCS12PBE = function(oid, params, password) {
   // get PBE params
   var capture = {};
   var errors = [];
@@ -14563,13 +14563,13 @@ pki$1.pbe.getCipherForPKCS12PBE = function(oid, params, password) {
 
   var dkLen, dIvLen, cipherFn;
   switch(oid) {
-    case pki$1.oids['pbeWithSHAAnd3-KeyTripleDES-CBC']:
+    case pki.oids['pbeWithSHAAnd3-KeyTripleDES-CBC']:
       dkLen = 24;
       dIvLen = 8;
       cipherFn = forge.des.startDecrypting;
       break;
 
-    case pki$1.oids['pbewithSHAAnd40BitRC2-CBC']:
+    case pki.oids['pbewithSHAAnd40BitRC2-CBC']:
       dkLen = 5;
       dIvLen = 8;
       cipherFn = function(key, iv) {
@@ -14587,9 +14587,9 @@ pki$1.pbe.getCipherForPKCS12PBE = function(oid, params, password) {
 
   // get PRF message digest
   var md = prfOidToMessageDigest(capture.prfOid);
-  var key = pki$1.pbe.generatePkcs12Key(password, salt, 1, count, dkLen, md);
+  var key = pki.pbe.generatePkcs12Key(password, salt, 1, count, dkLen, md);
   md.start();
-  var iv = pki$1.pbe.generatePkcs12Key(password, salt, 2, count, dIvLen, md);
+  var iv = pki.pbe.generatePkcs12Key(password, salt, 2, count, dIvLen, md);
 
   return cipherFn(key, iv);
 };
@@ -14605,7 +14605,7 @@ pki$1.pbe.getCipherForPKCS12PBE = function(oid, params, password) {
  * @param [options] the options to use:
  *          [md] an optional message digest object to use.
  */
-pki$1.pbe.opensslDeriveBytes = function(password, salt, dkLen, md) {
+pki.pbe.opensslDeriveBytes = function(password, salt, dkLen, md) {
   if(typeof md === 'undefined' || md === null) {
     if(!('md5' in forge.md)) {
       throw new Error('"md5" hash algorithm unavailable.');
@@ -14632,7 +14632,7 @@ function prfOidToMessageDigest(prfOid) {
   if(!prfOid) {
     prfAlgorithm = 'hmacWithSHA1';
   } else {
-    prfAlgorithm = pki$1.oids[asn1$1.derToOid(prfOid)];
+    prfAlgorithm = pki.oids[asn1$1.derToOid(prfOid)];
     if(!prfAlgorithm) {
       var error = new Error('Unsupported PRF OID.');
       error.oid = prfOid;
@@ -14689,7 +14689,7 @@ function createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm) {
       asn1$1.create(asn1$1.Class.UNIVERSAL, asn1$1.Type.SEQUENCE, true, [
         // algorithm
         asn1$1.create(asn1$1.Class.UNIVERSAL, asn1$1.Type.OID, false,
-          asn1$1.oidToDer(pki$1.oids[prfAlgorithm]).getBytes()),
+          asn1$1.oidToDer(pki.oids[prfAlgorithm]).getBytes()),
         // parameters (null)
         asn1$1.create(asn1$1.Class.UNIVERSAL, asn1$1.Type.NULL, false, '')
       ]));
@@ -25041,39 +25041,39 @@ function _update(s, w, bytes) {
  * Copyright (c) 2019 Digital Bazaar, Inc.
  */
 
-var asn1$2 = forge.asn1;
+var asn1 = forge.asn1;
 
 var privateKeyValidator$1 = {
   // PrivateKeyInfo
   name: 'PrivateKeyInfo',
-  tagClass: asn1$2.Class.UNIVERSAL,
-  type: asn1$2.Type.SEQUENCE,
+  tagClass: asn1.Class.UNIVERSAL,
+  type: asn1.Type.SEQUENCE,
   constructed: true,
   value: [{
     // Version (INTEGER)
     name: 'PrivateKeyInfo.version',
-    tagClass: asn1$2.Class.UNIVERSAL,
-    type: asn1$2.Type.INTEGER,
+    tagClass: asn1.Class.UNIVERSAL,
+    type: asn1.Type.INTEGER,
     constructed: false,
     capture: 'privateKeyVersion'
   }, {
     // privateKeyAlgorithm
     name: 'PrivateKeyInfo.privateKeyAlgorithm',
-    tagClass: asn1$2.Class.UNIVERSAL,
-    type: asn1$2.Type.SEQUENCE,
+    tagClass: asn1.Class.UNIVERSAL,
+    type: asn1.Type.SEQUENCE,
     constructed: true,
     value: [{
       name: 'AlgorithmIdentifier.algorithm',
-      tagClass: asn1$2.Class.UNIVERSAL,
-      type: asn1$2.Type.OID,
+      tagClass: asn1.Class.UNIVERSAL,
+      type: asn1.Type.OID,
       constructed: false,
       capture: 'privateKeyOid'
     }]
   }, {
     // PrivateKey
     name: 'PrivateKeyInfo',
-    tagClass: asn1$2.Class.UNIVERSAL,
-    type: asn1$2.Type.OCTETSTRING,
+    tagClass: asn1.Class.UNIVERSAL,
+    type: asn1.Type.OCTETSTRING,
     constructed: false,
     capture: 'privateKey'
   }]
@@ -25081,27 +25081,27 @@ var privateKeyValidator$1 = {
 
 var publicKeyValidator$1 = {
   name: 'SubjectPublicKeyInfo',
-  tagClass: asn1$2.Class.UNIVERSAL,
-  type: asn1$2.Type.SEQUENCE,
+  tagClass: asn1.Class.UNIVERSAL,
+  type: asn1.Type.SEQUENCE,
   constructed: true,
   captureAsn1: 'subjectPublicKeyInfo',
   value: [{
     name: 'SubjectPublicKeyInfo.AlgorithmIdentifier',
-    tagClass: asn1$2.Class.UNIVERSAL,
-    type: asn1$2.Type.SEQUENCE,
+    tagClass: asn1.Class.UNIVERSAL,
+    type: asn1.Type.SEQUENCE,
     constructed: true,
     value: [{
       name: 'AlgorithmIdentifier.algorithm',
-      tagClass: asn1$2.Class.UNIVERSAL,
-      type: asn1$2.Type.OID,
+      tagClass: asn1.Class.UNIVERSAL,
+      type: asn1.Type.OID,
       constructed: false,
       capture: 'publicKeyOid'
     }]
   },
   // capture group for ed25519PublicKey
   {
-    tagClass: asn1$2.Class.UNIVERSAL,
-    type: asn1$2.Type.BITSTRING,
+    tagClass: asn1.Class.UNIVERSAL,
+    type: asn1.Type.BITSTRING,
     constructed: false,
     composed: true,
     captureBitStringValue: 'ed25519PublicKey'
@@ -25143,8 +25143,8 @@ var asn1Validator = {
  * https://github.com/dchest/tweetnacl-js
  */
 
-var publicKeyValidator$2 = asn1Validator.publicKeyValidator;
-var privateKeyValidator$2 = asn1Validator.privateKeyValidator;
+var publicKeyValidator = asn1Validator.publicKeyValidator;
+var privateKeyValidator = asn1Validator.privateKeyValidator;
 
 var ByteBuffer = forge.util.ByteBuffer;
 var NativeBuffer = typeof Buffer === 'undefined' ? Uint8Array : Buffer;
@@ -25203,7 +25203,7 @@ ed25519.generateKeyPair = function(options) {
 ed25519.privateKeyFromAsn1 = function(obj) {
   var capture = {};
   var errors = [];
-  var valid = forge.asn1.validate(obj, privateKeyValidator$2, capture, errors);
+  var valid = forge.asn1.validate(obj, privateKeyValidator, capture, errors);
   if(!valid) {
     var error = new Error('Invalid Key.');
     error.errors = errors;
@@ -25239,7 +25239,7 @@ ed25519.publicKeyFromAsn1 = function(obj) {
   // get SubjectPublicKeyInfo
   var capture = {};
   var errors = [];
-  var valid = forge.asn1.validate(obj, publicKeyValidator$2, capture, errors);
+  var valid = forge.asn1.validate(obj, publicKeyValidator, capture, errors);
   if(!valid) {
     var error = new Error('Invalid Key.');
     error.errors = errors;
@@ -26208,7 +26208,7 @@ function M(o, a, b) {
 
 forge.kem = forge.kem || {};
 
-var BigInteger$2 = forge.jsbn.BigInteger;
+var BigInteger = forge.jsbn.BigInteger;
 
 /**
  * The API for the RSA Key Encapsulation Mechanism (RSA-KEM) from ISO 18033-2.
@@ -26251,10 +26251,10 @@ forge.kem.rsa.create = function(kdf, options) {
     var byteLength = Math.ceil(publicKey.n.bitLength() / 8);
     var r;
     do {
-      r = new BigInteger$2(
+      r = new BigInteger(
         forge.util.bytesToHex(prng.getBytesSync(byteLength)),
         16).mod(publicKey.n);
-    } while(r.compareTo(BigInteger$2.ONE) <= 0);
+    } while(r.compareTo(BigInteger.ONE) <= 0);
 
     // prepend r with zeros
     r = forge.util.hexToBytes(r.toString(16));