--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
@ -841,6 +841,12 @@
        "node": ">= 10.13.0"
      }
    },
+    "node_modules/jsencrypt": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmmirror.com/jsencrypt/-/jsencrypt-3.3.2.tgz",
+      "integrity": "sha512-arQR1R1ESGdAxY7ZheWr12wCaF2yF47v5qpB76TtV64H1pyGudk9Hvw8Y9tb/FiTIaaTRUyaSnm5T/Y53Ghm/A==",
+      "license": "MIT"
+    },
    "node_modules/json-parse-even-better-errors": {
      "version": "2.3.1",
      "resolved": "https://registry.npmmirror.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
--- a/node_modules/jsencrypt/LICENSE.txt
+++ b/node_modules/jsencrypt/LICENSE.txt
@ -0,0 +1,107 @@
+File: /src/LICENSE.txt
+The MIT License (MIT)
+Copyright (c) 2015 Form.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+File: /lib/jsrsasign/LICENSE.txt
+
+
+CONTAINS CODE FROM YUI LIBRARY SEE LICENSE @ http://yuilibrary.com/license/
+
+The 'jsrsasign'(RSA-Sign JavaScript Library) License
+
+Copyright (c) 2010-2013 Kenji Urushima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+File: /lib/jsbn/LICENSE.txt
+
+
+Licensing
+---------
+
+This software is covered under the following copyright:
+
+/*
+ * Copyright (c) 2003-2005  Tom Wu
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
+ * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * In addition, the following condition applies:
+ *
+ * All redistributions must retain an intact copy of this copyright notice
+ * and disclaimer.
+ */
+
+Address all questions regarding this license to:
+
+  Tom Wu
+  tjw@cs.Stanford.EDU
+File: /lib/asn1js/LICENSE.txt
+
+
+ASN.1 JavaScript decoder
+Copyright (c) 2008-2013 Lapo Luchini <lapo@lapo.it>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--- a/node_modules/jsencrypt/README.md
+++ b/node_modules/jsencrypt/README.md
@ -0,0 +1,192 @@
+Website
+======================
+http://travistidwell.com/jsencrypt
+
+Introduction
+======================
+When browsing the internet looking for a good solution to RSA Javascript
+encryption, there is a whole slew of libraries that basically take the fantastic
+work done by Tom Wu @ http://www-cs-students.stanford.edu/~tjw/jsbn/ and then
+modify that code to do what they want.
+
+What I couldn't find, however, was a simple wrapper around this library that
+basically uses the library <a href="https://github.com/travist/jsencrypt/pull/6">practically</a> untouched, but adds a wrapper to provide parsing of
+actual Private and Public key-pairs generated with OpenSSL.
+
+This library is the result of these efforts.
+
+How to use this library.
+=======================
+This library should work hand-in-hand with openssl.  With that said, here is how to use this library.
+
+ - Within your terminal (Unix based OS) type the following.
+
+```
+openssl genrsa -out rsa_1024_priv.pem 1024
+```
+
+ - This generates a private key, which you can see by doing the following...
+
+```
+cat rsa_1024_priv.pem
+```
+
+ - You can then copy and paste this in the Private Key section of within index.html.
+ - Next, you can then get the public key by executing the following command.
+
+```
+openssl rsa -pubout -in rsa_1024_priv.pem -out rsa_1024_pub.pem
+```
+
+ - You can see the public key by typing...
+
+```
+cat rsa_1024_pub.pem
+```
+
+ - Now copy and paste this in the Public key within the index.html.
+ - Now you can then convert to and from encrypted text by doing the following in code.
+
+
+```html
+<!doctype html>
+<html>
+  <head>
+    <title>JavaScript RSA Encryption</title>
+    <script src="http://code.jquery.com/jquery-1.8.3.min.js"></script>
+    <script src="bin/jsencrypt.min.js"></script>
+    <script type="text/javascript">
+
+      // Call this code when the page is done loading.
+      $(function() {
+
+        // Run a quick encryption/decryption when they click.
+        $('#testme').click(function() {
+
+          // Encrypt with the public key...
+          var encrypt = new JSEncrypt();
+          encrypt.setPublicKey($('#pubkey').val());
+          var encrypted = encrypt.encrypt($('#input').val());
+
+          // Decrypt with the private key...
+          var decrypt = new JSEncrypt();
+          decrypt.setPrivateKey($('#privkey').val());
+          var uncrypted = decrypt.decrypt(encrypted);
+
+          // Now a simple check to see if the round-trip worked.
+          if (uncrypted == $('#input').val()) {
+            alert('It works!!!');
+          }
+          else {
+            alert('Something went wrong....');
+          }
+        });
+      });
+    </script>
+  </head>
+  <body>
+    <label for="privkey">Private Key</label><br/>
+    <textarea id="privkey" rows="15" cols="65">-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDlOJu6TyygqxfWT7eLtGDwajtNFOb9I5XRb6khyfD1Yt3YiCgQ
+WMNW649887VGJiGr/L5i2osbl8C9+WJTeucF+S76xFxdU6jE0NQ+Z+zEdhUTooNR
+aY5nZiu5PgDB0ED/ZKBUSLKL7eibMxZtMlUDHjm4gwQco1KRMDSmXSMkDwIDAQAB
+AoGAfY9LpnuWK5Bs50UVep5c93SJdUi82u7yMx4iHFMc/Z2hfenfYEzu+57fI4fv
+xTQ//5DbzRR/XKb8ulNv6+CHyPF31xk7YOBfkGI8qjLoq06V+FyBfDSwL8KbLyeH
+m7KUZnLNQbk8yGLzB3iYKkRHlmUanQGaNMIJziWOkN+N9dECQQD0ONYRNZeuM8zd
+8XJTSdcIX4a3gy3GGCJxOzv16XHxD03GW6UNLmfPwenKu+cdrQeaqEixrCejXdAF
+z/7+BSMpAkEA8EaSOeP5Xr3ZrbiKzi6TGMwHMvC7HdJxaBJbVRfApFrE0/mPwmP5
+rN7QwjrMY+0+AbXcm8mRQyQ1+IGEembsdwJBAN6az8Rv7QnD/YBvi52POIlRSSIM
+V7SwWvSK4WSMnGb1ZBbhgdg57DXaspcwHsFV7hByQ5BvMtIduHcT14ECfcECQATe
+aTgjFnqE/lQ22Rk0eGaYO80cc643BXVGafNfd9fcvwBMnk0iGX0XRsOozVt5Azil
+psLBYuApa66NcVHJpCECQQDTjI2AQhFc1yRnCU/YgDnSpJVm1nASoRUnU8Jfm3Oz
+uku7JUXcVpt08DFSceCEX9unCuMcT72rAQlLpdZir876
+-----END RSA PRIVATE KEY-----</textarea><br/>
+    <label for="pubkey">Public Key</label><br/>
+    <textarea id="pubkey" rows="15" cols="65">-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDlOJu6TyygqxfWT7eLtGDwajtN
+FOb9I5XRb6khyfD1Yt3YiCgQWMNW649887VGJiGr/L5i2osbl8C9+WJTeucF+S76
+xFxdU6jE0NQ+Z+zEdhUTooNRaY5nZiu5PgDB0ED/ZKBUSLKL7eibMxZtMlUDHjm4
+gwQco1KRMDSmXSMkDwIDAQAB
+-----END PUBLIC KEY-----</textarea><br/>
+    <label for="input">Text to encrypt:</label><br/>
+    <textarea id="input" name="input" type="text" rows=4 cols=70>This is a test!</textarea><br/>
+    <input id="testme" type="button" value="Test Me!!!" /><br/>
+  </body>
+</html>
+```
+
+ - Look at how http://www.travistidwell.com/jsencrypt/demo works to get a better idea.
+
+ - Signing and verification works in a similar way.
+
+```javascript
+// Sign with the private key...
+var sign = new JSEncrypt();
+sign.setPrivateKey($('#privkey').val());
+var signature = sign.sign($('#input').val(), CryptoJS.SHA256, "sha256");
+
+// Verify with the public key...
+var verify = new JSEncrypt();
+verify.setPublicKey($('#pubkey').val());
+var verified = verify.verify($('#input').val(), signature, CryptoJS.SHA256);
+
+// Now a simple check to see if the round-trip worked.
+if (verified) {
+  alert('It works!!!');
+}
+else {
+  alert('Something went wrong....');
+}
+```
+
+- Note that you have to provide the hash function. In this example we use one from the [CryptoJS](https://github.com/brix/crypto-js) library, but you can use whichever you want.
+- Also, unless you use a custom hash function, you should provide the hash type to the `sign` method. Possible values are: `md2`, `md5`, `sha1`, `sha224`, `sha256`, `sha384`, `sha512`, `ripemd160`.
+
+Other Information
+========================
+
+This library heavily utilizes the wonderful work of Tom Wu found at http://www-cs-students.stanford.edu/~tjw/jsbn/.
+
+This jsbn library was written using the raw variables to perform encryption.  This is great for encryption, but most private keys use a Private Key in the PEM format seen below.
+
+1024 bit RSA Private Key in Base64 Format
+-----------------------------------------
+```
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQDHikastc8+I81zCg/qWW8dMr8mqvXQ3qbPAmu0RjxoZVI47tvs
+kYlFAXOf0sPrhO2nUuooJngnHV0639iTTEYG1vckNaW2R6U5QTdQ5Rq5u+uV3pMk
+7w7Vs4n3urQ6jnqt2rTXbC1DNa/PFeAZatbf7ffBBy0IGO0zc128IshYcwIDAQAB
+AoGBALTNl2JxTvq4SDW/3VH0fZkQXWH1MM10oeMbB2qO5beWb11FGaOO77nGKfWc
+bYgfp5Ogrql4yhBvLAXnxH8bcqqwORtFhlyV68U1y4R+8WxDNh0aevxH8hRS/1X5
+031DJm1JlU0E+vStiktN0tC3ebH5hE+1OxbIHSZ+WOWLYX7JAkEA5uigRgKp8ScG
+auUijvdOLZIhHWq7y5Wz+nOHUuDw8P7wOTKU34QJAoWEe771p9Pf/GTA/kr0BQnP
+QvWUDxGzJwJBAN05C6krwPeryFKrKtjOGJIniIoY72wRnoNcdEEs3HDRhf48YWFo
+riRbZylzzzNFy/gmzT6XJQTfktGqq+FZD9UCQGIJaGrxHJgfmpDuAhMzGsUsYtTr
+iRox0D1Iqa7dhE693t5aBG010OF6MLqdZA1CXrn5SRtuVVaCSLZEL/2J5UcCQQDA
+d3MXucNnN4NPuS/L9HMYJWD7lPoosaORcgyK77bSSNgk+u9WSjbH1uYIAIPSffUZ
+bti+jc1dUg5wb+aeZlgJAkEAurrpmpqj5vg087ZngKfFGR5rozDiTsK5DceTV97K
+a3Y+Nzl+XWTxDBWk4YPh2ZlKv402hZEfWBYxUDn5ZkH/bw==
+-----END RSA PRIVATE KEY-----
+```
+
+This library simply takes keys in the following format, and translates it to those variables needed to perform the encryptions used in Tom Wu's library.
+
+Here are some good resources to investigate further.
+ - http://etherhack.co.uk/asymmetric/docs/rsa_key_breakdown.html
+ - http://www.di-mgt.com.au/rsa_alg.html
+ - https://polarssl.org/kb/cryptography/asn1-key-structures-in-der-and-pem
+
+With this information, we can translate a private key format to the variables
+required with the jsbn library from Tom Wu by using the following mappings.
+
+```
+modulus => n
+public exponent => e
+private exponent => d
+prime1 => p
+prime2 => q
+exponent1 => dmp1
+exponent2 => dmq1
+coefficient => coeff
+```
+
--- a/node_modules/jsencrypt/bin/jsencrypt.js
+++ b/node_modules/jsencrypt/bin/jsencrypt.js
--- a/node_modules/jsencrypt/bin/jsencrypt.min.js
+++ b/node_modules/jsencrypt/bin/jsencrypt.min.js
--- a/node_modules/jsencrypt/bin/jsencrypt.min.js.LICENSE.txt
+++ b/node_modules/jsencrypt/bin/jsencrypt.min.js.LICENSE.txt
@ -0,0 +1,8 @@
+/**
+ * @fileOverview
+ * @name asn1-1.0.js
+ * @author Kenji Urushima kenji.urushima@gmail.com
+ * @version asn1 1.0.13 (2017-Jun-02)
+ * @since jsrsasign 2.1
+ * @license <a href="https://kjur.github.io/jsrsasign/license/">MIT License</a>
+ */
--- a/node_modules/jsencrypt/lib/JSEncrypt.d.ts
+++ b/node_modules/jsencrypt/lib/JSEncrypt.d.ts
@ -0,0 +1,116 @@
+import { JSEncryptRSAKey } from "./JSEncryptRSAKey";
+export interface IJSEncryptOptions {
+    default_key_size?: string;
+    default_public_exponent?: string;
+    log?: boolean;
+}
+/**
+ *
+ * @param {Object} [options = {}] - An object to customize JSEncrypt behaviour
+ * possible parameters are:
+ * - 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
+ */
+export declare class JSEncrypt {
+    constructor(options?: IJSEncryptOptions);
+    private default_key_size;
+    private default_public_exponent;
+    private log;
+    private key;
+    static version: string;
+    /**
+     * 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
+     */
+    setKey(key: string): void;
+    /**
+     * Proxy method for setKey, for api compatibility
+     * @see setKey
+     * @public
+     */
+    setPrivateKey(privkey: string): void;
+    /**
+     * Proxy method for setKey, for api compatibility
+     * @see setKey
+     * @public
+     */
+    setPublicKey(pubkey: string): void;
+    /**
+     * 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
+     */
+    decrypt(str: string): string | 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
+     */
+    encrypt(str: string): string | 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
+     */
+    sign(str: string, digestMethod: (str: string) => string, digestName: string): string | false;
+    /**
+     * 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
+     */
+    verify(str: string, signature: string, digestMethod: (str: string) => string): boolean;
+    /**
+     * 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
+     */
+    getKey(cb?: () => void): JSEncryptRSAKey;
+    /**
+     * 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
+     */
+    getPrivateKey(): string;
+    /**
+     * 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
+     */
+    getPrivateKeyB64(): string;
+    /**
+     * 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
+     */
+    getPublicKey(): string;
+    /**
+     * 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
+     */
+    getPublicKeyB64(): string;
+}
--- a/node_modules/jsencrypt/lib/JSEncrypt.js
+++ b/node_modules/jsencrypt/lib/JSEncrypt.js
@ -0,0 +1,192 @@
+var _a;
+import { b64tohex, hex2b64 } from "./lib/jsbn/base64";
+import { JSEncryptRSAKey } from "./JSEncryptRSAKey";
+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:
+ * - 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 = {}; }
+        options = 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 = 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 (this.log && this.key) {
+            console.warn("A key was already set, overriding existing.");
+        }
+        this.key = new JSEncryptRSAKey(key);
+    };
+    /**
+     * 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 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) {
+        // return the RSA signature of 'str' in 'hex' format.
+        try {
+            return hex2b64(this.getKey().sign(str, digestMethod, digestName));
+        }
+        catch (ex) {
+            return false;
+        }
+    };
+    /**
+     * 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) {
+        // Return the decrypted 'digest' of the signature.
+        try {
+            return this.getKey().verify(str, b64tohex(signature), digestMethod);
+        }
+        catch (ex) {
+            return false;
+        }
+    };
+    /**
+     * 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 };
--- a/node_modules/jsencrypt/lib/JSEncryptRSAKey.d.ts
+++ b/node_modules/jsencrypt/lib/JSEncryptRSAKey.d.ts
@ -0,0 +1,142 @@
+import { RSAKey } from "./lib/jsbn/rsa";
+/**
+ * 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
+ */
+export declare class JSEncryptRSAKey extends RSAKey {
+    constructor(key?: string);
+    /**
+     * 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
+     */
+    parseKey(pem: string): boolean;
+    /**
+     * 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
+     */
+    getPrivateBaseKey(): string;
+    /**
+     * base64 (pem) encoded version of the DER encoded representation
+     * @returns {string} pem encoded representation without header and footer
+     * @public
+     */
+    getPrivateBaseKeyB64(): string;
+    /**
+     * 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
+     */
+    getPublicBaseKey(): string;
+    /**
+     * base64 (pem) encoded version of the DER encoded representation
+     * @returns {string} pem encoded representation without header and footer
+     * @public
+     */
+    getPublicBaseKeyB64(): string;
+    /**
+     * 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
+     */
+    static wordwrap(str: string, width?: number): string;
+    /**
+     * Retrieve the pem encoded private key
+     * @returns {string} the pem encoded private key with header/footer
+     * @public
+     */
+    getPrivateKey(): string;
+    /**
+     * Retrieve the pem encoded public key
+     * @returns {string} the pem encoded public key with header/footer
+     * @public
+     */
+    getPublicKey(): string;
+    /**
+     * 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
+     */
+    static hasPublicKeyProperty(obj: object): boolean;
+    /**
+     * 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
+     */
+    static hasPrivateKeyProperty(obj: object): boolean;
+    /**
+     * 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
+     */
+    parsePropertiesFrom(obj: any): void;
+}
--- a/node_modules/jsencrypt/lib/JSEncryptRSAKey.js
+++ b/node_modules/jsencrypt/lib/JSEncryptRSAKey.js
@ -0,0 +1,320 @@
+var __extends = (this && this.__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 __());
+    };
+})();
+import { hex2b64 } from "./lib/jsbn/base64";
+import { Hex } from "./lib/asn1js/hex";
+import { Base64 } from "./lib/asn1js/base64";
+import { ASN1 } from "./lib/asn1js/asn1";
+import { RSAKey } from "./lib/jsbn/rsa";
+import { parseBigInt } from "./lib/jsbn/jsbn";
+import { KJUR } from "./lib/jsrsasign/asn1-1.0";
+/**
+ * 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" }),
+                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 };
--- a/node_modules/jsencrypt/lib/index.d.ts
+++ b/node_modules/jsencrypt/lib/index.d.ts
@ -0,0 +1,3 @@
+import { JSEncrypt } from './JSEncrypt';
+export { JSEncrypt };
+export default JSEncrypt;
--- a/node_modules/jsencrypt/lib/index.js
+++ b/node_modules/jsencrypt/lib/index.js
@ -0,0 +1,3 @@
+import { JSEncrypt } from './JSEncrypt';
+export { JSEncrypt };
+export default JSEncrypt;
--- a/node_modules/jsencrypt/lib/lib/asn1js/asn1.d.ts
+++ b/node_modules/jsencrypt/lib/lib/asn1js/asn1.d.ts
@ -0,0 +1,51 @@
+import { Int10 } from "./int10";
+export declare class Stream {
+    constructor(enc: Stream | number[], pos?: number);
+    private enc;
+    pos: number;
+    get(pos?: number): number;
+    hexDigits: string;
+    hexByte(b: number): string;
+    hexDump(start: number, end: number, raw: boolean): string;
+    isASCII(start: number, end: number): boolean;
+    parseStringISO(start: number, end: number): string;
+    parseStringUTF(start: number, end: number): string;
+    parseStringBMP(start: number, end: number): string;
+    parseTime(start: number, end: number, shortYear: boolean): string;
+    parseInteger(start: number, end: number): string | 0 | -1;
+    parseBitString(start: number, end: number, maxLength: number): string;
+    parseOctetString(start: number, end: number, maxLength: number): string;
+    parseOID(start: number, end: number, maxLength: number): string;
+}
+export declare class ASN1 {
+    constructor(stream: Stream, header: number, length: number, tag: ASN1Tag, sub: ASN1[]);
+    private stream;
+    private header;
+    private length;
+    private tag;
+    sub: ASN1[];
+    typeName(): string;
+    content(maxLength: number): string | 0 | -1;
+    toString(): string;
+    toPrettyString(indent: string): string;
+    posStart(): number;
+    posContent(): number;
+    posEnd(): number;
+    toHexString(): string;
+    static decodeLength(stream: Stream): number;
+    /**
+     * Retrieve the hexadecimal value (as a string) of the current ASN.1 element
+     * @returns {string}
+     * @public
+     */
+    getHexStringValue(): string;
+    static decode(str: Stream | number[]): ASN1;
+}
+export declare class ASN1Tag {
+    constructor(stream: Stream);
+    tagClass: number;
+    tagConstructed: boolean;
+    tagNumber: number | Int10;
+    isUniversal(): boolean;
+    isEOC(): boolean;
+}
--- a/node_modules/jsencrypt/lib/lib/asn1js/asn1.js
+++ b/node_modules/jsencrypt/lib/lib/asn1js/asn1.js
@ -0,0 +1,565 @@
+// ASN.1 JavaScript decoder
+// Copyright (c) 2008-2014 Lapo Luchini <lapo@lapo.it>
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+/*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false */
+/*global oids */
+import { Int10 } from "./int10";
+var ellipsis = "\u2026";
+var reTimeS = /^(\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
+var reTimeL = /^(\d\d\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
+function stringCut(str, len) {
+    if (str.length > len) {
+        str = str.substring(0, len) + ellipsis;
+    }
+    return str;
+}
+var Stream = /** @class */ (function () {
+    function Stream(enc, pos) {
+        this.hexDigits = "0123456789ABCDEF";
+        if (enc instanceof Stream) {
+            this.enc = enc.enc;
+            this.pos = enc.pos;
+        }
+        else {
+            // enc should be an array or a binary string
+            this.enc = enc;
+            this.pos = pos;
+        }
+    }
+    Stream.prototype.get = function (pos) {
+        if (pos === undefined) {
+            pos = this.pos++;
+        }
+        if (pos >= this.enc.length) {
+            throw new Error("Requesting byte offset ".concat(pos, " on a stream of length ").concat(this.enc.length));
+        }
+        return ("string" === typeof this.enc) ? this.enc.charCodeAt(pos) : this.enc[pos];
+    };
+    Stream.prototype.hexByte = function (b) {
+        return this.hexDigits.charAt((b >> 4) & 0xF) + this.hexDigits.charAt(b & 0xF);
+    };
+    Stream.prototype.hexDump = function (start, end, raw) {
+        var s = "";
+        for (var i = start; i < end; ++i) {
+            s += this.hexByte(this.get(i));
+            if (raw !== true) {
+                switch (i & 0xF) {
+                    case 0x7:
+                        s += "  ";
+                        break;
+                    case 0xF:
+                        s += "\n";
+                        break;
+                    default:
+                        s += " ";
+                }
+            }
+        }
+        return s;
+    };
+    Stream.prototype.isASCII = function (start, end) {
+        for (var i = start; i < end; ++i) {
+            var c = this.get(i);
+            if (c < 32 || c > 176) {
+                return false;
+            }
+        }
+        return true;
+    };
+    Stream.prototype.parseStringISO = function (start, end) {
+        var s = "";
+        for (var i = start; i < end; ++i) {
+            s += String.fromCharCode(this.get(i));
+        }
+        return s;
+    };
+    Stream.prototype.parseStringUTF = function (start, end) {
+        var s = "";
+        for (var i = start; i < end;) {
+            var c = this.get(i++);
+            if (c < 128) {
+                s += String.fromCharCode(c);
+            }
+            else if ((c > 191) && (c < 224)) {
+                s += String.fromCharCode(((c & 0x1F) << 6) | (this.get(i++) & 0x3F));
+            }
+            else {
+                s += String.fromCharCode(((c & 0x0F) << 12) | ((this.get(i++) & 0x3F) << 6) | (this.get(i++) & 0x3F));
+            }
+        }
+        return s;
+    };
+    Stream.prototype.parseStringBMP = function (start, end) {
+        var str = "";
+        var hi;
+        var lo;
+        for (var i = start; i < end;) {
+            hi = this.get(i++);
+            lo = this.get(i++);
+            str += String.fromCharCode((hi << 8) | lo);
+        }
+        return str;
+    };
+    Stream.prototype.parseTime = function (start, end, shortYear) {
+        var s = this.parseStringISO(start, end);
+        var m = (shortYear ? reTimeS : reTimeL).exec(s);
+        if (!m) {
+            return "Unrecognized time: " + s;
+        }
+        if (shortYear) {
+            // to avoid querying the timer, use the fixed range [1970, 2069]
+            // it will conform with ITU X.400 [-10, +40] sliding window until 2030
+            m[1] = +m[1];
+            m[1] += (+m[1] < 70) ? 2000 : 1900;
+        }
+        s = m[1] + "-" + m[2] + "-" + m[3] + " " + m[4];
+        if (m[5]) {
+            s += ":" + m[5];
+            if (m[6]) {
+                s += ":" + m[6];
+                if (m[7]) {
+                    s += "." + m[7];
+                }
+            }
+        }
+        if (m[8]) {
+            s += " UTC";
+            if (m[8] != "Z") {
+                s += m[8];
+                if (m[9]) {
+                    s += ":" + m[9];
+                }
+            }
+        }
+        return s;
+    };
+    Stream.prototype.parseInteger = function (start, end) {
+        var v = this.get(start);
+        var neg = (v > 127);
+        var pad = neg ? 255 : 0;
+        var len;
+        var s = "";
+        // skip unuseful bits (not allowed in DER)
+        while (v == pad && ++start < end) {
+            v = this.get(start);
+        }
+        len = end - start;
+        if (len === 0) {
+            return neg ? -1 : 0;
+        }
+        // show bit length of huge integers
+        if (len > 4) {
+            s = v;
+            len <<= 3;
+            while (((+s ^ pad) & 0x80) == 0) {
+                s = +s << 1;
+                --len;
+            }
+            s = "(" + len + " bit)\n";
+        }
+        // decode the integer
+        if (neg) {
+            v = v - 256;
+        }
+        var n = new Int10(v);
+        for (var i = start + 1; i < end; ++i) {
+            n.mulAdd(256, this.get(i));
+        }
+        return s + n.toString();
+    };
+    Stream.prototype.parseBitString = function (start, end, maxLength) {
+        var unusedBit = this.get(start);
+        var lenBit = ((end - start - 1) << 3) - unusedBit;
+        var intro = "(" + lenBit + " bit)\n";
+        var s = "";
+        for (var i = start + 1; i < end; ++i) {
+            var b = this.get(i);
+            var skip = (i == end - 1) ? unusedBit : 0;
+            for (var j = 7; j >= skip; --j) {
+                s += (b >> j) & 1 ? "1" : "0";
+            }
+            if (s.length > maxLength) {
+                return intro + stringCut(s, maxLength);
+            }
+        }
+        return intro + s;
+    };
+    Stream.prototype.parseOctetString = function (start, end, maxLength) {
+        if (this.isASCII(start, end)) {
+            return stringCut(this.parseStringISO(start, end), maxLength);
+        }
+        var len = end - start;
+        var s = "(" + len + " byte)\n";
+        maxLength /= 2; // we work in bytes
+        if (len > maxLength) {
+            end = start + maxLength;
+        }
+        for (var i = start; i < end; ++i) {
+            s += this.hexByte(this.get(i));
+        }
+        if (len > maxLength) {
+            s += ellipsis;
+        }
+        return s;
+    };
+    Stream.prototype.parseOID = function (start, end, maxLength) {
+        var s = "";
+        var n = new Int10();
+        var bits = 0;
+        for (var i = start; i < end; ++i) {
+            var v = this.get(i);
+            n.mulAdd(128, v & 0x7F);
+            bits += 7;
+            if (!(v & 0x80)) { // finished
+                if (s === "") {
+                    n = n.simplify();
+                    if (n instanceof Int10) {
+                        n.sub(80);
+                        s = "2." + n.toString();
+                    }
+                    else {
+                        var m = n < 80 ? n < 40 ? 0 : 1 : 2;
+                        s = m + "." + (n - m * 40);
+                    }
+                }
+                else {
+                    s += "." + n.toString();
+                }
+                if (s.length > maxLength) {
+                    return stringCut(s, maxLength);
+                }
+                n = new Int10();
+                bits = 0;
+            }
+        }
+        if (bits > 0) {
+            s += ".incomplete";
+        }
+        return s;
+    };
+    return Stream;
+}());
+export { Stream };
+var ASN1 = /** @class */ (function () {
+    function ASN1(stream, header, length, tag, sub) {
+        if (!(tag instanceof ASN1Tag)) {
+            throw new Error("Invalid tag value.");
+        }
+        this.stream = stream;
+        this.header = header;
+        this.length = length;
+        this.tag = tag;
+        this.sub = sub;
+    }
+    ASN1.prototype.typeName = function () {
+        switch (this.tag.tagClass) {
+            case 0: // universal
+                switch (this.tag.tagNumber) {
+                    case 0x00:
+                        return "EOC";
+                    case 0x01:
+                        return "BOOLEAN";
+                    case 0x02:
+                        return "INTEGER";
+                    case 0x03:
+                        return "BIT_STRING";
+                    case 0x04:
+                        return "OCTET_STRING";
+                    case 0x05:
+                        return "NULL";
+                    case 0x06:
+                        return "OBJECT_IDENTIFIER";
+                    case 0x07:
+                        return "ObjectDescriptor";
+                    case 0x08:
+                        return "EXTERNAL";
+                    case 0x09:
+                        return "REAL";
+                    case 0x0A:
+                        return "ENUMERATED";
+                    case 0x0B:
+                        return "EMBEDDED_PDV";
+                    case 0x0C:
+                        return "UTF8String";
+                    case 0x10:
+                        return "SEQUENCE";
+                    case 0x11:
+                        return "SET";
+                    case 0x12:
+                        return "NumericString";
+                    case 0x13:
+                        return "PrintableString"; // ASCII subset
+                    case 0x14:
+                        return "TeletexString"; // aka T61String
+                    case 0x15:
+                        return "VideotexString";
+                    case 0x16:
+                        return "IA5String"; // ASCII
+                    case 0x17:
+                        return "UTCTime";
+                    case 0x18:
+                        return "GeneralizedTime";
+                    case 0x19:
+                        return "GraphicString";
+                    case 0x1A:
+                        return "VisibleString"; // ASCII subset
+                    case 0x1B:
+                        return "GeneralString";
+                    case 0x1C:
+                        return "UniversalString";
+                    case 0x1E:
+                        return "BMPString";
+                }
+                return "Universal_" + this.tag.tagNumber.toString();
+            case 1:
+                return "Application_" + this.tag.tagNumber.toString();
+            case 2:
+                return "[" + this.tag.tagNumber.toString() + "]"; // Context
+            case 3:
+                return "Private_" + this.tag.tagNumber.toString();
+        }
+    };
+    ASN1.prototype.content = function (maxLength) {
+        if (this.tag === undefined) {
+            return null;
+        }
+        if (maxLength === undefined) {
+            maxLength = Infinity;
+        }
+        var content = this.posContent();
+        var len = Math.abs(this.length);
+        if (!this.tag.isUniversal()) {
+            if (this.sub !== null) {
+                return "(" + this.sub.length + " elem)";
+            }
+            return this.stream.parseOctetString(content, content + len, maxLength);
+        }
+        switch (this.tag.tagNumber) {
+            case 0x01: // BOOLEAN
+                return (this.stream.get(content) === 0) ? "false" : "true";
+            case 0x02: // INTEGER
+                return this.stream.parseInteger(content, content + len);
+            case 0x03: // BIT_STRING
+                return this.sub ? "(" + this.sub.length + " elem)" :
+                    this.stream.parseBitString(content, content + len, maxLength);
+            case 0x04: // OCTET_STRING
+                return this.sub ? "(" + this.sub.length + " elem)" :
+                    this.stream.parseOctetString(content, content + len, maxLength);
+            // case 0x05: // NULL
+            case 0x06: // OBJECT_IDENTIFIER
+                return this.stream.parseOID(content, content + len, maxLength);
+            // case 0x07: // ObjectDescriptor
+            // case 0x08: // EXTERNAL
+            // case 0x09: // REAL
+            // case 0x0A: // ENUMERATED
+            // case 0x0B: // EMBEDDED_PDV
+            case 0x10: // SEQUENCE
+            case 0x11: // SET
+                if (this.sub !== null) {
+                    return "(" + this.sub.length + " elem)";
+                }
+                else {
+                    return "(no elem)";
+                }
+            case 0x0C: // UTF8String
+                return stringCut(this.stream.parseStringUTF(content, content + len), maxLength);
+            case 0x12: // NumericString
+            case 0x13: // PrintableString
+            case 0x14: // TeletexString
+            case 0x15: // VideotexString
+            case 0x16: // IA5String
+            // case 0x19: // GraphicString
+            case 0x1A: // VisibleString
+                // case 0x1B: // GeneralString
+                // case 0x1C: // UniversalString
+                return stringCut(this.stream.parseStringISO(content, content + len), maxLength);
+            case 0x1E: // BMPString
+                return stringCut(this.stream.parseStringBMP(content, content + len), maxLength);
+            case 0x17: // UTCTime
+            case 0x18: // GeneralizedTime
+                return this.stream.parseTime(content, content + len, (this.tag.tagNumber == 0x17));
+        }
+        return null;
+    };
+    ASN1.prototype.toString = function () {
+        return this.typeName() + "@" + this.stream.pos + "[header:" + this.header + ",length:" + this.length + ",sub:" + ((this.sub === null) ? "null" : this.sub.length) + "]";
+    };
+    ASN1.prototype.toPrettyString = function (indent) {
+        if (indent === undefined) {
+            indent = "";
+        }
+        var s = indent + this.typeName() + " @" + this.stream.pos;
+        if (this.length >= 0) {
+            s += "+";
+        }
+        s += this.length;
+        if (this.tag.tagConstructed) {
+            s += " (constructed)";
+        }
+        else if ((this.tag.isUniversal() && ((this.tag.tagNumber == 0x03) || (this.tag.tagNumber == 0x04))) && (this.sub !== null)) {
+            s += " (encapsulates)";
+        }
+        s += "\n";
+        if (this.sub !== null) {
+            indent += "  ";
+            for (var i = 0, max = this.sub.length; i < max; ++i) {
+                s += this.sub[i].toPrettyString(indent);
+            }
+        }
+        return s;
+    };
+    ASN1.prototype.posStart = function () {
+        return this.stream.pos;
+    };
+    ASN1.prototype.posContent = function () {
+        return this.stream.pos + this.header;
+    };
+    ASN1.prototype.posEnd = function () {
+        return this.stream.pos + this.header + Math.abs(this.length);
+    };
+    ASN1.prototype.toHexString = function () {
+        return this.stream.hexDump(this.posStart(), this.posEnd(), true);
+    };
+    ASN1.decodeLength = function (stream) {
+        var buf = stream.get();
+        var len = buf & 0x7F;
+        if (len == buf) {
+            return len;
+        }
+        // no reason to use Int10, as it would be a huge buffer anyways
+        if (len > 6) {
+            throw new Error("Length over 48 bits not supported at position " + (stream.pos - 1));
+        }
+        if (len === 0) {
+            return null;
+        } // undefined
+        buf = 0;
+        for (var i = 0; i < len; ++i) {
+            buf = (buf * 256) + stream.get();
+        }
+        return buf;
+    };
+    /**
+     * Retrieve the hexadecimal value (as a string) of the current ASN.1 element
+     * @returns {string}
+     * @public
+     */
+    ASN1.prototype.getHexStringValue = function () {
+        var hexString = this.toHexString();
+        var offset = this.header * 2;
+        var length = this.length * 2;
+        return hexString.substr(offset, length);
+    };
+    ASN1.decode = function (str) {
+        var stream;
+        if (!(str instanceof Stream)) {
+            stream = new Stream(str, 0);
+        }
+        else {
+            stream = str;
+        }
+        var streamStart = new Stream(stream);
+        var tag = new ASN1Tag(stream);
+        var len = ASN1.decodeLength(stream);
+        var start = stream.pos;
+        var header = start - streamStart.pos;
+        var sub = null;
+        var getSub = function () {
+            var ret = [];
+            if (len !== null) {
+                // definite length
+                var end = start + len;
+                while (stream.pos < end) {
+                    ret[ret.length] = ASN1.decode(stream);
+                }
+                if (stream.pos != end) {
+                    throw new Error("Content size is not correct for container starting at offset " + start);
+                }
+            }
+            else {
+                // undefined length
+                try {
+                    for (;;) {
+                        var s = ASN1.decode(stream);
+                        if (s.tag.isEOC()) {
+                            break;
+                        }
+                        ret[ret.length] = s;
+                    }
+                    len = start - stream.pos; // undefined lengths are represented as negative values
+                }
+                catch (e) {
+                    throw new Error("Exception while decoding undefined length content: " + e);
+                }
+            }
+            return ret;
+        };
+        if (tag.tagConstructed) {
+            // must have valid content
+            sub = getSub();
+        }
+        else if (tag.isUniversal() && ((tag.tagNumber == 0x03) || (tag.tagNumber == 0x04))) {
+            // sometimes BitString and OctetString are used to encapsulate ASN.1
+            try {
+                if (tag.tagNumber == 0x03) {
+                    if (stream.get() != 0) {
+                        throw new Error("BIT STRINGs with unused bits cannot encapsulate.");
+                    }
+                }
+                sub = getSub();
+                for (var i = 0; i < sub.length; ++i) {
+                    if (sub[i].tag.isEOC()) {
+                        throw new Error("EOC is not supposed to be actual content.");
+                    }
+                }
+            }
+            catch (e) {
+                // but silently ignore when they don't
+                sub = null;
+            }
+        }
+        if (sub === null) {
+            if (len === null) {
+                throw new Error("We can't skip over an invalid tag with undefined length at offset " + start);
+            }
+            stream.pos = start + Math.abs(len);
+        }
+        return new ASN1(streamStart, header, len, tag, sub);
+    };
+    return ASN1;
+}());
+export { ASN1 };
+var ASN1Tag = /** @class */ (function () {
+    function ASN1Tag(stream) {
+        var buf = stream.get();
+        this.tagClass = buf >> 6;
+        this.tagConstructed = ((buf & 0x20) !== 0);
+        this.tagNumber = buf & 0x1F;
+        if (this.tagNumber == 0x1F) { // long tag
+            var n = new Int10();
+            do {
+                buf = stream.get();
+                n.mulAdd(128, buf & 0x7F);
+            } while (buf & 0x80);
+            this.tagNumber = n.simplify();
+        }
+    }
+    ASN1Tag.prototype.isUniversal = function () {
+        return this.tagClass === 0x00;
+    };
+    ASN1Tag.prototype.isEOC = function () {
+        return this.tagClass === 0x00 && this.tagNumber === 0x00;
+    };
+    return ASN1Tag;
+}());
+export { ASN1Tag };
--- a/node_modules/jsencrypt/lib/lib/asn1js/base64.d.ts
+++ b/node_modules/jsencrypt/lib/lib/asn1js/base64.d.ts
@ -0,0 +1,5 @@
+export declare const Base64: {
+    decode(a: string): number[];
+    re: RegExp;
+    unarmor(a: string): number[];
+};
--- a/node_modules/jsencrypt/lib/lib/asn1js/base64.js
+++ b/node_modules/jsencrypt/lib/lib/asn1js/base64.js
@ -0,0 +1,88 @@
+// Base64 JavaScript decoder
+// Copyright (c) 2008-2013 Lapo Luchini <lapo@lapo.it>
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+/*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false */
+var decoder;
+export var Base64 = {
+    decode: function (a) {
+        var i;
+        if (decoder === undefined) {
+            var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+            var ignore = "= \f\n\r\t\u00A0\u2028\u2029";
+            decoder = Object.create(null);
+            for (i = 0; i < 64; ++i) {
+                decoder[b64.charAt(i)] = i;
+            }
+            decoder['-'] = 62; //+
+            decoder['_'] = 63; //-
+            for (i = 0; i < ignore.length; ++i) {
+                decoder[ignore.charAt(i)] = -1;
+            }
+        }
+        var out = [];
+        var bits = 0;
+        var char_count = 0;
+        for (i = 0; i < a.length; ++i) {
+            var c = a.charAt(i);
+            if (c == "=") {
+                break;
+            }
+            c = decoder[c];
+            if (c == -1) {
+                continue;
+            }
+            if (c === undefined) {
+                throw new Error("Illegal character at offset " + i);
+            }
+            bits |= c;
+            if (++char_count >= 4) {
+                out[out.length] = (bits >> 16);
+                out[out.length] = (bits >> 8) & 0xFF;
+                out[out.length] = bits & 0xFF;
+                bits = 0;
+                char_count = 0;
+            }
+            else {
+                bits <<= 6;
+            }
+        }
+        switch (char_count) {
+            case 1:
+                throw new Error("Base64 encoding incomplete: at least 2 bits missing");
+            case 2:
+                out[out.length] = (bits >> 10);
+                break;
+            case 3:
+                out[out.length] = (bits >> 16);
+                out[out.length] = (bits >> 8) & 0xFF;
+                break;
+        }
+        return out;
+    },
+    re: /-----BEGIN [^-]+-----([A-Za-z0-9+\/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+\/=\s]+)====/,
+    unarmor: function (a) {
+        var m = Base64.re.exec(a);
+        if (m) {
+            if (m[1]) {
+                a = m[1];
+            }
+            else if (m[2]) {
+                a = m[2];
+            }
+            else {
+                throw new Error("RegExp out of sync");
+            }
+        }
+        return Base64.decode(a);
+    }
+};
--- a/node_modules/jsencrypt/lib/lib/asn1js/hex.d.ts
+++ b/node_modules/jsencrypt/lib/lib/asn1js/hex.d.ts
@ -0,0 +1,3 @@
+export declare const Hex: {
+    decode(a: string): number[];
+};
--- a/node_modules/jsencrypt/lib/lib/asn1js/hex.js
+++ b/node_modules/jsencrypt/lib/lib/asn1js/hex.js
@ -0,0 +1,64 @@
+// Hex JavaScript decoder
+// Copyright (c) 2008-2013 Lapo Luchini <lapo@lapo.it>
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+/*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false */
+var decoder;
+export var Hex = {
+    decode: function (a) {
+        var i;
+        if (decoder === undefined) {
+            var hex = "0123456789ABCDEF";
+            var ignore = " \f\n\r\t\u00A0\u2028\u2029";
+            decoder = {};
+            for (i = 0; i < 16; ++i) {
+                decoder[hex.charAt(i)] = i;
+            }
+            hex = hex.toLowerCase();
+            for (i = 10; i < 16; ++i) {
+                decoder[hex.charAt(i)] = i;
+            }
+            for (i = 0; i < ignore.length; ++i) {
+                decoder[ignore.charAt(i)] = -1;
+            }
+        }
+        var out = [];
+        var bits = 0;
+        var char_count = 0;
+        for (i = 0; i < a.length; ++i) {
+            var c = a.charAt(i);
+            if (c == "=") {
+                break;
+            }
+            c = decoder[c];
+            if (c == -1) {
+                continue;
+            }
+            if (c === undefined) {
+                throw new Error("Illegal character at offset " + i);
+            }
+            bits |= c;
+            if (++char_count >= 2) {
+                out[out.length] = bits;
+                bits = 0;
+                char_count = 0;
+            }
+            else {
+                bits <<= 4;
+            }
+        }
+        if (char_count) {
+            throw new Error("Hex encoding incomplete: 4 bits missing");
+        }
+        return out;
+    }
+};
--- a/node_modules/jsencrypt/lib/lib/asn1js/int10.d.ts
+++ b/node_modules/jsencrypt/lib/lib/asn1js/int10.d.ts
@ -0,0 +1,9 @@
+export declare class Int10 {
+    constructor(value?: string | number);
+    mulAdd(m: number, c: number): void;
+    sub(c: number): void;
+    toString(base?: number): string;
+    valueOf(): number;
+    simplify(): number | this;
+    private buf;
+}
--- a/node_modules/jsencrypt/lib/lib/asn1js/int10.js
+++ b/node_modules/jsencrypt/lib/lib/asn1js/int10.js
@ -0,0 +1,87 @@
+// Big integer base-10 printing library
+// Copyright (c) 2014 Lapo Luchini <lapo@lapo.it>
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+/*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false */
+var max = 10000000000000; // biggest integer that can still fit 2^53 when multiplied by 256
+var Int10 = /** @class */ (function () {
+    function Int10(value) {
+        this.buf = [+value || 0];
+    }
+    Int10.prototype.mulAdd = function (m, c) {
+        // assert(m <= 256)
+        var b = this.buf;
+        var l = b.length;
+        var i;
+        var t;
+        for (i = 0; i < l; ++i) {
+            t = b[i] * m + c;
+            if (t < max) {
+                c = 0;
+            }
+            else {
+                c = 0 | (t / max);
+                t -= c * max;
+            }
+            b[i] = t;
+        }
+        if (c > 0) {
+            b[i] = c;
+        }
+    };
+    Int10.prototype.sub = function (c) {
+        // assert(m <= 256)
+        var b = this.buf;
+        var l = b.length;
+        var i;
+        var t;
+        for (i = 0; i < l; ++i) {
+            t = b[i] - c;
+            if (t < 0) {
+                t += max;
+                c = 1;
+            }
+            else {
+                c = 0;
+            }
+            b[i] = t;
+        }
+        while (b[b.length - 1] === 0) {
+            b.pop();
+        }
+    };
+    Int10.prototype.toString = function (base) {
+        if ((base || 10) != 10) {
+            throw new Error("only base 10 is supported");
+        }
+        var b = this.buf;
+        var s = b[b.length - 1].toString();
+        for (var i = b.length - 2; i >= 0; --i) {
+            s += (max + b[i]).toString().substring(1);
+        }
+        return s;
+    };
+    Int10.prototype.valueOf = function () {
+        var b = this.buf;
+        var v = 0;
+        for (var i = b.length - 1; i >= 0; --i) {
+            v = v * max + b[i];
+        }
+        return v;
+    };
+    Int10.prototype.simplify = function () {
+        var b = this.buf;
+        return (b.length == 1) ? b[0] : this;
+    };
+    return Int10;
+}());
+export { Int10 };
--- a/node_modules/jsencrypt/lib/lib/asn1js/oids.d.ts
+++ b/node_modules/jsencrypt/lib/lib/asn1js/oids.d.ts
--- a/node_modules/jsencrypt/lib/lib/asn1js/oids.js
+++ b/node_modules/jsencrypt/lib/lib/asn1js/oids.js
--- a/node_modules/jsencrypt/lib/lib/jsbn/base64.d.ts
+++ b/node_modules/jsencrypt/lib/lib/jsbn/base64.d.ts
@ -0,0 +1,3 @@
+export declare function hex2b64(h: string): string;
+export declare function b64tohex(s: string): string;
+export declare function b64toBA(s: string): number[];
--- a/node_modules/jsencrypt/lib/lib/jsbn/base64.js
+++ b/node_modules/jsencrypt/lib/lib/jsbn/base64.js
@ -0,0 +1,76 @@
+import { int2char } from "./util";
+var b64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var b64pad = "=";
+export function hex2b64(h) {
+    var i;
+    var c;
+    var ret = "";
+    for (i = 0; i + 3 <= h.length; i += 3) {
+        c = parseInt(h.substring(i, i + 3), 16);
+        ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63);
+    }
+    if (i + 1 == h.length) {
+        c = parseInt(h.substring(i, i + 1), 16);
+        ret += b64map.charAt(c << 2);
+    }
+    else if (i + 2 == h.length) {
+        c = parseInt(h.substring(i, i + 2), 16);
+        ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4);
+    }
+    while ((ret.length & 3) > 0) {
+        ret += b64pad;
+    }
+    return ret;
+}
+// convert a base64 string to hex
+export function b64tohex(s) {
+    var ret = "";
+    var i;
+    var k = 0; // b64 state, 0-3
+    var slop = 0;
+    for (i = 0; i < s.length; ++i) {
+        if (s.charAt(i) == b64pad) {
+            break;
+        }
+        var v = b64map.indexOf(s.charAt(i));
+        if (v < 0) {
+            continue;
+        }
+        if (k == 0) {
+            ret += int2char(v >> 2);
+            slop = v & 3;
+            k = 1;
+        }
+        else if (k == 1) {
+            ret += int2char((slop << 2) | (v >> 4));
+            slop = v & 0xf;
+            k = 2;
+        }
+        else if (k == 2) {
+            ret += int2char(slop);
+            ret += int2char(v >> 2);
+            slop = v & 3;
+            k = 3;
+        }
+        else {
+            ret += int2char((slop << 2) | (v >> 4));
+            ret += int2char(v & 0xf);
+            k = 0;
+        }
+    }
+    if (k == 1) {
+        ret += int2char(slop << 2);
+    }
+    return ret;
+}
+// convert a base64 string to a byte/number array
+export function b64toBA(s) {
+    // piggyback on b64tohex for now, optimize later
+    var h = b64tohex(s);
+    var i;
+    var a = [];
+    for (i = 0; 2 * i < h.length; ++i) {
+        a[i] = parseInt(h.substring(2 * i, 2 * i + 2), 16);
+    }
+    return a;
+}
--- a/node_modules/jsencrypt/lib/lib/jsbn/jsbn.d.ts
+++ b/node_modules/jsencrypt/lib/lib/jsbn/jsbn.d.ts
@ -0,0 +1,98 @@
+import { SecureRandom } from "./rng";
+export declare class BigInteger {
+    constructor(a: number | number[] | string, b?: number | SecureRandom, c?: number | SecureRandom);
+    toString(b: number): string;
+    protected negate(): BigInteger;
+    abs(): BigInteger;
+    compareTo(a: BigInteger): number;
+    bitLength(): number;
+    mod(a: BigInteger): BigInteger;
+    modPowInt(e: number, m: BigInteger): BigInteger;
+    protected clone(): BigInteger;
+    protected intValue(): number;
+    protected byteValue(): number;
+    protected shortValue(): number;
+    protected signum(): 0 | 1 | -1;
+    toByteArray(): number[];
+    protected equals(a: BigInteger): boolean;
+    protected min(a: BigInteger): BigInteger;
+    protected max(a: BigInteger): BigInteger;
+    protected and(a: BigInteger): BigInteger;
+    protected or(a: BigInteger): BigInteger;
+    protected xor(a: BigInteger): BigInteger;
+    protected andNot(a: BigInteger): BigInteger;
+    protected not(): BigInteger;
+    protected shiftLeft(n: number): BigInteger;
+    protected shiftRight(n: number): BigInteger;
+    protected getLowestSetBit(): number;
+    protected bitCount(): number;
+    protected testBit(n: number): boolean;
+    protected setBit(n: number): BigInteger;
+    protected clearBit(n: number): BigInteger;
+    protected flipBit(n: number): BigInteger;
+    add(a: BigInteger): BigInteger;
+    subtract(a: BigInteger): BigInteger;
+    multiply(a: BigInteger): BigInteger;
+    divide(a: BigInteger): BigInteger;
+    protected remainder(a: BigInteger): BigInteger;
+    protected divideAndRemainder(a: BigInteger): BigInteger[];
+    modPow(e: BigInteger, m: BigInteger): BigInteger;
+    modInverse(m: BigInteger): BigInteger;
+    protected pow(e: number): BigInteger;
+    gcd(a: BigInteger): BigInteger;
+    isProbablePrime(t: number): boolean;
+    copyTo(r: BigInteger): void;
+    fromInt(x: number): void;
+    protected fromString(s: string | number[], b: number): void;
+    clamp(): void;
+    dlShiftTo(n: number, r: BigInteger): void;
+    drShiftTo(n: number, r: BigInteger): void;
+    protected lShiftTo(n: number, r: BigInteger): void;
+    protected rShiftTo(n: number, r: BigInteger): void;
+    subTo(a: BigInteger, r: BigInteger): void;
+    multiplyTo(a: BigInteger, r: BigInteger): void;
+    squareTo(r: BigInteger): void;
+    divRemTo(m: BigInteger, q: BigInteger, r: BigInteger): void;
+    invDigit(): number;
+    protected isEven(): boolean;
+    protected exp(e: number, z: IReduction): BigInteger;
+    protected chunkSize(r: number): number;
+    protected toRadix(b: number): string;
+    fromRadix(s: string, b: number): void;
+    protected fromNumber(a: number, b: number | SecureRandom, c?: number | SecureRandom): void;
+    protected bitwiseTo(a: BigInteger, op: (a: number, b: number) => number, r: BigInteger): void;
+    protected changeBit(n: number, op: (a: number, b: number) => number): BigInteger;
+    protected addTo(a: BigInteger, r: BigInteger): void;
+    protected dMultiply(n: number): void;
+    dAddOffset(n: number, w: number): void;
+    multiplyLowerTo(a: BigInteger, n: number, r: BigInteger): void;
+    multiplyUpperTo(a: BigInteger, n: number, r: BigInteger): void;
+    protected modInt(n: number): number;
+    protected millerRabin(t: number): boolean;
+    protected square(): BigInteger;
+    gcda(a: BigInteger, callback: (x: BigInteger) => void): void;
+    fromNumberAsync(a: number, b: number | SecureRandom, c: number | SecureRandom, callback: () => void): void;
+    s: number;
+    t: number;
+    DB: number;
+    DM: number;
+    DV: number;
+    FV: number;
+    F1: number;
+    F2: number;
+    am: (i: number, x: number, w: BigInteger, j: number, c: number, n: number) => number;
+    [index: number]: number;
+    static ONE: BigInteger;
+    static ZERO: BigInteger;
+}
+export interface IReduction {
+    convert(x: BigInteger): BigInteger;
+    revert(x: BigInteger): BigInteger;
+    mulTo(x: BigInteger, y: BigInteger, r: BigInteger): void;
+    sqrTo(x: BigInteger, r: BigInteger): void;
+}
+export declare function nbi(): BigInteger;
+export declare function parseBigInt(str: string, r: number): BigInteger;
+export declare function intAt(s: string, i: number): number;
+export declare function nbv(i: number): BigInteger;
+export declare function nbits(x: number): number;
--- a/node_modules/jsencrypt/lib/lib/jsbn/jsbn.js
+++ b/node_modules/jsencrypt/lib/lib/jsbn/jsbn.js
--- a/node_modules/jsencrypt/lib/lib/jsbn/prng4.d.ts
+++ b/node_modules/jsencrypt/lib/lib/jsbn/prng4.d.ts
@ -0,0 +1,10 @@
+export declare class Arcfour {
+    constructor();
+    init(key: number[]): void;
+    next(): number;
+    private i;
+    private j;
+    private S;
+}
+export declare function prng_newstate(): Arcfour;
+export declare let rng_psize: number;
--- a/node_modules/jsencrypt/lib/lib/jsbn/prng4.js
+++ b/node_modules/jsencrypt/lib/lib/jsbn/prng4.js
@ -0,0 +1,46 @@
+// prng4.js - uses Arcfour as a PRNG
+var Arcfour = /** @class */ (function () {
+    function Arcfour() {
+        this.i = 0;
+        this.j = 0;
+        this.S = [];
+    }
+    // Arcfour.prototype.init = ARC4init;
+    // Initialize arcfour context from key, an array of ints, each from [0..255]
+    Arcfour.prototype.init = function (key) {
+        var i;
+        var j;
+        var t;
+        for (i = 0; i < 256; ++i) {
+            this.S[i] = i;
+        }
+        j = 0;
+        for (i = 0; i < 256; ++i) {
+            j = (j + this.S[i] + key[i % key.length]) & 255;
+            t = this.S[i];
+            this.S[i] = this.S[j];
+            this.S[j] = t;
+        }
+        this.i = 0;
+        this.j = 0;
+    };
+    // Arcfour.prototype.next = ARC4next;
+    Arcfour.prototype.next = function () {
+        var t;
+        this.i = (this.i + 1) & 255;
+        this.j = (this.j + this.S[this.i]) & 255;
+        t = this.S[this.i];
+        this.S[this.i] = this.S[this.j];
+        this.S[this.j] = t;
+        return this.S[(t + this.S[this.i]) & 255];
+    };
+    return Arcfour;
+}());
+export { Arcfour };
+// Plug in your RNG constructor here
+export function prng_newstate() {
+    return new Arcfour();
+}
+// Pool size must be a multiple of 4 and greater than 32.
+// An array of bytes the size of the pool will be passed to init()
+export var rng_psize = 256;
--- a/node_modules/jsencrypt/lib/lib/jsbn/rng.d.ts
+++ b/node_modules/jsencrypt/lib/lib/jsbn/rng.d.ts
@ -0,0 +1,3 @@
+export declare class SecureRandom {
+    nextBytes(ba: number[]): void;
+}
--- a/node_modules/jsencrypt/lib/lib/jsbn/rng.js
+++ b/node_modules/jsencrypt/lib/lib/jsbn/rng.js
@ -0,0 +1,78 @@
+// Random number generator - requires a PRNG backend, e.g. prng4.js
+import { prng_newstate, rng_psize } from "./prng4";
+var rng_state;
+var rng_pool = null;
+var rng_pptr;
+// Initialize the pool with junk if needed.
+if (rng_pool == null) {
+    rng_pool = [];
+    rng_pptr = 0;
+    var t = void 0;
+    if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
+        // Extract entropy (2048 bits) from RNG if available
+        var z = new Uint32Array(256);
+        window.crypto.getRandomValues(z);
+        for (t = 0; t < z.length; ++t) {
+            rng_pool[rng_pptr++] = z[t] & 255;
+        }
+    }
+    // Use mouse events for entropy, if we do not have enough entropy by the time
+    // we need it, entropy will be generated by Math.random.
+    var count = 0;
+    var onMouseMoveListener_1 = function (ev) {
+        count = count || 0;
+        if (count >= 256 || rng_pptr >= rng_psize) {
+            if (window.removeEventListener) {
+                window.removeEventListener("mousemove", onMouseMoveListener_1, false);
+            }
+            else if (window.detachEvent) {
+                window.detachEvent("onmousemove", onMouseMoveListener_1);
+            }
+            return;
+        }
+        try {
+            var mouseCoordinates = ev.x + ev.y;
+            rng_pool[rng_pptr++] = mouseCoordinates & 255;
+            count += 1;
+        }
+        catch (e) {
+            // Sometimes Firefox will deny permission to access event properties for some reason. Ignore.
+        }
+    };
+    if (typeof window !== 'undefined') {
+        if (window.addEventListener) {
+            window.addEventListener("mousemove", onMouseMoveListener_1, false);
+        }
+        else if (window.attachEvent) {
+            window.attachEvent("onmousemove", onMouseMoveListener_1);
+        }
+    }
+}
+function rng_get_byte() {
+    if (rng_state == null) {
+        rng_state = prng_newstate();
+        // At this point, we may not have collected enough entropy.  If not, fall back to Math.random
+        while (rng_pptr < rng_psize) {
+            var random = Math.floor(65536 * Math.random());
+            rng_pool[rng_pptr++] = random & 255;
+        }
+        rng_state.init(rng_pool);
+        for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
+            rng_pool[rng_pptr] = 0;
+        }
+        rng_pptr = 0;
+    }
+    // TODO: allow reseeding after first request
+    return rng_state.next();
+}
+var SecureRandom = /** @class */ (function () {
+    function SecureRandom() {
+    }
+    SecureRandom.prototype.nextBytes = function (ba) {
+        for (var i = 0; i < ba.length; ++i) {
+            ba[i] = rng_get_byte();
+        }
+    };
+    return SecureRandom;
+}());
+export { SecureRandom };
--- a/node_modules/jsencrypt/lib/lib/jsbn/rsa.d.ts
+++ b/node_modules/jsencrypt/lib/lib/jsbn/rsa.d.ts
@ -0,0 +1,23 @@
+import { BigInteger } from "./jsbn";
+export declare class RSAKey {
+    constructor();
+    doPublic(x: BigInteger): BigInteger;
+    doPrivate(x: BigInteger): BigInteger;
+    setPublic(N: string, E: string): void;
+    encrypt(text: string): string;
+    setPrivate(N: string, E: string, D: string): void;
+    setPrivateEx(N: string, E: string, D: string, P: string, Q: string, DP: string, DQ: string, C: string): void;
+    generate(B: number, E: string): void;
+    decrypt(ctext: string): string;
+    generateAsync(B: number, E: string, callback: () => void): void;
+    sign(text: string, digestMethod: (str: string) => string, digestName: string): string;
+    verify(text: string, signature: string, digestMethod: (str: string) => string): boolean;
+    protected n: BigInteger;
+    protected e: number;
+    protected d: BigInteger;
+    protected p: BigInteger;
+    protected q: BigInteger;
+    protected dmp1: BigInteger;
+    protected dmq1: BigInteger;
+    protected coeff: BigInteger;
+}
--- a/node_modules/jsencrypt/lib/lib/jsbn/rsa.js
+++ b/node_modules/jsencrypt/lib/lib/jsbn/rsa.js
@ -0,0 +1,373 @@
+// Depends on jsbn.js and rng.js
+// Version 1.1: support utf-8 encoding in pkcs1pad2
+// convert a (hex) string to a bignum object
+import { BigInteger, nbi, parseBigInt } from "./jsbn";
+import { SecureRandom } from "./rng";
+// function linebrk(s,n) {
+//   var ret = "";
+//   var i = 0;
+//   while(i + n < s.length) {
+//     ret += s.substring(i,i+n) + "\n";
+//     i += n;
+//   }
+//   return ret + s.substring(i,s.length);
+// }
+// function byte2Hex(b) {
+//   if(b < 0x10)
+//     return "0" + b.toString(16);
+//   else
+//     return b.toString(16);
+// }
+function pkcs1pad1(s, n) {
+    if (n < s.length + 22) {
+        console.error("Message too long for RSA");
+        return null;
+    }
+    var len = n - s.length - 6;
+    var filler = "";
+    for (var f = 0; f < len; f += 2) {
+        filler += "ff";
+    }
+    var m = "0001" + filler + "00" + s;
+    return parseBigInt(m, 16);
+}
+// PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
+function pkcs1pad2(s, n) {
+    if (n < s.length + 11) { // TODO: fix for utf-8
+        console.error("Message too long for RSA");
+        return null;
+    }
+    var ba = [];
+    var i = s.length - 1;
+    while (i >= 0 && n > 0) {
+        var c = s.charCodeAt(i--);
+        if (c < 128) { // encode using utf-8
+            ba[--n] = c;
+        }
+        else if ((c > 127) && (c < 2048)) {
+            ba[--n] = (c & 63) | 128;
+            ba[--n] = (c >> 6) | 192;
+        }
+        else {
+            ba[--n] = (c & 63) | 128;
+            ba[--n] = ((c >> 6) & 63) | 128;
+            ba[--n] = (c >> 12) | 224;
+        }
+    }
+    ba[--n] = 0;
+    var rng = new SecureRandom();
+    var x = [];
+    while (n > 2) { // random non-zero pad
+        x[0] = 0;
+        while (x[0] == 0) {
+            rng.nextBytes(x);
+        }
+        ba[--n] = x[0];
+    }
+    ba[--n] = 2;
+    ba[--n] = 0;
+    return new BigInteger(ba);
+}
+// "empty" RSA key constructor
+var RSAKey = /** @class */ (function () {
+    function RSAKey() {
+        this.n = null;
+        this.e = 0;
+        this.d = null;
+        this.p = null;
+        this.q = null;
+        this.dmp1 = null;
+        this.dmq1 = null;
+        this.coeff = null;
+    }
+    //#region PROTECTED
+    // protected
+    // RSAKey.prototype.doPublic = RSADoPublic;
+    // Perform raw public operation on "x": return x^e (mod n)
+    RSAKey.prototype.doPublic = function (x) {
+        return x.modPowInt(this.e, this.n);
+    };
+    // RSAKey.prototype.doPrivate = RSADoPrivate;
+    // Perform raw private operation on "x": return x^d (mod n)
+    RSAKey.prototype.doPrivate = function (x) {
+        if (this.p == null || this.q == null) {
+            return x.modPow(this.d, this.n);
+        }
+        // TODO: re-calculate any missing CRT params
+        var xp = x.mod(this.p).modPow(this.dmp1, this.p);
+        var xq = x.mod(this.q).modPow(this.dmq1, this.q);
+        while (xp.compareTo(xq) < 0) {
+            xp = xp.add(this.p);
+        }
+        return xp.subtract(xq).multiply(this.coeff).mod(this.p).multiply(this.q).add(xq);
+    };
+    //#endregion PROTECTED
+    //#region PUBLIC
+    // RSAKey.prototype.setPublic = RSASetPublic;
+    // Set the public key fields N and e from hex strings
+    RSAKey.prototype.setPublic = function (N, E) {
+        if (N != null && E != null && N.length > 0 && E.length > 0) {
+            this.n = parseBigInt(N, 16);
+            this.e = parseInt(E, 16);
+        }
+        else {
+            console.error("Invalid RSA public key");
+        }
+    };
+    // RSAKey.prototype.encrypt = RSAEncrypt;
+    // Return the PKCS#1 RSA encryption of "text" as an even-length hex string
+    RSAKey.prototype.encrypt = function (text) {
+        var maxLength = (this.n.bitLength() + 7) >> 3;
+        var m = pkcs1pad2(text, maxLength);
+        if (m == null) {
+            return null;
+        }
+        var c = this.doPublic(m);
+        if (c == null) {
+            return null;
+        }
+        var h = c.toString(16);
+        var length = h.length;
+        // fix zero before result
+        for (var i = 0; i < maxLength * 2 - length; i++) {
+            h = "0" + h;
+        }
+        return h;
+    };
+    // RSAKey.prototype.setPrivate = RSASetPrivate;
+    // Set the private key fields N, e, and d from hex strings
+    RSAKey.prototype.setPrivate = function (N, E, D) {
+        if (N != null && E != null && N.length > 0 && E.length > 0) {
+            this.n = parseBigInt(N, 16);
+            this.e = parseInt(E, 16);
+            this.d = parseBigInt(D, 16);
+        }
+        else {
+            console.error("Invalid RSA private key");
+        }
+    };
+    // RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
+    // Set the private key fields N, e, d and CRT params from hex strings
+    RSAKey.prototype.setPrivateEx = function (N, E, D, P, Q, DP, DQ, C) {
+        if (N != null && E != null && N.length > 0 && E.length > 0) {
+            this.n = parseBigInt(N, 16);
+            this.e = parseInt(E, 16);
+            this.d = parseBigInt(D, 16);
+            this.p = parseBigInt(P, 16);
+            this.q = parseBigInt(Q, 16);
+            this.dmp1 = parseBigInt(DP, 16);
+            this.dmq1 = parseBigInt(DQ, 16);
+            this.coeff = parseBigInt(C, 16);
+        }
+        else {
+            console.error("Invalid RSA private key");
+        }
+    };
+    // RSAKey.prototype.generate = RSAGenerate;
+    // Generate a new random private key B bits long, using public expt E
+    RSAKey.prototype.generate = function (B, E) {
+        var rng = new SecureRandom();
+        var qs = B >> 1;
+        this.e = parseInt(E, 16);
+        var ee = new BigInteger(E, 16);
+        for (;;) {
+            for (;;) {
+                this.p = new BigInteger(B - qs, 1, rng);
+                if (this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) {
+                    break;
+                }
+            }
+            for (;;) {
+                this.q = new BigInteger(qs, 1, rng);
+                if (this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) {
+                    break;
+                }
+            }
+            if (this.p.compareTo(this.q) <= 0) {
+                var t = this.p;
+                this.p = this.q;
+                this.q = t;
+            }
+            var p1 = this.p.subtract(BigInteger.ONE);
+            var q1 = this.q.subtract(BigInteger.ONE);
+            var phi = p1.multiply(q1);
+            if (phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {
+                this.n = this.p.multiply(this.q);
+                this.d = ee.modInverse(phi);
+                this.dmp1 = this.d.mod(p1);
+                this.dmq1 = this.d.mod(q1);
+                this.coeff = this.q.modInverse(this.p);
+                break;
+            }
+        }
+    };
+    // RSAKey.prototype.decrypt = RSADecrypt;
+    // Return the PKCS#1 RSA decryption of "ctext".
+    // "ctext" is an even-length hex string and the output is a plain string.
+    RSAKey.prototype.decrypt = function (ctext) {
+        var c = parseBigInt(ctext, 16);
+        var m = this.doPrivate(c);
+        if (m == null) {
+            return null;
+        }
+        return pkcs1unpad2(m, (this.n.bitLength() + 7) >> 3);
+    };
+    // Generate a new random private key B bits long, using public expt E
+    RSAKey.prototype.generateAsync = function (B, E, callback) {
+        var rng = new SecureRandom();
+        var qs = B >> 1;
+        this.e = parseInt(E, 16);
+        var ee = new BigInteger(E, 16);
+        var rsa = this;
+        // These functions have non-descript names because they were originally for(;;) loops.
+        // I don't know about cryptography to give them better names than loop1-4.
+        var loop1 = function () {
+            var loop4 = function () {
+                if (rsa.p.compareTo(rsa.q) <= 0) {
+                    var t = rsa.p;
+                    rsa.p = rsa.q;
+                    rsa.q = t;
+                }
+                var p1 = rsa.p.subtract(BigInteger.ONE);
+                var q1 = rsa.q.subtract(BigInteger.ONE);
+                var phi = p1.multiply(q1);
+                if (phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {
+                    rsa.n = rsa.p.multiply(rsa.q);
+                    rsa.d = ee.modInverse(phi);
+                    rsa.dmp1 = rsa.d.mod(p1);
+                    rsa.dmq1 = rsa.d.mod(q1);
+                    rsa.coeff = rsa.q.modInverse(rsa.p);
+                    setTimeout(function () { callback(); }, 0); // escape
+                }
+                else {
+                    setTimeout(loop1, 0);
+                }
+            };
+            var loop3 = function () {
+                rsa.q = nbi();
+                rsa.q.fromNumberAsync(qs, 1, rng, function () {
+                    rsa.q.subtract(BigInteger.ONE).gcda(ee, function (r) {
+                        if (r.compareTo(BigInteger.ONE) == 0 && rsa.q.isProbablePrime(10)) {
+                            setTimeout(loop4, 0);
+                        }
+                        else {
+                            setTimeout(loop3, 0);
+                        }
+                    });
+                });
+            };
+            var loop2 = function () {
+                rsa.p = nbi();
+                rsa.p.fromNumberAsync(B - qs, 1, rng, function () {
+                    rsa.p.subtract(BigInteger.ONE).gcda(ee, function (r) {
+                        if (r.compareTo(BigInteger.ONE) == 0 && rsa.p.isProbablePrime(10)) {
+                            setTimeout(loop3, 0);
+                        }
+                        else {
+                            setTimeout(loop2, 0);
+                        }
+                    });
+                });
+            };
+            setTimeout(loop2, 0);
+        };
+        setTimeout(loop1, 0);
+    };
+    RSAKey.prototype.sign = function (text, digestMethod, digestName) {
+        var header = getDigestHeader(digestName);
+        var digest = header + digestMethod(text).toString();
+        var m = pkcs1pad1(digest, this.n.bitLength() / 4);
+        if (m == null) {
+            return null;
+        }
+        var c = this.doPrivate(m);
+        if (c == null) {
+            return null;
+        }
+        var h = c.toString(16);
+        if ((h.length & 1) == 0) {
+            return h;
+        }
+        else {
+            return "0" + h;
+        }
+    };
+    RSAKey.prototype.verify = function (text, signature, digestMethod) {
+        var c = parseBigInt(signature, 16);
+        var m = this.doPublic(c);
+        if (m == null) {
+            return null;
+        }
+        var unpadded = m.toString(16).replace(/^1f+00/, "");
+        var digest = removeDigestHeader(unpadded);
+        return digest == digestMethod(text).toString();
+    };
+    return RSAKey;
+}());
+export { RSAKey };
+// Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
+function pkcs1unpad2(d, n) {
+    var b = d.toByteArray();
+    var i = 0;
+    while (i < b.length && b[i] == 0) {
+        ++i;
+    }
+    if (b.length - i != n - 1 || b[i] != 2) {
+        return null;
+    }
+    ++i;
+    while (b[i] != 0) {
+        if (++i >= b.length) {
+            return null;
+        }
+    }
+    var ret = "";
+    while (++i < b.length) {
+        var c = b[i] & 255;
+        if (c < 128) { // utf-8 decode
+            ret += String.fromCharCode(c);
+        }
+        else if ((c > 191) && (c < 224)) {
+            ret += String.fromCharCode(((c & 31) << 6) | (b[i + 1] & 63));
+            ++i;
+        }
+        else {
+            ret += String.fromCharCode(((c & 15) << 12) | ((b[i + 1] & 63) << 6) | (b[i + 2] & 63));
+            i += 2;
+        }
+    }
+    return ret;
+}
+// https://tools.ietf.org/html/rfc3447#page-43
+var DIGEST_HEADERS = {
+    md2: "3020300c06082a864886f70d020205000410",
+    md5: "3020300c06082a864886f70d020505000410",
+    sha1: "3021300906052b0e03021a05000414",
+    sha224: "302d300d06096086480165030402040500041c",
+    sha256: "3031300d060960864801650304020105000420",
+    sha384: "3041300d060960864801650304020205000430",
+    sha512: "3051300d060960864801650304020305000440",
+    ripemd160: "3021300906052b2403020105000414"
+};
+function getDigestHeader(name) {
+    return DIGEST_HEADERS[name] || "";
+}
+function removeDigestHeader(str) {
+    for (var name_1 in DIGEST_HEADERS) {
+        if (DIGEST_HEADERS.hasOwnProperty(name_1)) {
+            var header = DIGEST_HEADERS[name_1];
+            var len = header.length;
+            if (str.substr(0, len) == header) {
+                return str.substr(len);
+            }
+        }
+    }
+    return str;
+}
+// Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
+// function RSAEncryptB64(text) {
+//  var h = this.encrypt(text);
+//  if(h) return hex2b64(h); else return null;
+// }
+// public
+// RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
--- a/node_modules/jsencrypt/lib/lib/jsbn/util.d.ts
+++ b/node_modules/jsencrypt/lib/lib/jsbn/util.d.ts
@ -0,0 +1,7 @@
+export declare function int2char(n: number): string;
+export declare function op_and(x: number, y: number): number;
+export declare function op_or(x: number, y: number): number;
+export declare function op_xor(x: number, y: number): number;
+export declare function op_andnot(x: number, y: number): number;
+export declare function lbit(x: number): number;
+export declare function cbit(x: number): number;
--- a/node_modules/jsencrypt/lib/lib/jsbn/util.js
+++ b/node_modules/jsencrypt/lib/lib/jsbn/util.js
@ -0,0 +1,58 @@
+var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+export function int2char(n) {
+    return BI_RM.charAt(n);
+}
+//#region BIT_OPERATIONS
+// (public) this & a
+export function op_and(x, y) {
+    return x & y;
+}
+// (public) this | a
+export function op_or(x, y) {
+    return x | y;
+}
+// (public) this ^ a
+export function op_xor(x, y) {
+    return x ^ y;
+}
+// (public) this & ~a
+export function op_andnot(x, y) {
+    return x & ~y;
+}
+// return index of lowest 1-bit in x, x < 2^31
+export function lbit(x) {
+    if (x == 0) {
+        return -1;
+    }
+    var r = 0;
+    if ((x & 0xffff) == 0) {
+        x >>= 16;
+        r += 16;
+    }
+    if ((x & 0xff) == 0) {
+        x >>= 8;
+        r += 8;
+    }
+    if ((x & 0xf) == 0) {
+        x >>= 4;
+        r += 4;
+    }
+    if ((x & 3) == 0) {
+        x >>= 2;
+        r += 2;
+    }
+    if ((x & 1) == 0) {
+        ++r;
+    }
+    return r;
+}
+// return number of 1 bits in x
+export function cbit(x) {
+    var r = 0;
+    while (x != 0) {
+        x &= x - 1;
+        ++r;
+    }
+    return r;
+}
+//#endregion BIT_OPERATIONS
--- a/node_modules/jsencrypt/lib/lib/jsrsasign/asn1-1.0.js
+++ b/node_modules/jsencrypt/lib/lib/jsrsasign/asn1-1.0.js
--- a/node_modules/jsencrypt/lib/lib/jsrsasign/yahoo.js
+++ b/node_modules/jsencrypt/lib/lib/jsrsasign/yahoo.js
@ -0,0 +1,69 @@
+/*!
+Copyright (c) 2011, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.com/yui/license.html
+version: 2.9.0
+*/
+export var YAHOO = {};
+YAHOO.lang = {
+    /**
+     * Utility to set up the prototype, constructor and superclass properties to
+     * support an inheritance strategy that can chain constructors and methods.
+     * Static members will not be inherited.
+     *
+     * @method extend
+     * @static
+     * @param {Function} subc   the object to modify
+     * @param {Function} superc the object to inherit
+     * @param {Object} overrides  additional properties/methods to add to the
+     *                              subclass prototype.  These will override the
+     *                              matching items obtained from the superclass
+     *                              if present.
+     */
+    extend: function (subc, superc, overrides) {
+        if (!superc || !subc) {
+            throw new Error("YAHOO.lang.extend failed, please check that " +
+                "all dependencies are included.");
+        }
+        var F = function () { };
+        F.prototype = superc.prototype;
+        subc.prototype = new F();
+        subc.prototype.constructor = subc;
+        subc.superclass = superc.prototype;
+        if (superc.prototype.constructor == Object.prototype.constructor) {
+            superc.prototype.constructor = superc;
+        }
+        if (overrides) {
+            var i;
+            for (i in overrides) {
+                subc.prototype[i] = overrides[i];
+            }
+            /*
+             * IE will not enumerate native functions in a derived object even if the
+             * function was overridden.  This is a workaround for specific functions
+             * we care about on the Object prototype.
+             * @property _IEEnumFix
+             * @param {Function} r  the object to receive the augmentation
+             * @param {Function} s  the object that supplies the properties to augment
+             * @static
+             * @private
+             */
+            var _IEEnumFix = function () { }, ADD = ["toString", "valueOf"];
+            try {
+                if (/MSIE/.test(navigator.userAgent)) {
+                    _IEEnumFix = function (r, s) {
+                        for (i = 0; i < ADD.length; i = i + 1) {
+                            var fname = ADD[i], f = s[fname];
+                            if (typeof f === 'function' && f != Object.prototype[fname]) {
+                                r[fname] = f;
+                            }
+                        }
+                    };
+                }
+            }
+            catch (ex) { }
+            ;
+            _IEEnumFix(subc.prototype, overrides);
+        }
+    }
+};
--- a/node_modules/jsencrypt/lib/version.json
+++ b/node_modules/jsencrypt/lib/version.json
@ -0,0 +1 @@
+{"version": "3.3.0"}
--- a/node_modules/jsencrypt/package.json
+++ b/node_modules/jsencrypt/package.json
@ -0,0 +1,71 @@
+{
+    "name": "jsencrypt",
+    "version": "3.3.2",
+    "description": "A Javascript library to perform OpenSSL RSA Encryption, Decryption, and Key Generation.",
+    "main": "bin/jsencrypt.js",
+    "module": "lib/index.js",
+    "browser": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "dependencies": {},
+    "devDependencies": {
+        "@babel/core": "^7.20.12",
+        "@babel/preset-env": "^7.20.2",
+        "@babel/preset-typescript": "^7.18.6",
+        "@babel/register": "^7.18.9",
+        "@types/expect": "^24.3.0",
+        "@types/mocha": "^10.0.0",
+        "@types/node": "^18.11.4",
+        "chai": "^4.3.6",
+        "dirty-chai": "^2.0.1",
+        "fs-jetpack": "^5.1.0",
+        "mocha": "^10.0.0",
+        "process": "^0.11.10",
+        "ts-mocha": "^10.0.0",
+        "ts-node": "^10.9.1",
+        "typescript": "^4.2.4",
+        "url": "^0.11.0",
+        "webpack": "^5.35.1",
+        "webpack-cli": "^4.6.0"
+    },
+    "files": [
+        "bin",
+        "lib"
+    ],
+    "scripts": {
+        "build:dev": "tsc && tsc --project tsconfig-def.json && webpack",
+        "build:test": "tsc && tsc --project tsconfig-def.json && webpack --config webpack.test.js",
+        "build:prod": "tsc && tsc --project tsconfig-def.json && webpack --config webpack.prod.js",
+        "build": "npm run build:dev && npm run build:test && npm run build:prod",
+        "serve": "bundle exec jekyll server --config _config.build.yml",
+        "test": "ts-mocha test/test.rsa.js"
+    },
+    "author": "Travis Tidwell <travis@form.io>",
+    "contributors": [
+        {
+            "name": "Travis Tidwell",
+            "email": "travis@form.io",
+            "url": "http://github.com/travist"
+        },
+        {
+            "name": "Antonio",
+            "url": "https://github.com/zoloft"
+        },
+        {
+            "name": "Julio",
+            "url": "https://github.com/jmgaya"
+        },
+        {
+            "name": "Taehyun Hwang",
+            "url": "https://github.com/HwangTaehyun"
+        }
+    ],
+    "homepage": "http://www.travistidwell.com/jsencrypt",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/travist/jsencrypt.git"
+    },
+    "bugs": {
+        "url": "http://github.com/travist/jsencrypt/issues"
+    },
+    "license": "MIT"
+}
--- a/package-lock.json
+++ b/package-lock.json
@ -5,6 +5,7 @@
  "packages": {
    "": {
      "dependencies": {
+        "jsencrypt": "^3.3.2",
        "uview-ui": "^2.0.38"
      },
      "devDependencies": {
@ -1102,6 +1103,12 @@
        "node": ">= 10.13.0"
      }
    },
+    "node_modules/jsencrypt": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmmirror.com/jsencrypt/-/jsencrypt-3.3.2.tgz",
+      "integrity": "sha512-arQR1R1ESGdAxY7ZheWr12wCaF2yF47v5qpB76TtV64H1pyGudk9Hvw8Y9tb/FiTIaaTRUyaSnm5T/Y53Ghm/A==",
+      "license": "MIT"
+    },
    "node_modules/json-parse-even-better-errors": {
      "version": "2.3.1",
      "resolved": "https://registry.npmmirror.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
--- a/package.json
+++ b/package.json
@ -1,5 +1,6 @@
 {
  "dependencies": {
+    "jsencrypt": "^3.3.2",
    "uview-ui": "^2.0.38"
  },
  "devDependencies": {
--- a/pages/api.js
+++ b/pages/api.js
@ -1,8 +1,32 @@
 import request from "../utils/request.js";
-export function getList(params) {
+
+// 获取验证码
+export function getCodeImg() {
  return request({
-    url: "/api/v1/user/list",
-    method: "get",
-    params,
+    url: '/captchaImage',
+    header: {
+      isToken: false
+    },
+    method: 'get',
+    timeout: 20000
+  })
+}
+export function login({ username, password, code, uuid, client }) {
+  return request({
+    url: "/login",
+    method: "post",
+    data: { username, password, code, uuid, client },
+    header: {
+      isToken: false,
+      repeatSubmit: false,
+    },
  });
 }
+// 退房列表
+export function listCheckoutAlert(query) {
+  return request({
+    url: "/apartment/manager/listCheckoutAlert",
+    method: "get",
+    params: query,
+  });
+}
--- a/pages/login/login.vue
+++ b/pages/login/login.vue
@ -13,11 +13,11 @@
    </view>
    <view class="login-form-box">
      <view class="login-form-item">
-        <text class="login-label">手机号</text>
+        <text class="login-label">用户名</text>
        <u-input
-          v-model="form.phone"
-          placeholder="请输入手机号"
-          type="number"
+          v-model="form.username"
+          placeholder="请输入用户名"
+          type="text"
          border="none"
          shape="circle"
          custom-style="background:#f6f6f6;padding:16rpx 0;padding-left:16px;"
@ -34,10 +34,28 @@
          custom-style="background:#f6f6f6;padding:16rpx 0;padding-left:16px;"
        />
      </view>
+      <view class="login-form-item captcha-row">
+        <text class="login-label">验证码</text>
+        <view class="captcha-flex">
+          <u-input
+            v-model="form.code"
+            placeholder="验证码"
+            border="none"
+            shape="circle"
+            custom-style="background:#f6f6f6;padding:16rpx 0;padding-left:16px;"
+          />
+          <image
+            :src="codeUrl"
+            class="captcha-img"
+            mode="aspectFit"
+            @click="getCaptcha"
+          />
+        </view>
+      </view>
    </view>
    <view class="login-btn-box">
      <u-button
-        hairline="false"
+        :hairline="false"
        shape="circle"
        :custom-style="btnStyle"
        @click="handleLogin"
@ -49,29 +67,119 @@
 </template>

 <script>
+import { login, getCodeImg } from "../api";
+import { encrypt, decrypt } from "../../utils/jsencrypt";
 export default {
  data() {
    return {
      form: {
-        phone: "",
+        username: "",
        password: "",
+        code: "",
+        uuid: "",
+        rememberMe: false,
      },
+      loading: false,
+      loginFailCounts: {}, // 记录失败次数
+      accountLockTimes: {}, // 记录锁定时间
+      codeUrl: "", // 验证码图片base64或url
      btnStyle: {
        width: "60%",
        height: "44px",
        fontSize: "18px",
        margin: "50px",
        marginTop: "200rpx",
-				background: "linear-gradient(90deg, #0DC6C6 0%, #13C2C2 100%)",
+        background: "linear-gradient(90deg, #0DC6C6 0%, #13C2C2 100%)",
      },
    };
  },
  methods: {
-    handleLogin() {
-      uni.showToast({ title: "登录", icon: "none" });
-      uni.switchTab({ url: "/pages/tabBar/work/index" });
+    async getCaptcha() {
+      const res = await getCodeImg();
+      this.captchaEnabled =
+        res.captchaEnabled === undefined ? true : res.captchaEnabled;
+      if (this.captchaEnabled) {
+        this.codeUrl = "data:image/gif;base64," + res.img;
+        this.form.uuid = res.uuid;
+      }
+    },
+    async handleLogin() {
+      const username = String(this.form.username); // 强制转为字符串
+      // 1. 检查锁定
+      const lockInfo = JSON.parse(
+        uni.getStorageSync(`lock_${username}`) || "{}"
+      );
+      if (lockInfo.lockEndTime) {
+        const currentTime = new Date().getTime();
+        if (currentTime < lockInfo.lockEndTime) {
+          const remainingMinutes = Math.ceil(
+            (lockInfo.lockEndTime - currentTime) / (1000 * 60)
+          );
+          uni.showToast({
+            title: `账号被锁定，请${remainingMinutes}分钟后再试`,
+            icon: "none",
+          });
+          return;
+        } else {
+          uni.removeStorageSync(`lock_${username}`);
+        }
+      }
+      // 2. 校验表单
+      if (!this.form.username || !this.form.password || !this.form.code) {
+        uni.showToast({ title: "请填写完整信息", icon: "none" });
+        return;
+      }
+      this.loading = true;
+      // 3. 记住我
+      if (this.form.rememberMe) {
+        uni.setStorageSync("username", this.form.username);
+        uni.setStorageSync("password", encrypt(this.form.password)); // 如需加密可加密
+        uni.setStorageSync("rememberMe", true);
+      } else {
+        uni.removeStorageSync("username");
+        uni.removeStorageSync("password");
+        uni.removeStorageSync("rememberMe");
+      }
+      const res = await login({
+        username: String(this.form.username),
+        password: encrypt(this.form.password), // 如需加密可加密
+        code: this.form.code,
+        uuid: this.form.uuid,
+        client: "gypc",
+      });
+      this.loading = false;
+      console.log(res);
+      
+      if (res.code === 200) {
+        this.loginFailCounts[username] = 0;
+        uni.setStorageSync("token", res.token);
+        // uni.showToast({ title: "登录成功", icon: "success" });
+        uni.switchTab({ url: "/pages/tabBar/work/index" });
+      } else {
+        // 失败计数
+        this.loginFailCounts[username] =
+          (this.loginFailCounts[username] || 0) + 1;
+        if (this.loginFailCounts[username] >= 5) {
+          const lockEndTime = new Date().getTime() + 10 * 60 * 1000;
+          this.accountLockTimes[username] = lockEndTime;
+          uni.setStorageSync(
+            `lock_${username}`,
+            JSON.stringify({ lockEndTime, username })
+          );
+          uni.showToast({
+            title: "账号登录失败次数过多，已锁定10分钟",
+            icon: "none",
+          });
+        } else {
+          uni.showToast({ title: res[1].data.msg || "登录失败", icon: "none" });
+        }
+        this.getCaptcha();
+      }
    },
  },
+  mounted() {
+    this.getCaptcha();
+  },
 };
 </script>

@ -81,7 +189,7 @@ export default {
  flex-direction: column;
  align-items: center;
  background: #f7fafd;
-	height: 100vh;
+  height: 100vh;
 }
 .login-welcome {
  position: relative;
@ -121,7 +229,7 @@ export default {
  border-radius: 24rpx;
  box-shadow: 0 4rpx 24rpx rgba(0, 0, 0, 0.06);
  padding: 40rpx 30rpx 30rpx 30rpx;
-  margin-bottom: 60rpx;
+  margin-bottom: -46rpx;
 }
 .login-form-item {
  margin-bottom: 36rpx;
@ -138,4 +246,21 @@ export default {
  display: flex;
  justify-content: center;
 }
+.captcha-row {
+  display: flex;
+  flex-direction: column;
+}
+.captcha-flex {
+  display: flex;
+  align-items: center;
+}
+.captcha-img {
+  width: 160rpx;
+  height: 60rpx;
+  margin-left: 16rpx;
+  border: 1rpx solid #e0e0e0;
+  border-radius: 8rpx;
+  background: #fff;
+  box-sizing: border-box;
+}
 </style>
--- a/pagesA/checkout/list/list.vue
+++ b/pagesA/checkout/list/list.vue
@ -28,6 +28,7 @@
 </template>

 <script>
+import { listCheckoutAlert } from "../../../pages/api";
 export default {
  data() {
    return {
@ -63,6 +64,20 @@ export default {
    this.getList();
  },
  methods: {
+    async getList() {
+      const res = await listCheckoutAlert({
+        pageNum: 1,
+        pageSize: 10,
+      });
+      console.log(res, "res");
+
+      // if (res.code === 200) {
+      //   this.list = this.page === 1 ? res.data : [...this.list, ...res.data];
+      //   this.finished = res.data.length < this.pageSize;
+      //   this.refreshing = false;
+      // }
+    },
+
    // 下拉刷新
    onRefresh() {
      this.page = 1;
@ -75,12 +90,15 @@ export default {
      this.page++;
      this.getList();
    },
-		getList() { },
-		goDetail(item) {
-			 uni.navigateTo({
-        url: `/pagesA/checkout/detail/detail?id=${item.id}`
-      })
-		}
+    getList() {},
+    goDetail(item) {
+      uni.navigateTo({
+        url: `/pagesA/checkout/detail/detail?id=${item.id}`,
+      });
+    },
+  },
+  mounted() {
+    this.getList();
  },
 };
 </script>
--- a/utils/config.js
+++ b/utils/config.js
@ -1 +1 @@
-export const baseUrl = "";
+export const baseUrl = "http://219.146.91.110:30801/mz-api";
--- a/utils/jsencrypt.js
+++ b/utils/jsencrypt.js
@ -0,0 +1,20 @@
+import JSEncrypt from "jsencrypt/bin/jsencrypt.min";
+
+// 密钥对生成 http://web.chacuo.net/netrsakeypair
+
+const publicKey = `MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAgsm5VpzdRlmrK3RJJ5NRaL5Sn8cD4HoGSiVkkOqODEBKQG9nQdJQO446LMxB3Qmoit2Wo4DCtA3KEVSACEQtMAZDqqRx/rmFRi/sAUDLIzBQYcbHLR7fqC89rgY+E3szoP9yaM26HbX8LkSSCqxBlAeGz0yHH4+Y4xXNlt/g0kwbJ7lhzliE9QntvkQmobAT3BOQ3xdCOgyOBGhXXRUsPYLyeooY58jVMg9GcRFkLUoLOjUgRK4daijRJLs5Y32mLoOnyyei0xXNyY5tvn6FbXLnN2W5VbLeD2f6hsZcoRjIRA+I0bkbe2GL0gOllCAFob5wxNP62QbpCHluHKMk0QIDAQAB`;
+const privateKey = `MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCCyblWnN1GWasrdEknk1FovlKfxwPgegZKJWSQ6o4MQEpAb2dB0lA7jjoszEHdCaiK3ZajgMK0DcoRVIAIRC0wBkOqpHH+uYVGL+wBQMsjMFBhxsctHt+oLz2uBj4TezOg/3JozbodtfwuRJIKrEGUB4bPTIcfj5jjFc2W3+DSTBsnuWHOWIT1Ce2+RCahsBPcE5DfF0I6DI4EaFddFSw9gvJ6ihjnyNUyD0ZxEWQtSgs6NSBErh1qKNEkuzljfaYug6fLJ6LTFc3Jjm2+foVtcuc3ZblVst4PZ/qGxlyhGMhED4jRuRt7YYvSA6WUIAWhvnDE0/rZBukIeW4coyTRAgMBAAECggEAKVsGCvgxE9S4xlXP5/6ySE+eKr2wYSPUp09pnFU+s2sEz5kqamrJSfuwM4gm73DlZXup7WuCpZKSqaYxkeuU6lGgxe2Xyjb5iHcQxlipoyfc0v4a7w6LJFBDzapVqK1VZvw/PhqHVmu8IRk3oL5VQiybGSOWuokai/vR9Xo3Seenk0P/DQMRYFiTxXl4enbM6pIyvBKHiKPfFRoNdSSK37pb3KY12hG9JpKlap95rhIhihGiCuQTKGkNIKVHhuvIgbAEXFwiNCaEOeV8stMre+/DMjRwQc9IU7g3cloCr3sTe4jgi0aSPS/VPcK726P4LAttJwohaSxXRhnQRtTH3QKBgQDXOci04H7WJKL16Zos5QeYRnScGmg0Txq1Ydgn6mm+G3kDxzhAQcPm1sVzvHMN35u1O+WBsix7nDELeqKACUtue/tQGmbCzlKusjQTtmegg652/xpGH6q99trWqDsvgBZ4QzD1N4aHrTWNc+gRwOnWo8cBNTnR2OxKRY9WUZGs8wKBgQCbkMz1NXlYmCuFn2fGLLAZoSuCdW7uv3r5AFYeCh9kPzPNoVg25tSTumAMCNIecmXQU67zDQaz2M/D3VVjunAXMJFvHsd9UtbbiaAqd5F/g9LnD2v4jQSUCGLm1hzr6L38dkWdkdU3V8zqmESYc/TfklxfiGWKlrUn7af8MA6IKwKBgDFuaBaC6R6t02+/c1WUVKY4qFeiCQTaljvKeSbRw++Rx72CZ/z6HdBKy5bFVXd+P/jkBNZA4c6SFQGZ7PCTMevyNco0Bh3/3SWacDOG1U4ccFmMRbCNXV278I8UnGNQe9irNfdcBV3r/jy6vjY1pH9TpkU0wE7eD4cPathca6TZAoGAUrWeAxE3Px9IpHaoGflQd4/1Lht5q34qx5CiOL5xCj+AL2gFGsuHYjPJNRzLelygPS8A6UCXu68eZ6iZ6bgKOIoeCNJ4he0xRu/ZNDr2JLHVw/uzECcJtBrxWoGkRtkribroMGqEzjPkQyZJ8jRUkTmj2zcNpa2TC3OTyMVUNJkCgYEAsngxy2X2+K2WZ0EncYnrYGOXN4klvQTZMn+6vkzwitdFtFuOB/VOLjNBgFE035y1rT1JQDjQfC1kU1WBcwMyJNk5cTLZBIk4JxQCyOY825vZMsVIj0Edf7VQtKRuzZecbBEBXnMwcbijpkfQWPj0tD+998/p2+oh/0IbFs2WfUY=`;
+
+// 加密
+export function encrypt(txt) {
+  const encryptor = new JSEncrypt();
+  encryptor.setPublicKey(publicKey); // 设置公钥
+  return encryptor.encrypt(txt); // 对数据进行加密
+}
+
+// 解密
+export function decrypt(txt) {
+  const encryptor = new JSEncrypt();
+  encryptor.setPrivateKey(privateKey); // 设置私钥
+  return encryptor.decrypt(txt); // 对数据进行解密
+}
--- a/utils/request.js
+++ b/utils/request.js
@ -1,5 +1,5 @@
 // utils/request.js
-const BASE_URL = 'https://your-api-url.com'; // 替换为你的后端地址
+import { baseUrl } from "./config";

 export default function request(options = {}) {
  // 获取token（假设存储在本地storage）
@ -7,12 +7,12 @@ export default function request(options = {}) {

  return new Promise((resolve, reject) => {
    uni.request({
-      url: BASE_URL + options.url,
+      url: baseUrl + options.url,
      method: options.method || "GET",
      data:
-        options.method === "GET" ? options.data : JSON.stringify(options.data),
+        options.method === "GET" ? options.data : options.data || {},
      header: {
-        "Content-Type": options.contentType || "application/json",
+        "Content-Type": options.contentType || "application/json;charset=UTF-8",
        Authorization: token ? `Bearer ${token}` : "",
        ...options.header,
      },
@ -21,7 +21,6 @@ export default function request(options = {}) {
        if (res.statusCode === 200) {
          resolve(res.data);
        } else if (res.statusCode === 401) {
-          uni.showToast({ title: "登录失效，请重新登录", icon: "none" });
          uni.redirectTo({
            url: "/pages/login/login",
          });