pixel-react 1.15.21 → 1.15.22

package/lib/index.d.ts

@@ -4619,7 +4619,7 @@ declare const compareArrays: (arr1: unknown[], arr2: unknown[]) => boolean;
 type AnyObject = Record<string, unknown>;
 declare const compareObjects: (obj1: AnyObject | null, obj2: AnyObject | null) => boolean;
 
-declare function getEncryptedData(data: string, base64PublicKey: string): Promise<string>;
+declare const getEncryptedData: (data: string, publicKey: string) => string | false;
 
 type Callback = (...args: any[]) => void;
 interface ThrottledFunction extends Function {

package/lib/node_modules/js-beautify/js/src/css/beautifier.js

@@ -1,4 +1,4 @@
-import { __exports as beautifier } from '../../../../../_virtual/beautifier2.js';
+import { __exports as beautifier } from '../../../../../_virtual/beautifier3.js';
 import { __require as requireOptions } from './options.js';
 import { __require as requireOutput } from '../core/output.js';
 import { __require as requireInputscanner } from '../core/inputscanner.js';

package/lib/node_modules/js-beautify/js/src/css/options.js

@@ -1,4 +1,4 @@
-import { __exports as options } from '../../../../../_virtual/options.js';
+import { __exports as options } from '../../../../../_virtual/options2.js';
 import { __require as requireOptions$1 } from '../core/options.js';
 
 /*jshint node:true */

package/lib/node_modules/js-beautify/js/src/html/beautifier.js

@@ -1,4 +1,4 @@
-import { __exports as beautifier } from '../../../../../_virtual/beautifier.js';
+import { __exports as beautifier } from '../../../../../_virtual/beautifier2.js';
 import { __require as requireOptions } from './options.js';
 import { __require as requireOutput } from '../core/output.js';
 import { __require as requireTokenizer } from './tokenizer.js';

package/lib/node_modules/js-beautify/js/src/html/options.js

@@ -1,4 +1,4 @@
-import { __exports as options } from '../../../../../_virtual/options2.js';
+import { __exports as options } from '../../../../../_virtual/options.js';
 import { __require as requireOptions$1 } from '../core/options.js';
 
 /*jshint node:true */

package/lib/node_modules/js-beautify/js/src/javascript/beautifier.js

@@ -1,4 +1,4 @@
-import { __exports as beautifier } from '../../../../../_virtual/beautifier3.js';
+import { __exports as beautifier } from '../../../../../_virtual/beautifier.js';
 import { __require as requireOutput } from '../core/output.js';
 import { __require as requireToken } from '../core/token.js';
 import { __require as requireAcorn } from './acorn.js';

package/lib/node_modules/jsencrypt/lib/JSEncrypt.js

@@ -0,0 +1,246 @@
+import { b64tohex, hex2b64 } from './lib/jsbn/base64.js';
+import { JSEncryptRSAKey } from './JSEncryptRSAKey.js';
+import { oaep_pad } from './lib/jsbn/rsa.js';
+import { rstr2hex, rstr_sha256 } from './lib/jsbn/sha256.js';
+
+var _a;
+var version = typeof process !== "undefined" ? (_a = process.env) === null || _a === void 0 ? void 0 : _a.npm_package_version : undefined;
+/**
+ *
+ * @param {Object} [options = {}] - An object to customize JSEncrypt behaviour
+ * possible parameters are:
+ * - key                     {JSEncryptRSAKey}  default: null
+ * - default_key_size        {number}  default: 1024 the key size in bit
+ * - default_public_exponent {string}  default: '010001' the hexadecimal representation of the public exponent
+ * - log                     {boolean} default: false whether log warn/error or not
+ * @constructor
+ */
+var JSEncrypt = /** @class */function () {
+  function JSEncrypt(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    this.default_key_size = options.default_key_size ? parseInt(options.default_key_size, 10) : 1024;
+    this.default_public_exponent = options.default_public_exponent || "010001"; // 65537 default openssl public exponent for rsa key type
+    this.log = options.log || false;
+    // The private and public key.
+    this.key = options.key || null;
+  }
+  /**
+   * Method to set the rsa key parameter (one method is enough to set both the public
+   * and the private key, since the private key contains the public key paramenters)
+   * Log a warning if logs are enabled
+   * @param {Object|string} key the pem encoded string or an object (with or without header/footer)
+   * @public
+   */
+  JSEncrypt.prototype.setKey = function (key) {
+    if (key) {
+      if (this.log && this.key) {
+        console.warn("A key was already set, overriding existing.");
+      }
+      this.key = new JSEncryptRSAKey(key);
+    } else if (!this.key && this.log) {
+      console.error("A key was not set.");
+    }
+  };
+  /**
+   * Proxy method for setKey, for api compatibility
+   * @see setKey
+   * @public
+   */
+  JSEncrypt.prototype.setPrivateKey = function (privkey) {
+    // Create the key.
+    this.setKey(privkey);
+  };
+  /**
+   * Proxy method for setKey, for api compatibility
+   * @see setKey
+   * @public
+   */
+  JSEncrypt.prototype.setPublicKey = function (pubkey) {
+    // Sets the public key.
+    this.setKey(pubkey);
+  };
+  /**
+   * Proxy method for RSAKey object's decrypt, decrypt the string using the private
+   * components of the rsa key object. Note that if the object was not set will be created
+   * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
+   * @param {string} str base64 encoded crypted string to decrypt
+   * @return {string} the decrypted string
+   * @public
+   */
+  JSEncrypt.prototype.decrypt = function (str) {
+    // Return the decrypted string.
+    try {
+      return this.getKey().decrypt(b64tohex(str));
+    } catch (ex) {
+      return false;
+    }
+  };
+  /**
+   * Proxy method for RSAKey object's encrypt, encrypt the string using the public
+   * components of the rsa key object. Note that if the object was not set will be created
+   * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
+   * @param {string} str the string to encrypt
+   * @return {string} the encrypted string encoded in base64
+   * @public
+   */
+  JSEncrypt.prototype.encrypt = function (str) {
+    // Return the encrypted string.
+    try {
+      return hex2b64(this.getKey().encrypt(str));
+    } catch (ex) {
+      return false;
+    }
+  };
+  /**
+   * Proxy method for RSAKey object's encrypt with padding: RSA_PKCS1_OAEP_PADDING and oaepHash: sha256,
+   * encrypt the string using the public
+   * components of the rsa key object. Note that if the object was not set will be created
+   * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
+   * @param {string} str the string to encrypt
+   * @return {string} the encrypted string encoded in base64
+   * @public
+   */
+  JSEncrypt.prototype.encryptOAEP = function (str) {
+    // Return the encrypted string.
+    try {
+      return hex2b64(this.getKey().encrypt(str, oaep_pad));
+    } catch (ex) {
+      return false;
+    }
+  };
+  /**
+   * Proxy method for RSAKey object's sign.
+   * @param {string} str the string to sign
+   * @param {function} digestMethod hash method
+   * @param {string} digestName the name of the hash algorithm
+   * @return {string} the signature encoded in base64
+   * @public
+   */
+  JSEncrypt.prototype.sign = function (str, digestMethod, digestName) {
+    if (digestMethod === void 0) {
+      digestMethod = function (raw) {
+        return raw;
+      };
+    }
+    if (digestName === void 0) {
+      digestName = "";
+    }
+    // return the RSA signature of 'str' in 'hex' format.
+    try {
+      return hex2b64(this.getKey().sign(str, digestMethod, digestName));
+    } catch (ex) {
+      return false;
+    }
+  };
+  /**
+   * Signs a string using the SHA-256 hash algorithm.
+   * @param str the string to sign
+   * @returns the base64 encoded signature or false on failure
+   */
+  JSEncrypt.prototype.signSha256 = function (str) {
+    return this.sign(str, function (text) {
+      return rstr2hex(rstr_sha256(text));
+    }, "sha256");
+  };
+  /**
+   * Proxy method for RSAKey object's verify.
+   * @param {string} str the string to verify
+   * @param {string} signature the signature encoded in base64 to compare the string to
+   * @param {function} digestMethod hash method
+   * @return {boolean} whether the data and signature match
+   * @public
+   */
+  JSEncrypt.prototype.verify = function (str, signature, digestMethod) {
+    if (digestMethod === void 0) {
+      digestMethod = function (raw) {
+        return raw;
+      };
+    }
+    // Return the decrypted 'digest' of the signature.
+    try {
+      return this.getKey().verify(str, b64tohex(signature), digestMethod);
+    } catch (ex) {
+      return false;
+    }
+  };
+  /**
+   * Verifies a string using the SHA-256 hash algorithm.
+   * @param str the string to verify
+   * @param signature the base64 encoded signature to compare against
+   * @returns whether the signature is valid
+   */
+  JSEncrypt.prototype.verifySha256 = function (str, signature) {
+    return this.verify(str, signature, function (text) {
+      return rstr2hex(rstr_sha256(text));
+    });
+  };
+  /**
+   * Getter for the current JSEncryptRSAKey object. If it doesn't exists a new object
+   * will be created and returned
+   * @param {callback} [cb] the callback to be called if we want the key to be generated
+   * in an async fashion
+   * @returns {JSEncryptRSAKey} the JSEncryptRSAKey object
+   * @public
+   */
+  JSEncrypt.prototype.getKey = function (cb) {
+    // Only create new if it does not exist.
+    if (!this.key) {
+      // Get a new private key.
+      this.key = new JSEncryptRSAKey();
+      if (cb && {}.toString.call(cb) === "[object Function]") {
+        this.key.generateAsync(this.default_key_size, this.default_public_exponent, cb);
+        return;
+      }
+      // Generate the key.
+      this.key.generate(this.default_key_size, this.default_public_exponent);
+    }
+    return this.key;
+  };
+  /**
+   * Returns the pem encoded representation of the private key
+   * If the key doesn't exists a new key will be created
+   * @returns {string} pem encoded representation of the private key WITH header and footer
+   * @public
+   */
+  JSEncrypt.prototype.getPrivateKey = function () {
+    // Return the private representation of this key.
+    return this.getKey().getPrivateKey();
+  };
+  /**
+   * Returns the pem encoded representation of the private key
+   * If the key doesn't exists a new key will be created
+   * @returns {string} pem encoded representation of the private key WITHOUT header and footer
+   * @public
+   */
+  JSEncrypt.prototype.getPrivateKeyB64 = function () {
+    // Return the private representation of this key.
+    return this.getKey().getPrivateBaseKeyB64();
+  };
+  /**
+   * Returns the pem encoded representation of the public key
+   * If the key doesn't exists a new key will be created
+   * @returns {string} pem encoded representation of the public key WITH header and footer
+   * @public
+   */
+  JSEncrypt.prototype.getPublicKey = function () {
+    // Return the private representation of this key.
+    return this.getKey().getPublicKey();
+  };
+  /**
+   * Returns the pem encoded representation of the public key
+   * If the key doesn't exists a new key will be created
+   * @returns {string} pem encoded representation of the public key WITHOUT header and footer
+   * @public
+   */
+  JSEncrypt.prototype.getPublicKeyB64 = function () {
+    // Return the private representation of this key.
+    return this.getKey().getPublicBaseKeyB64();
+  };
+  JSEncrypt.version = version;
+  return JSEncrypt;
+}();
+
+export { JSEncrypt };
+//# sourceMappingURL=JSEncrypt.js.map

package/lib/node_modules/jsencrypt/lib/JSEncrypt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSEncrypt.js","sources":["../../../../node_modules/jsencrypt/lib/JSEncrypt.js"],"sourcesContent":["var _a;\nimport { b64tohex, hex2b64 } from \"./lib/jsbn/base64\";\nimport { JSEncryptRSAKey } from \"./JSEncryptRSAKey\";\nimport { oaep_pad } from './lib/jsbn/rsa';\nimport { rstr_sha256, rstr2hex } from './lib/jsbn/sha256';\nvar version = typeof process !== \"undefined\" ? (_a = process.env) === null || _a === void 0 ? void 0 : _a.npm_package_version : undefined;\n/**\n *\n * @param {Object} [options = {}] - An object to customize JSEncrypt behaviour\n * possible parameters are:\n * - key                     {JSEncryptRSAKey}  default: null\n * - default_key_size        {number}  default: 1024 the key size in bit\n * - default_public_exponent {string}  default: '010001' the hexadecimal representation of the public exponent\n * - log                     {boolean} default: false whether log warn/error or not\n * @constructor\n */\nvar JSEncrypt = /** @class */ (function () {\n    function JSEncrypt(options) {\n        if (options === void 0) { options = {}; }\n        this.default_key_size = options.default_key_size\n            ? parseInt(options.default_key_size, 10)\n            : 1024;\n        this.default_public_exponent = options.default_public_exponent || \"010001\"; // 65537 default openssl public exponent for rsa key type\n        this.log = options.log || false;\n        // The private and public key.\n        this.key = options.key || null;\n    }\n    /**\n     * Method to set the rsa key parameter (one method is enough to set both the public\n     * and the private key, since the private key contains the public key paramenters)\n     * Log a warning if logs are enabled\n     * @param {Object|string} key the pem encoded string or an object (with or without header/footer)\n     * @public\n     */\n    JSEncrypt.prototype.setKey = function (key) {\n        if (key) {\n            if (this.log && this.key) {\n                console.warn(\"A key was already set, overriding existing.\");\n            }\n            this.key = new JSEncryptRSAKey(key);\n        }\n        else if (!this.key && this.log) {\n            console.error(\"A key was not set.\");\n        }\n    };\n    /**\n     * Proxy method for setKey, for api compatibility\n     * @see setKey\n     * @public\n     */\n    JSEncrypt.prototype.setPrivateKey = function (privkey) {\n        // Create the key.\n        this.setKey(privkey);\n    };\n    /**\n     * Proxy method for setKey, for api compatibility\n     * @see setKey\n     * @public\n     */\n    JSEncrypt.prototype.setPublicKey = function (pubkey) {\n        // Sets the public key.\n        this.setKey(pubkey);\n    };\n    /**\n     * Proxy method for RSAKey object's decrypt, decrypt the string using the private\n     * components of the rsa key object. Note that if the object was not set will be created\n     * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor\n     * @param {string} str base64 encoded crypted string to decrypt\n     * @return {string} the decrypted string\n     * @public\n     */\n    JSEncrypt.prototype.decrypt = function (str) {\n        // Return the decrypted string.\n        try {\n            return this.getKey().decrypt(b64tohex(str));\n        }\n        catch (ex) {\n            return false;\n        }\n    };\n    /**\n     * Proxy method for RSAKey object's encrypt, encrypt the string using the public\n     * components of the rsa key object. Note that if the object was not set will be created\n     * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor\n     * @param {string} str the string to encrypt\n     * @return {string} the encrypted string encoded in base64\n     * @public\n     */\n    JSEncrypt.prototype.encrypt = function (str) {\n        // Return the encrypted string.\n        try {\n            return hex2b64(this.getKey().encrypt(str));\n        }\n        catch (ex) {\n            return false;\n        }\n    };\n    /**\n     * Proxy method for RSAKey object's encrypt with padding: RSA_PKCS1_OAEP_PADDING and oaepHash: sha256,\n     * encrypt the string using the public\n     * components of the rsa key object. Note that if the object was not set will be created\n     * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor\n     * @param {string} str the string to encrypt\n     * @return {string} the encrypted string encoded in base64\n     * @public\n     */\n    JSEncrypt.prototype.encryptOAEP = function (str) {\n        // Return the encrypted string.\n        try {\n            return hex2b64(this.getKey().encrypt(str, oaep_pad));\n        }\n        catch (ex) {\n            return false;\n        }\n    };\n    /**\n     * Proxy method for RSAKey object's sign.\n     * @param {string} str the string to sign\n     * @param {function} digestMethod hash method\n     * @param {string} digestName the name of the hash algorithm\n     * @return {string} the signature encoded in base64\n     * @public\n     */\n    JSEncrypt.prototype.sign = function (str, digestMethod, digestName) {\n        if (digestMethod === void 0) { digestMethod = function (raw) { return raw; }; }\n        if (digestName === void 0) { digestName = \"\"; }\n        // return the RSA signature of 'str' in 'hex' format.\n        try {\n            return hex2b64(this.getKey().sign(str, digestMethod, digestName));\n        }\n        catch (ex) {\n            return false;\n        }\n    };\n    /**\n     * Signs a string using the SHA-256 hash algorithm.\n     * @param str the string to sign\n     * @returns the base64 encoded signature or false on failure\n     */\n    JSEncrypt.prototype.signSha256 = function (str) {\n        return this.sign(str, function (text) {\n            return rstr2hex(rstr_sha256(text));\n        }, \"sha256\");\n    };\n    /**\n     * Proxy method for RSAKey object's verify.\n     * @param {string} str the string to verify\n     * @param {string} signature the signature encoded in base64 to compare the string to\n     * @param {function} digestMethod hash method\n     * @return {boolean} whether the data and signature match\n     * @public\n     */\n    JSEncrypt.prototype.verify = function (str, signature, digestMethod) {\n        if (digestMethod === void 0) { digestMethod = function (raw) { return raw; }; }\n        // Return the decrypted 'digest' of the signature.\n        try {\n            return this.getKey().verify(str, b64tohex(signature), digestMethod);\n        }\n        catch (ex) {\n            return false;\n        }\n    };\n    /**\n     * Verifies a string using the SHA-256 hash algorithm.\n     * @param str the string to verify\n     * @param signature the base64 encoded signature to compare against\n     * @returns whether the signature is valid\n     */\n    JSEncrypt.prototype.verifySha256 = function (str, signature) {\n        return this.verify(str, signature, function (text) {\n            return rstr2hex(rstr_sha256(text));\n        });\n    };\n    /**\n     * Getter for the current JSEncryptRSAKey object. If it doesn't exists a new object\n     * will be created and returned\n     * @param {callback} [cb] the callback to be called if we want the key to be generated\n     * in an async fashion\n     * @returns {JSEncryptRSAKey} the JSEncryptRSAKey object\n     * @public\n     */\n    JSEncrypt.prototype.getKey = function (cb) {\n        // Only create new if it does not exist.\n        if (!this.key) {\n            // Get a new private key.\n            this.key = new JSEncryptRSAKey();\n            if (cb && {}.toString.call(cb) === \"[object Function]\") {\n                this.key.generateAsync(this.default_key_size, this.default_public_exponent, cb);\n                return;\n            }\n            // Generate the key.\n            this.key.generate(this.default_key_size, this.default_public_exponent);\n        }\n        return this.key;\n    };\n    /**\n     * Returns the pem encoded representation of the private key\n     * If the key doesn't exists a new key will be created\n     * @returns {string} pem encoded representation of the private key WITH header and footer\n     * @public\n     */\n    JSEncrypt.prototype.getPrivateKey = function () {\n        // Return the private representation of this key.\n        return this.getKey().getPrivateKey();\n    };\n    /**\n     * Returns the pem encoded representation of the private key\n     * If the key doesn't exists a new key will be created\n     * @returns {string} pem encoded representation of the private key WITHOUT header and footer\n     * @public\n     */\n    JSEncrypt.prototype.getPrivateKeyB64 = function () {\n        // Return the private representation of this key.\n        return this.getKey().getPrivateBaseKeyB64();\n    };\n    /**\n     * Returns the pem encoded representation of the public key\n     * If the key doesn't exists a new key will be created\n     * @returns {string} pem encoded representation of the public key WITH header and footer\n     * @public\n     */\n    JSEncrypt.prototype.getPublicKey = function () {\n        // Return the private representation of this key.\n        return this.getKey().getPublicKey();\n    };\n    /**\n     * Returns the pem encoded representation of the public key\n     * If the key doesn't exists a new key will be created\n     * @returns {string} pem encoded representation of the public key WITHOUT header and footer\n     * @public\n     */\n    JSEncrypt.prototype.getPublicKeyB64 = function () {\n        // Return the private representation of this key.\n        return this.getKey().getPublicBaseKeyB64();\n    };\n    JSEncrypt.version = version;\n    return JSEncrypt;\n}());\nexport { JSEncrypt };\n"],"names":["_a","version","process","env","npm_package_version","undefined","JSEncrypt","options","default_key_size","parseInt","default_public_exponent","log","key","prototype","setKey","console","warn","JSEncryptRSAKey","error","setPrivateKey","privkey","setPublicKey","pubkey","decrypt","str","getKey","b64tohex","ex","encrypt","hex2b64","encryptOAEP","oaep_pad","sign","digestMethod","digestName","raw","signSha256","text","rstr2hex","rstr_sha256","verify","signature","verifySha256","cb","toString","call","generateAsync","generate","getPrivateKey","getPrivateKeyB64","getPrivateBaseKeyB64","getPublicKey","getPublicKeyB64","getPublicBaseKeyB64"],"mappings":"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","x_google_ignoreList":[0]}

package/lib/node_modules/jsencrypt/lib/JSEncryptRSAKey.js

@@ -0,0 +1,325 @@
+import { hex2b64 } from './lib/jsbn/base64.js';
+import { Hex } from './lib/asn1js/hex.js';
+import { Base64 } from './lib/asn1js/base64.js';
+import { ASN1 } from './lib/asn1js/asn1.js';
+import { RSAKey } from './lib/jsbn/rsa.js';
+import { parseBigInt } from './lib/jsbn/jsbn.js';
+import { KJUR } from './lib/jsrsasign/asn1-1.0.js';
+
+var __extends = window && window.__extends || function () {
+  var extendStatics = function (d, b) {
+    extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function (d, b) {
+    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+/**
+ * Create a new JSEncryptRSAKey that extends Tom Wu's RSA key object.
+ * This object is just a decorator for parsing the key parameter
+ * @param {string|Object} key - The key in string format, or an object containing
+ * the parameters needed to build a RSAKey object.
+ * @constructor
+ */
+var JSEncryptRSAKey = /** @class */function (_super) {
+  __extends(JSEncryptRSAKey, _super);
+  function JSEncryptRSAKey(key) {
+    var _this = _super.call(this) || this;
+    // Call the super constructor.
+    //  RSAKey.call(this);
+    // If a key key was provided.
+    if (key) {
+      // If this is a string...
+      if (typeof key === "string") {
+        _this.parseKey(key);
+      } else if (JSEncryptRSAKey.hasPrivateKeyProperty(key) || JSEncryptRSAKey.hasPublicKeyProperty(key)) {
+        // Set the values for the key.
+        _this.parsePropertiesFrom(key);
+      }
+    }
+    return _this;
+  }
+  /**
+   * Method to parse a pem encoded string containing both a public or private key.
+   * The method will translate the pem encoded string in a der encoded string and
+   * will parse private key and public key parameters. This method accepts public key
+   * in the rsaencryption pkcs #1 format (oid: 1.2.840.113549.1.1.1).
+   *
+   * @todo Check how many rsa formats use the same format of pkcs #1.
+   *
+   * The format is defined as:
+   * PublicKeyInfo ::= SEQUENCE {
+   *   algorithm       AlgorithmIdentifier,
+   *   PublicKey       BIT STRING
+   * }
+   * Where AlgorithmIdentifier is:
+   * AlgorithmIdentifier ::= SEQUENCE {
+   *   algorithm       OBJECT IDENTIFIER,     the OID of the enc algorithm
+   *   parameters      ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)
+   * }
+   * and PublicKey is a SEQUENCE encapsulated in a BIT STRING
+   * RSAPublicKey ::= SEQUENCE {
+   *   modulus           INTEGER,  -- n
+   *   publicExponent    INTEGER   -- e
+   * }
+   * it's possible to examine the structure of the keys obtained from openssl using
+   * an asn.1 dumper as the one used here to parse the components: http://lapo.it/asn1js/
+   * @argument {string} pem the pem encoded string, can include the BEGIN/END header/footer
+   * @private
+   */
+  JSEncryptRSAKey.prototype.parseKey = function (pem) {
+    try {
+      var modulus = 0;
+      var public_exponent = 0;
+      var reHex = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;
+      var der = reHex.test(pem) ? Hex.decode(pem) : Base64.unarmor(pem);
+      var asn1 = ASN1.decode(der);
+      // Fixes a bug with OpenSSL 1.0+ private keys
+      if (asn1.sub.length === 3) {
+        asn1 = asn1.sub[2].sub[0];
+      }
+      if (asn1.sub.length === 9) {
+        // Parse the private key.
+        modulus = asn1.sub[1].getHexStringValue(); // bigint
+        this.n = parseBigInt(modulus, 16);
+        public_exponent = asn1.sub[2].getHexStringValue(); // int
+        this.e = parseInt(public_exponent, 16);
+        var private_exponent = asn1.sub[3].getHexStringValue(); // bigint
+        this.d = parseBigInt(private_exponent, 16);
+        var prime1 = asn1.sub[4].getHexStringValue(); // bigint
+        this.p = parseBigInt(prime1, 16);
+        var prime2 = asn1.sub[5].getHexStringValue(); // bigint
+        this.q = parseBigInt(prime2, 16);
+        var exponent1 = asn1.sub[6].getHexStringValue(); // bigint
+        this.dmp1 = parseBigInt(exponent1, 16);
+        var exponent2 = asn1.sub[7].getHexStringValue(); // bigint
+        this.dmq1 = parseBigInt(exponent2, 16);
+        var coefficient = asn1.sub[8].getHexStringValue(); // bigint
+        this.coeff = parseBigInt(coefficient, 16);
+      } else if (asn1.sub.length === 2) {
+        if (asn1.sub[0].sub) {
+          // Parse ASN.1 SubjectPublicKeyInfo type as defined by X.509
+          var bit_string = asn1.sub[1];
+          var sequence = bit_string.sub[0];
+          modulus = sequence.sub[0].getHexStringValue();
+          this.n = parseBigInt(modulus, 16);
+          public_exponent = sequence.sub[1].getHexStringValue();
+          this.e = parseInt(public_exponent, 16);
+        } else {
+          // Parse ASN.1 RSAPublicKey type as defined by PKCS #1
+          modulus = asn1.sub[0].getHexStringValue();
+          this.n = parseBigInt(modulus, 16);
+          public_exponent = asn1.sub[1].getHexStringValue();
+          this.e = parseInt(public_exponent, 16);
+        }
+      } else {
+        return false;
+      }
+      return true;
+    } catch (ex) {
+      return false;
+    }
+  };
+  /**
+   * Translate rsa parameters in a hex encoded string representing the rsa key.
+   *
+   * The translation follow the ASN.1 notation :
+   * RSAPrivateKey ::= SEQUENCE {
+   *   version           Version,
+   *   modulus           INTEGER,  -- n
+   *   publicExponent    INTEGER,  -- e
+   *   privateExponent   INTEGER,  -- d
+   *   prime1            INTEGER,  -- p
+   *   prime2            INTEGER,  -- q
+   *   exponent1         INTEGER,  -- d mod (p1)
+   *   exponent2         INTEGER,  -- d mod (q-1)
+   *   coefficient       INTEGER,  -- (inverse of q) mod p
+   * }
+   * @returns {string}  DER Encoded String representing the rsa private key
+   * @private
+   */
+  JSEncryptRSAKey.prototype.getPrivateBaseKey = function () {
+    var options = {
+      array: [new KJUR.asn1.DERInteger({
+        int: 0
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.n
+      }), new KJUR.asn1.DERInteger({
+        int: this.e
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.d
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.p
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.q
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.dmp1
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.dmq1
+      }), new KJUR.asn1.DERInteger({
+        bigint: this.coeff
+      })]
+    };
+    var seq = new KJUR.asn1.DERSequence(options);
+    return seq.getEncodedHex();
+  };
+  /**
+   * base64 (pem) encoded version of the DER encoded representation
+   * @returns {string} pem encoded representation without header and footer
+   * @public
+   */
+  JSEncryptRSAKey.prototype.getPrivateBaseKeyB64 = function () {
+    return hex2b64(this.getPrivateBaseKey());
+  };
+  /**
+   * Translate rsa parameters in a hex encoded string representing the rsa public key.
+   * The representation follow the ASN.1 notation :
+   * PublicKeyInfo ::= SEQUENCE {
+   *   algorithm       AlgorithmIdentifier,
+   *   PublicKey       BIT STRING
+   * }
+   * Where AlgorithmIdentifier is:
+   * AlgorithmIdentifier ::= SEQUENCE {
+   *   algorithm       OBJECT IDENTIFIER,     the OID of the enc algorithm
+   *   parameters      ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)
+   * }
+   * and PublicKey is a SEQUENCE encapsulated in a BIT STRING
+   * RSAPublicKey ::= SEQUENCE {
+   *   modulus           INTEGER,  -- n
+   *   publicExponent    INTEGER   -- e
+   * }
+   * @returns {string} DER Encoded String representing the rsa public key
+   * @private
+   */
+  JSEncryptRSAKey.prototype.getPublicBaseKey = function () {
+    var first_sequence = new KJUR.asn1.DERSequence({
+      array: [new KJUR.asn1.DERObjectIdentifier({
+        oid: "1.2.840.113549.1.1.1"
+      }),
+      // RSA Encryption pkcs #1 oid
+      new KJUR.asn1.DERNull()]
+    });
+    var second_sequence = new KJUR.asn1.DERSequence({
+      array: [new KJUR.asn1.DERInteger({
+        bigint: this.n
+      }), new KJUR.asn1.DERInteger({
+        int: this.e
+      })]
+    });
+    var bit_string = new KJUR.asn1.DERBitString({
+      hex: "00" + second_sequence.getEncodedHex()
+    });
+    var seq = new KJUR.asn1.DERSequence({
+      array: [first_sequence, bit_string]
+    });
+    return seq.getEncodedHex();
+  };
+  /**
+   * base64 (pem) encoded version of the DER encoded representation
+   * @returns {string} pem encoded representation without header and footer
+   * @public
+   */
+  JSEncryptRSAKey.prototype.getPublicBaseKeyB64 = function () {
+    return hex2b64(this.getPublicBaseKey());
+  };
+  /**
+   * wrap the string in block of width chars. The default value for rsa keys is 64
+   * characters.
+   * @param {string} str the pem encoded string without header and footer
+   * @param {Number} [width=64] - the length the string has to be wrapped at
+   * @returns {string}
+   * @private
+   */
+  JSEncryptRSAKey.wordwrap = function (str, width) {
+    width = width || 64;
+    if (!str) {
+      return str;
+    }
+    var regex = "(.{1," + width + "})( +|$\n?)|(.{1," + width + "})";
+    return str.match(RegExp(regex, "g")).join("\n");
+  };
+  /**
+   * Retrieve the pem encoded private key
+   * @returns {string} the pem encoded private key with header/footer
+   * @public
+   */
+  JSEncryptRSAKey.prototype.getPrivateKey = function () {
+    var key = "-----BEGIN RSA PRIVATE KEY-----\n";
+    key += JSEncryptRSAKey.wordwrap(this.getPrivateBaseKeyB64()) + "\n";
+    key += "-----END RSA PRIVATE KEY-----";
+    return key;
+  };
+  /**
+   * Retrieve the pem encoded public key
+   * @returns {string} the pem encoded public key with header/footer
+   * @public
+   */
+  JSEncryptRSAKey.prototype.getPublicKey = function () {
+    var key = "-----BEGIN PUBLIC KEY-----\n";
+    key += JSEncryptRSAKey.wordwrap(this.getPublicBaseKeyB64()) + "\n";
+    key += "-----END PUBLIC KEY-----";
+    return key;
+  };
+  /**
+   * Check if the object contains the necessary parameters to populate the rsa modulus
+   * and public exponent parameters.
+   * @param {Object} [obj={}] - An object that may contain the two public key
+   * parameters
+   * @returns {boolean} true if the object contains both the modulus and the public exponent
+   * properties (n and e)
+   * @todo check for types of n and e. N should be a parseable bigInt object, E should
+   * be a parseable integer number
+   * @private
+   */
+  JSEncryptRSAKey.hasPublicKeyProperty = function (obj) {
+    obj = obj || {};
+    return obj.hasOwnProperty("n") && obj.hasOwnProperty("e");
+  };
+  /**
+   * Check if the object contains ALL the parameters of an RSA key.
+   * @param {Object} [obj={}] - An object that may contain nine rsa key
+   * parameters
+   * @returns {boolean} true if the object contains all the parameters needed
+   * @todo check for types of the parameters all the parameters but the public exponent
+   * should be parseable bigint objects, the public exponent should be a parseable integer number
+   * @private
+   */
+  JSEncryptRSAKey.hasPrivateKeyProperty = function (obj) {
+    obj = obj || {};
+    return obj.hasOwnProperty("n") && obj.hasOwnProperty("e") && obj.hasOwnProperty("d") && obj.hasOwnProperty("p") && obj.hasOwnProperty("q") && obj.hasOwnProperty("dmp1") && obj.hasOwnProperty("dmq1") && obj.hasOwnProperty("coeff");
+  };
+  /**
+   * Parse the properties of obj in the current rsa object. Obj should AT LEAST
+   * include the modulus and public exponent (n, e) parameters.
+   * @param {Object} obj - the object containing rsa parameters
+   * @private
+   */
+  JSEncryptRSAKey.prototype.parsePropertiesFrom = function (obj) {
+    this.n = obj.n;
+    this.e = obj.e;
+    if (obj.hasOwnProperty("d")) {
+      this.d = obj.d;
+      this.p = obj.p;
+      this.q = obj.q;
+      this.dmp1 = obj.dmp1;
+      this.dmq1 = obj.dmq1;
+      this.coeff = obj.coeff;
+    }
+  };
+  return JSEncryptRSAKey;
+}(RSAKey);
+
+export { JSEncryptRSAKey };
+//# sourceMappingURL=JSEncryptRSAKey.js.map