V1

node_modules/js-crypto-key-utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jun Kurihara
+
+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.

node_modules/js-crypto-key-utils/README.md

@@ -0,0 +1,158 @@
+Universal Module for Cryptographic Key Utilities in JavaScript
+--
+[![npm version](https://badge.fury.io/js/js-crypto-key-utils.svg)](https://badge.fury.io/js/js-crypto-key-utils)
+[![Dependencies](https://david-dm.org/junkurihara/jscu.svg?path=packages/js-crypto-key-utils)](https://david-dm.org/junkurihara/jscu?path=packages/js-crypto-key-utils)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+> **WARNING**: At this time this solution should be considered suitable for research and experimentation, further code and security review is needed before utilization in a production application.
+
+# Introduction and Overview
+This library is designed to 'universally' provide several functions for a cryptographic key handling, which means it works both on most browsers and on Node.js just by importing from npm/source code. This key utility library provides converters for EC/RSA keys in PEM/DER<->JWK, octet form of EC keys <-> JWK, and computation of JWK thumbprints. Especially for the conversion PEM/DER <->JWK, encryption and decryption of private key in DER/PEM are supported. 
+
+# Installation
+At your project directory, do either one of the following.
+
+- From npm/yarn:
+  ```shell
+  $ npm install --save js-crypto-key-utils // npm
+  $ yarn add js-crypto-key-utils // yarn
+  ```
+- From GitHub:
+  ```shell
+  $ git clone https://github.com/junkurihara/jscu.git
+  $ cd js-crypto-utils/packages/js-crypto-key-utils
+  & yarn build
+  ```
+
+Then you should import the package as follows.
+
+```shell
+import keyutil from 'js-crypto-key-utils'; // for npm
+import keyutil from 'path/to/js-crypto-key-utils/dist/index.js'; // for github
+```
+
+The bundled file is also given as `js-crypto-key-utils/dist/jsckey.bundle.js` for a use case where the module is imported as a `window.jsckey` object via `script` tags.
+
+  
+# Usage
+Supported key types are Json Web Key (JWK, [RFC7517](https://tools.ietf.org/html/rfc7517)), and PEM/DER. Octet-Formatted Key ([SECG SEC1](http://www.secg.org/sec1-v2.pdf) 2.3.3 and 2.3.4, link to PDF) is also available for elliptic curve cryptography keys. Note that for PEM/DER, public keys are encoded to the form of `SubjectPublicKeyInfo` (SPKI) defined as a part of X.509 public key certificate ([RFC5280](https://tools.ietf.org/html/rfc5280)). The detailed encoding rule for elliptic curve cryptographic keys is given in [RFC5480](https://tools.ietf.org/html/rfc5480). On the other hand, private keys are encoded to hte form of `PrivateKeyInfo` defined in PKCS#8 ([RFC5958](https://tools.ietf.org/html/rfc5958)). The detailed encoding rule for elliptic curve cryptographic keys is given in [RFC5915](https://tools.ietf.org/html/rfc5915) as well as SPKI. Please refer to [RFC3447](https://tools.ietf.org/html/rfc3447) for the detailed encoding rule of RSA public and private keys.
+
+## Instantiation
+At first, you need to instantiate `Key` object by importing various type of keys. 
+
+```javascript
+const yourStringPemKey = '------BEGIN PRIVATE...'; // SPKI (public key) or PKCS8 (either encrypted or plaintext private key)
+const yourBinaryDerKey = new Uint8Array([...]); // SPKI (public key) or PKCS8 (either encrypted or plaintext private key)
+const yourJasonWebKey = {kty: 'EC', ... };
+const yourOctetFormKey = new Uint8Array([0x04, ...]) // only for Elliptic Curve Crypto Key.
+
+const keyObjFromPem = new keyutil.Key('pem', yourStringPemKey);
+const keyObjFromDer = new keyutil.Key('der', yourBinaryDerKey);
+const keyObjFromJwk = new keyutil.Key('jwk', yourJasonWebKey); 
+const keyObjFromOct = new keyutil.Key('oct', yourOctetFormKey, {namedCurve: '...'}); //namedCurve like 'P-256K' is required.
+```
+
+## Handling key objects
+In a case where the imported key is encrypted (pem/der), it needs to be decrypted before getting exported.
+```javascript
+const keyObj = new keyutil.Key('pem', encryptedPemKey);
+const yourPassphrase = '...';
+
+// first now you can check the status
+const isEncrypted = keyObj.isEncrypted;
+
+// before using the key object, decrypt the key object with the passphrase.
+if(isEncrypted) await keyObj.decrypt(yourPassphrase);
+
+const thisMustBeFalse = keyObj.isEncrypted; // false
+
+// you can lock the key object by encrypting it as well.
+if(!thisMustBeFalse) await keyObj.encrypt(yourPassphrase);
+
+const thisMustBeTrue = keyObj.isEncrypted; // true;
+```
+
+## Exporting keys in desired format
+From instantiated key objects, various types of keys can be exported.
+```javascript
+const keyObj = new keyutil.Key('pem', pemKey);
+
+// jwk
+let jwk;
+if(!keyObj.isEncrypted) jwk = await keyObj.export('jwk');
+if(keyObj.isPrivate) jwk = await keyObj.export('jwk', {outputPublic: true}); // export public key from private key.
+
+// pem
+let pem;
+if(!keyObj.isEncrypted) pem = await keyObj.export('pem');
+if(keyObj.isPrivate) pem = await keyObj.export('pem', {outputPublic: true}); // export public key from private key.
+// Only ECC Key: export compressed form of public key from private/public key.
+pem = await keyObj.export('pem', {outputPublic: true, compact: true});
+
+// der
+let der;
+if(!keyObj.isEncrypted) der = await keyObj.export('der');
+if(keyObj.isPrivate) der = await keyObj.export('der', {outputPublic: true}); // export public key from private key.
+// Only ECC Keys: export compressed form of public key from private/public key.
+der = await keyObj.export('der', {outputPublic: true, compact: true});
+
+// Only ECC Keys
+// octet from
+let oct;
+if(!keyObj.isEncrypted) oct = await keyObj.export('oct');
+if(keyObj.isPrivate) oct = await keyObj.export('oct', {outputPublic: true}); // export public key from private key.
+// export compressed form of public key from private/public key.
+oct = await keyObj.export('oct', {outputPublic: true, compact: true});
+```
+
+
+## Exporting encrypted keys with arbitrary specified passphrase.
+All you need to export encrypted private keys in PEM/DER is just putting passphrase in the API. The default encryption algorithm follows PKCS#5 v2.1 ([RFC8018](https://tools.ietf.org/html/rfc8018)) and uses AES256-CBC and HMAC-with-SHA-256 to encrypt your private key.
+```javascript
+const keyObj = new keyutil.Key('pem', pemKey);
+
+// encrypt with default params
+let encryptedPem;
+if(!keyObj.isEncrypted && keyObj.isPrivate)
+  encryptedPem = await keyObj.export('pem', {encryptParams: {passphrase: 'top secret'}});
+
+// encrypt with intended params
+if(!keyObj.isEncrypted && keyObj.isPrivate)
+  encryptedPem = await keyObj.export('pem', {
+    encryptParams: {
+      passphrase: 'top secret',
+      algorithm: 'pbes2', // default. 'pbeWith...' is also available, i.e., pbes1.
+      cipher: 'aes256-cbc', // default. for encryption. 'aes128-cbc', 'aes192-cbc'(only node), 'des-ede3-cbc' are available as well.
+      prf: 'hmacWithSHA256' // default. for key derivation
+    }
+  });
+```
+
+## Getting JWK Thumbprint
+You can obtain the JWK Thumbprint defined in [RFC7638](https://tools.ietf.org/html/rfc7638) from instantiated key object. The API can be invoked as follows.
+```javascript
+const keyObj = new keyutil.Key('pem', pemKey);
+
+let thumbprint;
+
+// with default params (hash is SHA-256, output is in Uint8Array)
+if(!keyObj.isEncrypted) thumbprint = await keyObj.getJwkThumbprint();
+
+// with intented params
+if(!keyObj.isEncrypted) thumbprint = await keyObj.getJwkThumbprint(
+  'SHA-512',
+  'hex' // output is hex string
+); 
+```
+Note that the thumbprint generated from a public key is exactly same as that from its paired private key.
+
+# Note
+Now this library supports the following curve for elliptic curve cryptography.
+- P-256 (secp256r1)
+- P-384 (secp384r1)
+- P-521 (secp521r1)
+- P-256K (secp256k1)
+
+# License
+Licensed under the MIT license, see `LICENSE` file.

node_modules/js-crypto-key-utils/dist/asn1def.js

@@ -0,0 +1,156 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PBES2ESParams = exports.PBKDF2Params = exports.PBES2Params = exports.PBEParameter = exports.EncryptedPrivateKeyInfo = exports.OneAsymmetricKey = exports.SubjectPublicKeyInfo = exports.KeyStructure = void 0;
+
+var _asn = _interopRequireDefault(require("asn1.js"));
+
+/**
+ * asn1def.js
+ */
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * This is either one of subjectPublicKeyInfo, oneAsymmetricKey or encryptedPrivateKeyInfo in ASN.1 format.
+ * @type {AsnObject}
+ */
+var KeyStructure = _asn.default.define('KeyStructure', function () {
+  this.choice({
+    subjectPublicKeyInfo: this.use(SubjectPublicKeyInfo),
+    oneAsymmetricKey: this.use(OneAsymmetricKey),
+    encryptedPrivateKeyInfo: this.use(EncryptedPrivateKeyInfo)
+  });
+});
+/**
+ * SubjectPublicKeyInfo specified in RFC 5280 {@link https://tools.ietf.org/html/rfc5280}.
+ * @type {AsnObject}
+ */
+
+
+exports.KeyStructure = KeyStructure;
+
+var SubjectPublicKeyInfo = _asn.default.define('SubjectPublicKeyInfo', function () {
+  this.seq().obj(this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPublicKey').bitstr());
+}); ///////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * OneAsymmetricKey specified in RFC5958 {@link https://tools.ietf.org/html/rfc5958}.
+ * (old version PrivateKeyInfo {@link https://tools.ietf.org/html/rfc5208}.)
+ * @type {AsnObject}
+ */
+
+
+exports.SubjectPublicKeyInfo = SubjectPublicKeyInfo;
+
+var OneAsymmetricKey = _asn.default.define('OneAsymmetricKey', function () {
+  this.seq().obj(this.key('version').use(Version), this.key('privateKeyAlgorithm').use(AlgorithmIdentifier), this.key('privateKey').octstr(), this.key('attributes').implicit(0).optional().any(), this.key('publicKey').implicit(1).optional().bitstr());
+});
+/**
+ * EncryptedPrivateKeyInfo specified in RFC5958 {@link https://tools.ietf.org/html/rfc5958}.
+ * @type {AsnObject}
+ */
+
+
+exports.OneAsymmetricKey = OneAsymmetricKey;
+
+var EncryptedPrivateKeyInfo = _asn.default.define('EncryptedPrivateKeyInfo', function () {
+  this.seq().obj(this.key('encryptionAlgorithm').use(AlgorithmIdentifier), this.key('encryptedData').octstr());
+}); ///////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * PBEParameter, parameter for password-based encryption, specified in RFC 8018 {@link https://tools.ietf.org/html/rfc8018}.
+ * @type {AsnObject}
+ */
+
+
+exports.EncryptedPrivateKeyInfo = EncryptedPrivateKeyInfo;
+
+var PBEParameter = _asn.default.define('PBEParameter', function () {
+  this.seq().obj(this.key('salt').octstr(8), this.key('iterationCount').int());
+});
+/**
+ * PBES2Params, parameter for password-based encryption scheme 2, specified in RFC 8018 {@link https://tools.ietf.org/html/rfc8018}.
+ * @type {AsnObject}
+ */
+
+
+exports.PBEParameter = PBEParameter;
+
+var PBES2Params = _asn.default.define('PBES2Params', function () {
+  this.seq().obj(this.key('keyDerivationFunc').use(AlgorithmIdentifier), this.key('encryptionScheme').use(AlgorithmIdentifier));
+}); ///////////////////////////////////////////////////////////////////////////////////////////
+// PBKDF2-params ::= SEQUENCE {
+//        salt CHOICE {
+//          specified OCTET STRING,
+//          otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}}
+//        },
+//        iterationCount INTEGER (1..MAX),
+//        keyLength INTEGER (1..MAX) OPTIONAL,
+//        prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT
+//        algid-hmacWithSHA1
+//    }
+
+/**
+ * PBKDF2Params, parameter for PBKDF2, specified in RFC 8018 {@link https://tools.ietf.org/html/rfc8018}.
+ * @type {AsnObject}
+ */
+
+
+exports.PBES2Params = PBES2Params;
+
+var PBKDF2Params = _asn.default.define('PBKDF2Params', function () {
+  this.seq().obj(this.key('salt').choice({
+    'specified': this.octstr(),
+    'otherSource': this.use(AlgorithmIdentifier)
+  }), this.key('iterationCount').int(), this.key('keyLength').int().optional(), this.key('prf').use(AlgorithmIdentifier).def({
+    algorithm: [1, 2, 840, 113549, 2, 7],
+    // hmacWithSHA1
+    parameters: Buffer.from([0x05, 0x00])
+  }));
+}); ///////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * PBES2ESParams specified in RFC 8018 {@link https://tools.ietf.org/html/rfc8018}.
+ * @type {{'aes192-cbc': AsnObject, 'aes128-cbc': AsnObject, 'des-ede3-cbc': Object, 'aes256-cbc': AsnObject}}
+ */
+
+
+exports.PBKDF2Params = PBKDF2Params;
+var PBES2ESParams = {
+  'des-ede3-cbc': _asn.default.define('DesEde3CbcParams', function () {
+    this.octstr();
+  }),
+  'aes128-cbc': _asn.default.define('Aes128CbcParams', function () {
+    this.octstr();
+  }),
+  'aes192-cbc': _asn.default.define('Aes192CbcParams', function () {
+    this.octstr();
+  }),
+  'aes256-cbc': _asn.default.define('Aes256CbcParams', function () {
+    this.octstr();
+  })
+}; ////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * AlgorithmIdentifier given in RFC 5280 {@link https://tools.ietf.org/html/rfc5280}
+ * @type AsnObject
+ */
+
+exports.PBES2ESParams = PBES2ESParams;
+
+var AlgorithmIdentifier = _asn.default.define('AlgorithmIdentifier', function () {
+  this.seq().obj(this.key('algorithm').objid(), this.key('parameters').optional().any());
+});
+/**
+ * Version
+ * @type {AsnObject}
+ */
+
+
+var Version = _asn.default.define('Version', function () {
+  this.int();
+});

node_modules/js-crypto-key-utils/dist/asn1ec.js

@@ -0,0 +1,156 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJWK = exports.fromJWK = void 0;
+
+var _asn = _interopRequireDefault(require("asn1.js"));
+
+var _params = _interopRequireWildcard(require("./params.js"));
+
+var _octenc = require("./octenc.js");
+
+/**
+ * asn1ec.js
+ */
+
+/**
+ * Convert JWK to parsed ASN.1 EC key object
+ * @param {JsonWebKey} jwk - A key object in JWK format.
+ * @param {PublicOrPrivate} type - 'public' or 'private'
+ * @param {boolean} [compact=false] - *Only for EC public keys*, the compact form of public key is given as ASN.1 object if true.
+ * @return {Object} - Parsed ASN.1 object.
+ */
+var fromJWK = function fromJWK(jwk, type) {
+  var compact = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (Object.keys(_params.default.namedCurves).indexOf(jwk.crv) < 0) throw new Error('UnsupportedCurve');
+  var octetPublicKey = (0, _octenc.fromJwk)(jwk, {
+    outputFormat: 'binary',
+    outputPublic: true,
+    compact: compact
+  });
+  var publicKeyAlgorithmOid = _params.default.publicKeyAlgorithms['EC'].oid;
+  var publicKey = {
+    unused: 0,
+    data: Array.from(octetPublicKey)
+  }; //Buffer.from(octkeyObj.publicKey)};
+
+  var parameters = ECParameters.encode({
+    type: 'namedCurve',
+    value: _params.default.namedCurves[jwk.crv].oid
+  }, 'der');
+  var algorithm = {
+    algorithm: publicKeyAlgorithmOid,
+    parameters: parameters
+  };
+  var decoded = {};
+
+  if (type === 'public') {
+    // SPKI
+    decoded.subjectPublicKey = publicKey;
+    decoded.algorithm = algorithm;
+  } else if (type === 'private') {
+    // PKCS8
+    var octetPrivateKey = (0, _octenc.fromJwk)(jwk, {
+      outputFormat: 'binary',
+      outputPublic: false,
+      compact: compact
+    });
+    decoded.version = 0; // no public key presents for v2 (0)
+
+    decoded.privateKeyAlgorithm = algorithm;
+    decoded.privateKey = ECPrivateKey.encode({
+      version: 1,
+      privateKey: Array.from(octetPrivateKey),
+      //Buffer.from(octkeyObj.privateKey),
+      parameters: parameters,
+      publicKey: publicKey
+    }, 'der');
+  }
+
+  return decoded;
+};
+/**
+ * Convert parsed ASN.1 EC key object to JWK.
+ * @param {Object} decoded - Parsed ASN.1 EC key object.
+ * @param {PublicOrPrivate} type - 'public' or 'private'
+ * @return {JsonWebKey} - Converted key objects in JWK format.
+ * @throws {Error} - Throws if UnsupportedCurve.
+ */
+
+
+exports.fromJWK = fromJWK;
+
+var toJWK = function toJWK(decoded, type) {
+  if (type === 'public') {
+    // SPKI
+    decoded.algorithm.parameters = ECParameters.decode(decoded.algorithm.parameters, 'der'); // overwrite nested binary object as parsed object
+
+    var octPubKey = new Uint8Array(decoded.subjectPublicKey.data); // convert oct key to jwk
+
+    var namedCurves = (0, _params.getAlgorithmFromOid)(decoded.algorithm.parameters.value, _params.default.namedCurves);
+    if (namedCurves.length < 1) throw new Error('UnsupportedCurve');
+    return (0, _octenc.toJwk)(octPubKey, namedCurves[0], {
+      outputPublic: true
+    });
+  } else if (type === 'private') {
+    // PKCS8
+    decoded.privateKeyAlgorithm.parameters = ECParameters.decode(decoded.privateKeyAlgorithm.parameters, 'der'); // Work around for optional private key parameter field.
+
+    try {
+      decoded.privateKey = ECPrivateKey.decode(decoded.privateKey, 'der');
+    } catch (e) {
+      decoded.privateKey = ECPrivateKeyAlt.decode(decoded.privateKey, 'der');
+    }
+
+    var octPrivKey = new Uint8Array(decoded.privateKey.privateKey);
+
+    var _namedCurves = (0, _params.getAlgorithmFromOid)(decoded.privateKeyAlgorithm.parameters.value, _params.default.namedCurves);
+
+    if (_namedCurves.length < 1) throw new Error('UnsupportedCurve');
+    return (0, _octenc.toJwk)(octPrivKey, _namedCurves[0], {
+      outputPublic: false
+    });
+  }
+}; /////////////////////////
+
+/**
+ * ECParameters specified in RFC 5480 {@link https://tools.ietf.org/html/rfc5480}.
+ * @type {AsnObject}
+ */
+
+
+exports.toJWK = toJWK;
+
+var ECParameters = _asn.default.define('ECParameters', function () {
+  this.choice({
+    namedCurve: this.objid()
+  });
+});
+/**
+ * ECPrivateKey specified in RFC 5915 {@link https://tools.ietf.org/html/rfc5915}.
+ * @type {AsnObject}
+ */
+
+
+var ECPrivateKey = _asn.default.define('ECPrivateKey', function () {
+  this.seq().obj(this.key('version').int(), this.key('privateKey').octstr(), this.key('parameters').explicit(0).optional().any(), // rfc suggested that this must be implemented
+  this.key('publicKey').explicit(1).optional().bitstr() // rfc suggested that this must be implemented
+  );
+});
+/**
+ * ECPrivateKey Alternative for an work around...
+ * @type {AsnObject}
+ */
+
+
+var ECPrivateKeyAlt = _asn.default.define('ECPrivateKey', function () {
+  this.seq().obj(this.key('version').int(), this.key('privateKey').octstr(), // this.key('parameters').explicit(0).optional().any(), // rfc suggested that this must be implemented
+  this.key('publicKey').explicit(1).optional().bitstr() // rfc suggested that this must be implemented
+  );
+});

node_modules/js-crypto-key-utils/dist/asn1enc.js

@@ -0,0 +1,229 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJwk = exports.fromJwk = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var asn1ec = _interopRequireWildcard(require("./asn1ec.js"));
+
+var asn1rsa = _interopRequireWildcard(require("./asn1rsa.js"));
+
+var _params = _interopRequireWildcard(require("./params.js"));
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _buffer = _interopRequireDefault(require("buffer"));
+
+var _asn1def = require("./asn1def.js");
+
+var _rfc = require("./rfc8018.js");
+
+var _util = require("./util.js");
+
+/**
+ * asn1enc.js
+ */
+var Buffer = _buffer.default.Buffer;
+/**
+ * Convert jwk to spki/pkcs8 in string or binary format.
+ * @param {JsonWebKey} jwkey - A key object in JWK format to be encoded.
+ * @param {boolean} outputPublic - Derive public key from private key when true
+ * @param {AsnFormat} format - 'pem' or 'der'
+ * @param {boolean} compact - 'true' or 'false' for EC public key compressed representation in der/pem
+ * @param {String} passphrase - if passphrase is given and the given key is private key, it will be encoded with the passphrase.
+ * @param {AsnEncryptOptionsWithPassphrase} encOptions - ASN.1 encryption options
+ * @return {Uint8Array|String} - Encoded private key in DER or PEM
+ */
+
+var fromJwk =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee(jwkey, format, _ref) {
+    var outputPublic, _ref$compact, compact, encOptions, orgType, type, decoded, binKey;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            outputPublic = _ref.outputPublic, _ref$compact = _ref.compact, compact = _ref$compact === void 0 ? false : _ref$compact, encOptions = _ref.encOptions;
+            orgType = (0, _util.getJwkType)(jwkey);
+            type = typeof outputPublic === 'boolean' && outputPublic ? 'public' : orgType;
+
+            if (jwkey.kty === 'EC') {
+              decoded = asn1ec.fromJWK(jwkey, type, compact);
+            } else if (jwkey.kty === 'RSA') {
+              decoded = asn1rsa.fromJwk(jwkey, type);
+            }
+
+            if (!(type === 'public')) {
+              _context.next = 8;
+              break;
+            }
+
+            binKey = _asn1def.SubjectPublicKeyInfo.encode(decoded, 'der');
+            _context.next = 14;
+            break;
+
+          case 8:
+            binKey = _asn1def.OneAsymmetricKey.encode(decoded, 'der');
+
+            if (!(typeof encOptions.passphrase !== 'undefined' && encOptions.passphrase.length > 0)) {
+              _context.next = 14;
+              break;
+            }
+
+            _context.next = 12;
+            return (0, _rfc.encryptEncryptedPrivateKeyInfo)(binKey, encOptions);
+
+          case 12:
+            binKey = _context.sent;
+            type = 'encryptedPrivate';
+
+          case 14:
+            binKey = new Uint8Array(binKey);
+            return _context.abrupt("return", format === 'pem' ? _jsEncodingUtils.default.formatter.binToPem(binKey, type) : binKey);
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function fromJwk(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Convert SPKI/PKCS8 key in string or binary format to JWK.
+ * @param {PEM|DER} key - Key object.
+ * @param {AsnFormat} format - 'pem' or 'der'
+ * @param {boolean} [outputPublic] - Export public key even from private key if true.
+ * @param {String} [passphrase] - Encrypt private key if passphrase is given.
+ * @return {JsonWebKey} - Obtained key object in JWK format.
+ * @throws {Error} Throws if UnsupportedKeyStructure, UnsupportedKey or InvalidKeyType.
+ */
+
+
+exports.fromJwk = fromJwk;
+
+var toJwk =
+/*#__PURE__*/
+function () {
+  var _ref4 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(key, format, _ref3) {
+    var outputPublic, passphrase, binKey, decoded, type, keyTypes;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            outputPublic = _ref3.outputPublic, passphrase = _ref3.passphrase;
+            // Peel the pem strings
+            binKey = format === 'pem' ? _jsEncodingUtils.default.formatter.pemToBin(key) : key; // decode binary spki/pkcs8-formatted key to parsed object
+
+            _context2.prev = 2;
+            decoded = _asn1def.KeyStructure.decode(Buffer.from(binKey), 'der');
+            _context2.next = 9;
+            break;
+
+          case 6:
+            _context2.prev = 6;
+            _context2.t0 = _context2["catch"](2);
+            throw new Error('FailedToDecodeKey');
+
+          case 9:
+            if (!(decoded.type === 'subjectPublicKeyInfo')) {
+              _context2.next = 14;
+              break;
+            }
+
+            type = 'public';
+            decoded = decoded.value;
+            _context2.next = 26;
+            break;
+
+          case 14:
+            type = typeof outputPublic === 'boolean' && outputPublic ? 'public' : 'private';
+
+            if (!(decoded.type === 'encryptedPrivateKeyInfo')) {
+              _context2.next = 21;
+              break;
+            }
+
+            _context2.next = 18;
+            return (0, _rfc.decryptEncryptedPrivateKeyInfo)(decoded.value, passphrase);
+
+          case 18:
+            decoded = _context2.sent;
+            _context2.next = 26;
+            break;
+
+          case 21:
+            if (!(decoded.type === 'oneAsymmetricKey')) {
+              _context2.next = 25;
+              break;
+            }
+
+            decoded = decoded.value;
+            _context2.next = 26;
+            break;
+
+          case 25:
+            throw new Error('UnsupportedKeyStructure');
+
+          case 26:
+            keyTypes = (0, _params.getAlgorithmFromOid)(type === 'public' ? decoded.algorithm.algorithm : decoded.privateKeyAlgorithm.algorithm, _params.default.publicKeyAlgorithms);
+
+            if (!(keyTypes.length < 1)) {
+              _context2.next = 29;
+              break;
+            }
+
+            throw new Error('UnsupportedKey');
+
+          case 29:
+            if (!(keyTypes[0] === 'EC')) {
+              _context2.next = 33;
+              break;
+            }
+
+            return _context2.abrupt("return", asn1ec.toJWK(decoded, type));
+
+          case 33:
+            if (!(keyTypes[0] === 'RSA')) {
+              _context2.next = 37;
+              break;
+            }
+
+            return _context2.abrupt("return", asn1rsa.toJwk(decoded, type));
+
+          case 37:
+            throw new Error('InvalidKeyType');
+
+          case 38:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[2, 6]]);
+  }));
+
+  return function toJwk(_x4, _x5, _x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+exports.toJwk = toJwk;

node_modules/js-crypto-key-utils/dist/asn1rsa.js

@@ -0,0 +1,182 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJwk = exports.fromJwk = void 0;
+
+var _asn = _interopRequireDefault(require("asn1.js"));
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _buffer = _interopRequireDefault(require("buffer"));
+
+var _params = _interopRequireDefault(require("./params.js"));
+
+var _util = require("./util");
+
+/**
+ * asn1rsa.js
+ */
+var Buffer = _buffer.default.Buffer;
+
+/**
+ * Encode RSA JWK key to ASN.1 DER or PEM of SPKI/OneAsymmetricKey.
+ * @param {JsonWebKey} jwk - A key object in JWK format to be encoded.
+ * @param {PublicOrPrivate} type - 'public' or 'private'.
+ * @returns {Object} - Parsed object of ASN.1 encoded key object.
+ */
+var fromJwk = function fromJwk(jwk, type) {
+  var publicKeyAlgorithmOid = _params.default.publicKeyAlgorithms['RSA'].oid; // Parameters is always null Ox0500 in ASN.1 as shown in the Section 2.3.1 https://tools.ietf.org/html/rfc3279
+
+  var parameters = Buffer.from([0x05, 0x00]);
+  var algorithm = {
+    algorithm: publicKeyAlgorithmOid,
+    parameters: parameters
+  }; // to append leading zeros (pruned when making JWK) in order to make binary of intended bit length
+  // https://tools.ietf.org/html/rfc7518#section-6.3
+
+  var modulusBytes = _jsEncodingUtils.default.encoder.decodeBase64Url(jwk.n);
+
+  var nLen = modulusBytes.length;
+  var modulusLength = nLen % 128 === 0 ? nLen : nLen + (128 - nLen % 128);
+  var modulus = new _asn.default.bignum((0, _util.appendLeadingZeros)(modulusBytes, modulusLength)); // JWA RFC
+
+  var publicExponent = new _asn.default.bignum(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.e));
+  var decoded = {};
+
+  if (type === 'public') {
+    // SPKI
+    decoded.subjectPublicKey = {
+      unused: 0,
+      data: RSAPublicKey.encode({
+        modulus: modulus,
+        publicExponent: publicExponent
+      }, 'der')
+    };
+    decoded.algorithm = algorithm;
+  } else if (type === 'private') {
+    // PKCS8
+    decoded.version = 0; // no public key presents for v2 (0)
+
+    decoded.privateKeyAlgorithm = algorithm;
+    decoded.privateKey = RSAPrivateKey.encode({
+      version: 0,
+      modulus: modulus,
+      publicExponent: publicExponent,
+      privateExponent: new _asn.default.bignum((0, _util.appendLeadingZeros)(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.d), modulusLength)),
+      prime1: new _asn.default.bignum((0, _util.appendLeadingZeros)(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.p), modulusLength)),
+      prime2: new _asn.default.bignum((0, _util.appendLeadingZeros)(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.q), modulusLength)),
+      exponent1: new _asn.default.bignum((0, _util.appendLeadingZeros)(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.dp), modulusLength)),
+      exponent2: new _asn.default.bignum((0, _util.appendLeadingZeros)(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.dq), modulusLength)),
+      coefficient: new _asn.default.bignum((0, _util.appendLeadingZeros)(_jsEncodingUtils.default.encoder.decodeBase64Url(jwk.qi), modulusLength))
+    }, 'der');
+  }
+
+  return decoded;
+};
+/**
+ * Convert RSA spki/pkcs8 public/private keys to JWK
+ * @param {Object} decoded - Parsed object of RSA key to be encoded.
+ * @param {PublicOrPrivate} type - 'public' or 'private'
+ * @return {JsonWebKey} - Encoded RSA key object in JWK format.
+ */
+
+
+exports.fromJwk = fromJwk;
+
+var toJwk = function toJwk(decoded, type) {
+  if (type === 'public') {
+    // SPKI
+    // algorithm.algorithm.parameters is always null Ox0500 in ASN.1
+    // as shown in the Section 2.3.1 https://tools.ietf.org/html/rfc3279
+    // overwrite nested binary object as parsed object
+    decoded.subjectPublicKey.data = RSAPublicKey.decode(decoded.subjectPublicKey.data, 'der');
+    var modulus = decoded.subjectPublicKey.data.modulus;
+    var publicExponent = decoded.subjectPublicKey.data.publicExponent; // convert n and e from BN
+    // modulus n
+
+    var nLen = modulus.byteLength();
+    var len = nLen % 128 === 0 ? nLen : nLen + (128 - nLen % 128);
+    modulus = new Uint8Array(modulus.toArray('be', len)); // // publicExponent e;
+
+    publicExponent = new Uint8Array(publicExponent.toArray('be', publicExponent.byteLength()));
+    return {
+      kty: 'RSA',
+      n: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(modulus)),
+      // prune leading zeros https://tools.ietf.org/html/rfc7518#section-6.3
+      e: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(publicExponent))
+    };
+  } else if (type === 'private') {
+    // PKCS8
+    // privateKeyAlgorithm.algorithm.parameters is always null Ox0500 in ASN.1
+    // as shown in the Section 2.3.1 https://tools.ietf.org/html/rfc3279
+    // overwrite nested binary object as parsed object
+    decoded.privateKey = RSAPrivateKey.decode(decoded.privateKey, 'der');
+    var privateKeyElems = {};
+    privateKeyElems.modulus = decoded.privateKey.modulus; // calculate key length from modulus n
+
+    var _nLen = privateKeyElems.modulus.byteLength();
+
+    var _len = _nLen % 128 === 0 ? _nLen : _nLen + (128 - _nLen % 128); // this is actual key length, e.g., 256 bytes
+    // convert BN to Uint8Array
+
+
+    privateKeyElems.modulus = new Uint8Array(privateKeyElems.modulus.toArray('be', _len)); // n of length len
+
+    privateKeyElems.publicExponent = new Uint8Array(decoded.privateKey.publicExponent.toArray('be', decoded.privateKey.publicExponent.byteLength())); // e of arbitrary small length
+
+    privateKeyElems.privateExponent = new Uint8Array(decoded.privateKey.privateExponent.toArray('be', _len)); // d of length len
+
+    var keys = ['prime1', 'prime2', 'exponent1', 'exponent2', 'coefficient']; // elements of length len/2
+
+    keys.forEach(function (key) {
+      privateKeyElems[key] = new Uint8Array(decoded.privateKey[key].toArray('be', _len >> 1));
+    }); // prune leading zeros JWW RSA private key: https://tools.ietf.org/html/rfc7517
+
+    return {
+      kty: 'RSA',
+      n: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.modulus)),
+      e: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.publicExponent)),
+      d: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.privateExponent)),
+      p: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.prime1)),
+      q: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.prime2)),
+      dp: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.exponent1)),
+      dq: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.exponent2)),
+      qi: _jsEncodingUtils.default.encoder.encodeBase64Url((0, _util.pruneLeadingZeros)(privateKeyElems.coefficient))
+    };
+  }
+}; ///////////
+// https://tools.ietf.org/html/rfc3447
+
+
+exports.toJwk = toJwk;
+
+var RSAPublicKey = _asn.default.define('RSAPublicKey', function () {
+  this.seq().obj(this.key('modulus').int(), // n
+  this.key('publicExponent').int() // e
+  );
+});
+
+var RSAPrivateKey = _asn.default.define('RSAPrivateKey', function () {
+  this.seq().obj(this.key('version').int(), // 0
+  this.key('modulus').int(), // n
+  this.key('publicExponent').int(), // e
+  this.key('privateExponent').int(), // d
+  this.key('prime1').int(), // p
+  this.key('prime2').int(), // q
+  this.key('exponent1').int(), // d mod (p-1)
+  this.key('exponent2').int(), // d mod (q-1)
+  this.key('coefficient').int(), // (inverse of q) mod p
+  this.key('otherPrimeInfos').optional().use(OtherPrimeInfos));
+});
+
+var OtherPrimeInfos = _asn.default.define('OtherPrimeInfos', function () {
+  this.seqof(OtherPrimeInfo);
+});
+
+var OtherPrimeInfo = _asn.default.define('OtherPrimeInfo', function () {
+  this.seq().obj(this.key('prime').int(), this.key('exponent').int(), this.key('coefficient').int());
+});

node_modules/js-crypto-key-utils/dist/converter.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJwkFrom = exports.fromJwkTo = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var asn1enc = _interopRequireWildcard(require("./asn1enc.js"));
+
+var octenc = _interopRequireWildcard(require("./octenc.js"));
+
+/**
+ * converter.js
+ */
+// ASN.1 in RFC5280 (SPKI) and RFC5208 (PKCS8) -> RSA and EC, encode='asn', format='pem' or 'der'
+// -> SPKI (in X.509): RFC5280 for public key, PKCS8: RFC5208 for private key
+// Octet Form in ANSI X9.63 -> EC, encode='oct', format='string' or 'binary', compact=true or false
+// -> Standards for Efficient Cryptography Group (SECG), "SEC1: Elliptic Curve Cryptography", Version 1.0, September 2000.
+
+/**
+ * Convert JWK to ASN.1 (for RSA and EC) and Octet (for EC) encoded keys.
+ * @param {String} output - 'pem', 'der', or 'oct' (only EC JWK), output format.
+ * @param {JsonWebKey} jwkey - A JWK to be encoded.
+ * @param {KeyExportOptions} options - Options to export key including encryption options.
+ *   For EC JWK : options.compact = true or false
+ *   For EC JWK with output = 'oct' : options.format = 'binary' or 'string'
+ *   For both: outputPublic (optional) : boolean. derived key type. from private key, public key can be derived when true.
+ * @return {PEM|DER|OctetEC} - Output key object.
+ */
+var fromJwkTo =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee() {
+    var output,
+        jwkey,
+        options,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            output = _args.length > 0 && _args[0] !== undefined ? _args[0] : 'pem';
+            jwkey = _args.length > 1 ? _args[1] : undefined;
+            options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+
+            if (!(['pem', 'der', 'oct'].indexOf(output) < 0)) {
+              _context.next = 5;
+              break;
+            }
+
+            throw new Error('InvalidOutputForm');
+
+          case 5:
+            if (!((0, _typeof2.default)(jwkey) !== 'object')) {
+              _context.next = 7;
+              break;
+            }
+
+            throw new Error('InvalidJWKAsObject');
+
+          case 7:
+            if (!(jwkey.kty !== 'EC' && jwkey.kty !== 'RSA')) {
+              _context.next = 9;
+              break;
+            }
+
+            throw new Error('UnsupportedKeyType');
+
+          case 9:
+            if (!(typeof options.outputPublic !== 'undefined' && typeof options.outputPublic !== 'boolean')) {
+              _context.next = 11;
+              break;
+            }
+
+            throw new Error('outputPublicMustBeBoolean');
+
+          case 11:
+            // default values
+            if (jwkey.key === 'EC' && typeof options.compact !== 'boolean') options.compact = false;
+            if (output === 'oct' && options.output !== 'string') options.output = 'binary';
+            if (typeof options.encryptParams === 'undefined') options.encryptParams = {};
+            if ((output === 'der' || output === 'pem') && typeof options.encryptParams.passphrase === 'undefined') options.encryptParams.passphrase = ''; // In the case of PEM/DER
+
+            if (!(output === 'der' || output === 'pem')) {
+              _context.next = 21;
+              break;
+            }
+
+            _context.next = 18;
+            return asn1enc.fromJwk(jwkey, output, {
+              outputPublic: options.outputPublic,
+              compact: options.compact,
+              encOptions: options.encryptParams
+            });
+
+          case 18:
+            return _context.abrupt("return", _context.sent);
+
+          case 21:
+            if (!(output === 'oct' && jwkey.kty === 'EC')) {
+              _context.next = 25;
+              break;
+            }
+
+            return _context.abrupt("return", octenc.fromJwk(jwkey, {
+              outputPublic: options.outputPublic,
+              outputFormat: options.output,
+              compact: options.compact
+            }));
+
+          case 25:
+            throw new Error('UnsupportedConversion');
+
+          case 26:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function fromJwkTo() {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Convert ASN.1 encoded (for RSA and EC) or octet formed (for EC) keys to JWK.
+ * @param {String} input - 'pem', 'der' or 'oct', input key format.
+ * @param {PEM|DER|OctetEC} key - A key object to be encoded.
+ * @param {JwkExportOptionsInternal} [options={}] - options to export JWK keys.
+ * @return {JsonWebKey} - Obtained key object in JWK format.
+ * @throws {Error} - Throws if InvalidInputForm, InappropriateOptions, outputPublicMustBeBoolean or UnsupportedConversion
+ */
+
+
+exports.fromJwkTo = fromJwkTo;
+
+var toJwkFrom =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(input, key) {
+    var options,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            options = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+
+            if (!(['pem', 'der', 'oct'].indexOf(input) < 0)) {
+              _context2.next = 3;
+              break;
+            }
+
+            throw new Error('InvalidInputForm');
+
+          case 3:
+            if (!(input === 'oct' && !options.namedCurve)) {
+              _context2.next = 5;
+              break;
+            }
+
+            throw new Error('InappropriateOptions');
+
+          case 5:
+            if (!(typeof options.outputPublic !== 'undefined' && typeof options.outputPublic !== 'boolean')) {
+              _context2.next = 7;
+              break;
+            }
+
+            throw new Error('outputPublicMustBeBoolean');
+
+          case 7:
+            // default values
+            if ((input === 'der' || input === 'pem') && typeof options.passphrase === 'undefined') options.passphrase = ''; // In the case of PEM
+
+            if (!(input === 'der' || input === 'pem')) {
+              _context2.next = 14;
+              break;
+            }
+
+            _context2.next = 11;
+            return asn1enc.toJwk(key, input, {
+              outputPublic: options.outputPublic,
+              passphrase: options.passphrase
+            });
+
+          case 11:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 14:
+            if (!(input === 'oct')) {
+              _context2.next = 18;
+              break;
+            }
+
+            return _context2.abrupt("return", octenc.toJwk(key, options.namedCurve, {
+              outputPublic: options.outputPublic
+            }));
+
+          case 18:
+            throw new Error('UnsupportedConversion');
+
+          case 19:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function toJwkFrom(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+exports.toJwkFrom = toJwkFrom;

node_modules/js-crypto-key-utils/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Key", {
+  enumerable: true,
+  get: function get() {
+    return _key.Key;
+  }
+});
+exports.default = void 0;
+
+var _key = require("./key.js");
+
+/**
+ * index.js
+ */
+// import {fromJwkTo, toJwkFrom} from './converter.js';
+// import {getJwkThumbprint} from './thumbprint.js';
+// import {isAsn1Encrypted} from './util.js';
+// export default {fromJwkTo, toJwkFrom, getJwkThumbprint, isAsn1Encrypted, Key};
+// export {fromJwkTo, toJwkFrom, getJwkThumbprint, isAsn1Encrypted, Key};
+var _default = {
+  Key: _key.Key
+};
+exports.default = _default;

node_modules/js-crypto-key-utils/dist/key.js

@@ -0,0 +1,601 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Key = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _converter = require("./converter.js");
+
+var _thumbprint = require("./thumbprint.js");
+
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _util = require("./util.js");
+
+/**
+ * key.js
+ */
+
+/**
+ * Key class to abstract public and private key objects in string or binary.
+ *   This class provides functions to interchangeably convert key formats,
+ *   and key objects will be used for the root package, js-crypto-utils, as inputs to exposed APIs.
+ */
+var Key =
+/*#__PURE__*/
+function () {
+  /**
+   * @constructor
+   * @param {String} format - Key format: 'jwk', 'der', 'pem' or 'oct' (only for ECC key).
+   * @param {JsonWebKey|PEM|DER|OctetEC} key - Key object in the specified format.
+   * @param {Object} [options={}] - Required if format='oct', and then it is {namedCurve: String}.
+   * @throws {Error} - Throws if the input format and key are incompatible to the constructor.
+   */
+  function Key(format, key) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    (0, _classCallCheck2.default)(this, Key);
+    var localKey = (0, _lodash.default)(key);
+    var localOpt = (0, _lodash.default)(options);
+    this._jwk = {};
+    this._der = null;
+    this._oct = {}; // only for EC keys
+
+    this._current = {
+      jwk: false,
+      der: false,
+      oct: false
+    };
+
+    if (format === 'jwk') {
+      this._setJwk(localKey);
+    } else if (format === 'der' || format === 'pem') {
+      if (format === 'der' && !(localKey instanceof Uint8Array)) throw new Error('DerKeyMustBeUint8Array');
+      if (format === 'pem' && typeof localKey !== 'string') throw new Error('PemKeyMustBeString');
+
+      this._setAsn1(localKey, format);
+    } else if (format === 'oct') {
+      if (typeof localOpt.namedCurve !== 'string') throw new Error('namedCurveMustBeSpecified');
+      if (!(localKey instanceof Uint8Array)) throw new Error('OctetKeyMustBeUint8Array');
+
+      this._setSec1(localKey, localOpt.namedCurve);
+    } else throw new Error('UnsupportedType');
+  } ///////////////////////////////////////////////////////////
+  // private method handling instance variables
+  // all instance variables must be set via these methods
+
+  /**
+   * Set a key in JWK to the Key object.
+   * @param {JsonWebKey} jwkey - The Json Web Key.
+   * @private
+   */
+
+
+  (0, _createClass2.default)(Key, [{
+    key: "_setJwk",
+    value: function _setJwk(jwkey) {
+      this._type = (0, _util.getJwkType)(jwkey); // this also check key format
+
+      this._jwk = jwkey;
+      if (this._isEncrypted) this._der = null;
+      this._isEncrypted = false;
+
+      this._setCurrentStatus();
+    }
+    /**
+     * Set a key in DER or PEM to the Key object.
+     * @param {DER|PEM} asn1key - The DER key byte array or PEM key string.
+     * @param {String} format - 'der' or 'pem' specifying the format.
+     * @private
+     */
+
+  }, {
+    key: "_setAsn1",
+    value: function _setAsn1(asn1key, format) {
+      this._type = (0, _util.isAsn1Public)(asn1key, format) ? 'public' : 'private'; // this also check key format
+
+      this._isEncrypted = (0, _util.isAsn1Encrypted)(asn1key, format);
+      this._der = format === 'pem' ? _jsEncodingUtils.default.formatter.pemToBin(asn1key) : asn1key;
+
+      if (this._isEncrypted) {
+        this._jwk = {};
+        this._oct = {};
+      }
+
+      this._setCurrentStatus();
+    }
+    /**
+     * Set a key in SEC1 = Octet format to the Key Object.
+     * @param {OctetEC} sec1key - The Octet SEC1 key byte array.
+     * @param {String} namedCurve - Name of curve like 'P-256'.
+     * @private
+     */
+
+  }, {
+    key: "_setSec1",
+    value: function _setSec1(sec1key, namedCurve) {
+      this._type = (0, _util.getSec1KeyType)(sec1key, namedCurve); // this also check key format
+
+      this._oct = {
+        namedCurve: namedCurve,
+        key: sec1key
+      };
+      if (this._isEncrypted) this._der = null;
+      this._isEncrypted = false;
+
+      this._setCurrentStatus();
+    }
+    /**
+     * Set the current internal status. In particular, manage what the object is based on.
+     * @private
+     */
+
+  }, {
+    key: "_setCurrentStatus",
+    value: function _setCurrentStatus() {
+      this._current.jwk = typeof this._jwk.kty === 'string' && (this._jwk.kty === 'RSA' || this._jwk.kty === 'EC');
+      this._current.der = typeof this._der !== 'undefined' && this._der instanceof Uint8Array && this._der.length > 0;
+      this._current.oct = typeof this._oct.key !== 'undefined' && this._oct.key instanceof Uint8Array && this._oct.key.length > 0 && typeof this._oct.namedCurve === 'string';
+    } ///////////////////////////////////////////////////////////
+    // (pseudo) public methods allowed to be accessed from outside
+
+    /**
+     * Convert the stored key and export the key in desired format.
+     * Imported key must be basically decrypted except the case where the key is exported as-is.
+     * @param {String} format - Intended format of exported key. 'jwk', 'pem', 'der' or 'oct'
+     * @param {KeyExportOptions} [options={}] - Optional arguments.
+     * @return {Promise<JsonWebKey|PEM|DER|OctetEC>} - Exported key object.
+     */
+
+  }, {
+    key: "export",
+    value: function () {
+      var _export2 = (0, _asyncToGenerator2.default)(
+      /*#__PURE__*/
+      _regenerator.default.mark(function _callee() {
+        var format,
+            options,
+            jwkey,
+            _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                format = _args.length > 0 && _args[0] !== undefined ? _args[0] : 'jwk';
+                options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+
+                if (!(['pem', 'der', 'jwk', 'oct'].indexOf(format) < 0)) {
+                  _context.next = 4;
+                  break;
+                }
+
+                throw new Error('UnsupportedFormat');
+
+              case 4:
+                if (!(this._isEncrypted && this._type === 'private')) {
+                  _context.next = 10;
+                  break;
+                }
+
+                if (!((format === 'der' || format === 'pem') && Object.keys(options).length === 0 && this._current.der)) {
+                  _context.next = 9;
+                  break;
+                }
+
+                return _context.abrupt("return", format === 'pem' ? _jsEncodingUtils.default.formatter.binToPem(this._der, 'encryptedPrivate') : this._der);
+
+              case 9:
+                throw new Error('DecryptionRequired');
+
+              case 10:
+                if (!this._current.jwk) {
+                  _context.next = 14;
+                  break;
+                }
+
+                jwkey = this._jwk;
+                _context.next = 27;
+                break;
+
+              case 14:
+                if (!this._current.oct) {
+                  _context.next = 20;
+                  break;
+                }
+
+                _context.next = 17;
+                return (0, _converter.toJwkFrom)('oct', this._oct.key, {
+                  namedCurve: this._oct.namedCurve
+                });
+
+              case 17:
+                jwkey = _context.sent;
+                _context.next = 27;
+                break;
+
+              case 20:
+                if (!this._current.der) {
+                  _context.next = 26;
+                  break;
+                }
+
+                _context.next = 23;
+                return (0, _converter.toJwkFrom)('der', this._der);
+
+              case 23:
+                jwkey = _context.sent;
+                _context.next = 27;
+                break;
+
+              case 26:
+                throw new Error('InvalidStatus');
+
+              case 27:
+                this._setJwk(jwkey); // store jwk if the exiting private key is not encrypted
+                // then export as the key in intended format
+
+
+                if (!(format === 'der' || format === 'pem')) {
+                  _context.next = 35;
+                  break;
+                }
+
+                if (typeof options.encryptParams === 'undefined') options.encryptParams = {};
+                _context.next = 32;
+                return (0, _converter.fromJwkTo)(format, jwkey, {
+                  outputPublic: options.outputPublic,
+                  compact: options.compact,
+                  //passphrase: options.encryptParams.passphrase,
+                  encryptParams: options.encryptParams
+                });
+
+              case 32:
+                return _context.abrupt("return", _context.sent);
+
+              case 35:
+                if (!(format === 'oct')) {
+                  _context.next = 41;
+                  break;
+                }
+
+                _context.next = 38;
+                return (0, _converter.fromJwkTo)(format, jwkey, {
+                  outputPublic: options.outputPublic,
+                  output: options.output,
+                  compact: options.compact
+                });
+
+              case 38:
+                return _context.abrupt("return", _context.sent);
+
+              case 41:
+                return _context.abrupt("return", jwkey);
+
+              case 42:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function _export() {
+        return _export2.apply(this, arguments);
+      }
+
+      return _export;
+    }()
+    /**
+     * Encrypt stored key and set the encrypted key to this instance.
+     * @param {String} passphrase - String passphrase.
+     * @return {Promise<boolean>} - Always true otherwise thrown.
+     * @throws {Error} - Throws if AlreadyEncrypted.
+     */
+
+  }, {
+    key: "encrypt",
+    value: function () {
+      var _encrypt = (0, _asyncToGenerator2.default)(
+      /*#__PURE__*/
+      _regenerator.default.mark(function _callee2(passphrase) {
+        var options;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!this._isEncrypted) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                throw new Error('AlreadyEncrypted');
+
+              case 2:
+                options = {
+                  encryptParams: {
+                    passphrase: passphrase
+                  }
+                };
+                _context2.t0 = this;
+                _context2.next = 6;
+                return this.export('der', options);
+
+              case 6:
+                _context2.t1 = _context2.sent;
+
+                _context2.t0._setAsn1.call(_context2.t0, _context2.t1, 'der');
+
+                return _context2.abrupt("return", true);
+
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function encrypt(_x) {
+        return _encrypt.apply(this, arguments);
+      }
+
+      return encrypt;
+    }()
+    /**
+     * Decrypted stored key and set the decrypted key in JWK to this instance.
+     * @param {String} passphrase - String passphrase.
+     * @return {Promise<boolean>} - Always true otherwise thrown.
+     * @throws {Error} - Throws if NotEncrypted or FailedToDecrypt.
+     */
+
+  }, {
+    key: "decrypt",
+    value: function () {
+      var _decrypt = (0, _asyncToGenerator2.default)(
+      /*#__PURE__*/
+      _regenerator.default.mark(function _callee3(passphrase) {
+        var jwkey;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (this._isEncrypted) {
+                  _context3.next = 2;
+                  break;
+                }
+
+                throw new Error('NotEncrypted');
+
+              case 2:
+                if (!(this._current.der && typeof passphrase === 'string')) {
+                  _context3.next = 8;
+                  break;
+                }
+
+                _context3.next = 5;
+                return (0, _converter.toJwkFrom)('der', this._der, {
+                  passphrase: passphrase
+                });
+
+              case 5:
+                jwkey = _context3.sent;
+                _context3.next = 9;
+                break;
+
+              case 8:
+                throw new Error('FailedToDecrypt');
+
+              case 9:
+                this._setJwk(jwkey);
+
+                return _context3.abrupt("return", true);
+
+              case 11:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function decrypt(_x2) {
+        return _decrypt.apply(this, arguments);
+      }
+
+      return decrypt;
+    }()
+    /**
+     * Conpute JWK thumbprint specified in RFC7638 {@link https://tools.ietf.org/html/rfc7638}.
+     * @param {String} [alg='SHA-256'] - Name of hash algorithm for thumbprint computation like 'SHA-256'.
+     * @param {JwkThumbpirntFormat} [output='binary'] - Output format of JWK thumbprint. 'binary', 'hex' or 'base64'.
+     * @return {Promise<Uint8Array|String>} - Computed thumbprint.
+     * @throws {Error} - Throws if DecryptionRequired.
+     */
+
+  }, {
+    key: "getJwkThumbprint",
+    value: function () {
+      var _getJwkThumbprint2 = (0, _asyncToGenerator2.default)(
+      /*#__PURE__*/
+      _regenerator.default.mark(function _callee4() {
+        var alg,
+            output,
+            _args4 = arguments;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                alg = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : 'SHA-256';
+                output = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : 'binary';
+
+                if (!this._isEncrypted) {
+                  _context4.next = 4;
+                  break;
+                }
+
+                throw new Error('DecryptionRequired');
+
+              case 4:
+                _context4.t0 = _thumbprint.getJwkThumbprint;
+                _context4.next = 7;
+                return this.export('jwk');
+
+              case 7:
+                _context4.t1 = _context4.sent;
+                _context4.t2 = alg;
+                _context4.t3 = output;
+                _context4.next = 12;
+                return (0, _context4.t0)(_context4.t1, _context4.t2, _context4.t3);
+
+              case 12:
+                return _context4.abrupt("return", _context4.sent);
+
+              case 13:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function getJwkThumbprint() {
+        return _getJwkThumbprint2.apply(this, arguments);
+      }
+
+      return getJwkThumbprint;
+    }() // getters
+
+    /**
+     * Get keyType in JWK format
+     * @return {Promise<String>} - 'RSA' or 'EC'
+     * @throws {Error} - Throws if DecryptionRequired.
+     */
+
+  }, {
+    key: "keyType",
+    get: function get() {
+      var _this = this;
+
+      if (this._isEncrypted) throw new Error('DecryptionRequired');
+      return new Promise(
+      /*#__PURE__*/
+      function () {
+        var _ref = (0, _asyncToGenerator2.default)(
+        /*#__PURE__*/
+        _regenerator.default.mark(function _callee5(resolve, reject) {
+          var jwkey;
+          return _regenerator.default.wrap(function _callee5$(_context5) {
+            while (1) {
+              switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 2;
+                  return _this.export('jwk').catch(function (e) {
+                    reject(e);
+                  });
+
+                case 2:
+                  jwkey = _context5.sent;
+                  resolve(jwkey.kty);
+
+                case 4:
+                case "end":
+                  return _context5.stop();
+              }
+            }
+          }, _callee5);
+        }));
+
+        return function (_x3, _x4) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    }
+    /**
+     * Get jwkThumbprint of this key.
+     * @return {Promise<Uint8Array>} - Returns binary thumbprint.
+     */
+
+  }, {
+    key: "jwkThumbprint",
+    get: function get() {
+      return this.getJwkThumbprint();
+    }
+    /**
+     * Check if this is encrypted.
+     * @return {boolean}
+     */
+
+  }, {
+    key: "isEncrypted",
+    get: function get() {
+      return this._isEncrypted;
+    }
+    /**
+     * Check if this is a private key.
+     * @return {boolean}
+     */
+
+  }, {
+    key: "isPrivate",
+    get: function get() {
+      return this._type === 'private';
+    }
+    /**
+     * Returns the key in DER format.
+     * @return {Promise<DER>}
+     */
+
+  }, {
+    key: "der",
+    get: function get() {
+      return this.export('der');
+    }
+    /**
+     * Returns the key in PEM format.
+     * @return {Promise<PEM>}
+     */
+
+  }, {
+    key: "pem",
+    get: function get() {
+      return this.export('pem');
+    }
+    /**
+     * Returns the key in JWK format
+     * @return {Promise<JsonWebKey>}
+     */
+
+  }, {
+    key: "jwk",
+    get: function get() {
+      return this.export('jwk');
+    }
+    /**
+     * Returns the 'EC' key in Octet SEC1 format.
+     * @return {Promise<OctetEC>}
+     */
+
+  }, {
+    key: "oct",
+    get: function get() {
+      return this.export('oct', {
+        output: 'string'
+      });
+    }
+  }]);
+  return Key;
+}();
+
+exports.Key = Key;

node_modules/js-crypto-key-utils/dist/octenc.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toJwk = exports.fromJwk = void 0;
+
+var _params = _interopRequireDefault(require("./params.js"));
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _elliptic = _interopRequireDefault(require("elliptic"));
+
+var _util = require("./util.js");
+
+/**
+ * octenc.js
+ */
+var Ec = _elliptic.default.ec;
+/**
+ * Convert JWK EC public/private keys to octet form.
+ * Compressed form of EC public key is referred to RFC 5480 {@link https://tools.ietf.org/html/rfc5480}.
+ * @param {JsonWebKey} jwkey - A key object in JWK format to be encoded to SEC1 octet format key.
+ * @param {boolean} [outputPublic] - Export public key even from private key if true.
+ * @param {OctetFormat} [outputFormat='binary'] - 'binary' or 'string'.
+ * @param {boolean} [compact=false] - Export compressed form of public key if true.
+ * @return {JsonWebKey} - Encoded key object in JWK format.
+ */
+
+var fromJwk = function fromJwk(jwkey, _ref) {
+  var outputPublic = _ref.outputPublic,
+      _ref$outputFormat = _ref.outputFormat,
+      outputFormat = _ref$outputFormat === void 0 ? 'binary' : _ref$outputFormat,
+      _ref$compact = _ref.compact,
+      compact = _ref$compact === void 0 ? false : _ref$compact;
+  // original key type
+  var orgType = (0, _util.getJwkType)(jwkey);
+  var type = typeof outputPublic === 'boolean' && outputPublic ? 'public' : orgType;
+
+  if (type === 'public') {
+    var bufX = _jsEncodingUtils.default.encoder.decodeBase64Url(jwkey.x);
+
+    var bufY = _jsEncodingUtils.default.encoder.decodeBase64Url(jwkey.y);
+
+    var publicKey;
+
+    if (compact) {
+      // compressed form
+      // http://www.secg.org/SEC1-Ver-1.0.pdf
+      publicKey = new Uint8Array(bufX.length + 1);
+      publicKey[0] = 0xFF & (0x01 & bufY.slice(-1)[0]) + 0x02;
+      publicKey.set(bufX, 1);
+    } else {
+      // uncompressed form
+      publicKey = new Uint8Array(bufX.length + bufY.length + 1);
+      publicKey[0] = 0xFF & 0x04;
+      publicKey.set(bufX, 1);
+      publicKey.set(bufY, bufX.length + 1);
+    }
+
+    return outputFormat === 'string' ? _jsEncodingUtils.default.encoder.arrayBufferToHexString(publicKey) : publicKey;
+  } else if (type === 'private') {
+    if (!jwkey.d) throw new Error('InvalidKey');
+
+    var bufD = _jsEncodingUtils.default.encoder.decodeBase64Url(jwkey.d);
+
+    return outputFormat === 'string' ? _jsEncodingUtils.default.encoder.arrayBufferToHexString(bufD) : bufD;
+  }
+};
+/**
+ * Convert Octet form of EC public/private keys to JWK.
+ * @param {String|Uint8Array} octkey - OctetEC key object in hex string format or Uint8Array.
+ * @param {String} namedCurve - Name of elliptic curve like 'P-256'.
+ * @param {boolean} [outputPublic] - Export public key even from private key if true.
+ * @return {JsonWebKey} - Derived key object in JWK format.
+ */
+
+
+exports.fromJwk = fromJwk;
+
+var toJwk = function toJwk(octkey, namedCurve, _ref2) {
+  var outputPublic = _ref2.outputPublic;
+  if (Object.keys(_params.default.namedCurves).indexOf(namedCurve) < 0) throw new Error('UnsupportedCurve'); // original key type and check the key structure
+
+  var orgType = (0, _util.getSec1KeyType)(octkey, namedCurve);
+  var type = typeof outputPublic === 'boolean' && outputPublic ? 'public' : orgType; // format conversion
+
+  var binKey = typeof octkey === 'string' ? _jsEncodingUtils.default.encoder.hexStringToArrayBuffer(octkey) : octkey; // instantiation
+
+  var curve = _params.default.namedCurves[namedCurve].indutnyName;
+  var ec = new Ec(curve); // derive key object from binary key
+
+  var ecKey = orgType === 'public' ? ec.keyFromPublic(binKey) : ec.keyFromPrivate(binKey);
+  var publicKey = new Uint8Array(ecKey.getPublic('array'));
+  var len = _params.default.namedCurves[namedCurve].payloadSize;
+  var bufX = publicKey.slice(1, len + 1);
+  var bufY = publicKey.slice(len + 1, len * 2 + 1);
+  var jwKey = {
+    // https://www.rfc-editor.org/rfc/rfc7518.txt
+    kty: 'EC',
+    crv: namedCurve,
+    x: _jsEncodingUtils.default.encoder.encodeBase64Url(bufX),
+    // oct to base64url
+    y: _jsEncodingUtils.default.encoder.encodeBase64Url(bufY) // ext: true
+
+  };
+
+  if (type === 'private') {
+    // octkey is exactly private key if type is private.
+    jwKey.d = _jsEncodingUtils.default.encoder.encodeBase64Url(binKey);
+  }
+
+  return jwKey;
+};
+
+exports.toJwk = toJwk;

node_modules/js-crypto-key-utils/dist/params.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAlgorithmFromOid = getAlgorithmFromOid;
+exports.getAlgorithmFromOidStrict = exports.default = void 0;
+
+/**
+ * params.js
+ */
+var _default = {
+  // oid is referred to rfc5480 https://www.ietf.org/rfc/rfc5480.txt
+  namedCurves: {
+    'P-256': {
+      indutnyName: 'p256',
+      payloadSize: 32,
+      oid: [1, 2, 840, 10045, 3, 1, 7]
+    },
+    'P-384': {
+      indutnyName: 'p384',
+      payloadSize: 48,
+      oid: [1, 3, 132, 0, 34]
+    },
+    'P-521': {
+      indutnyName: 'p521',
+      payloadSize: 66,
+      oid: [1, 3, 132, 0, 35]
+    },
+    'P-256K': {
+      indutnyName: 'secp256k1',
+      payloadSize: 32,
+      oid: [1, 3, 132, 0, 10]
+    }
+  },
+  // https://tools.ietf.org/html/rfc3279
+  publicKeyAlgorithms: {
+    'EC': {
+      oid: [1, 2, 840, 10045, 2, 1]
+    },
+    'RSA': {
+      oid: [1, 2, 840, 113549, 1, 1, 1]
+    }
+  },
+  passwordBasedEncryptionSchemes: {
+    // PBES1
+    'pbeWithMD5AndDES-CBC': {
+      oid: [1, 2, 840, 113549, 1, 5, 3],
+      hash: 'MD5',
+      encrypt: 'DES-CBC'
+    },
+    'pbeWithSHA1AndDES-CBC': {
+      oid: [1, 2, 840, 113549, 1, 5, 10],
+      hash: 'SHA-1',
+      encrypt: 'DES-CBC'
+    },
+    // PBES2
+    'pbes2': {
+      oid: [1, 2, 840, 113549, 1, 5, 13]
+    }
+  },
+  keyDerivationFunctions: {
+    'pbkdf2': {
+      oid: [1, 2, 840, 113549, 1, 5, 12],
+      defaultSaltLen: 8
+    }
+  },
+  pbkdf2Prfs: {
+    'hmacWithSHA1': {
+      oid: [1, 2, 840, 113549, 2, 7],
+      hash: 'SHA-1'
+    },
+    'hmacWithSHA256': {
+      oid: [1, 2, 840, 113549, 2, 9],
+      hash: 'SHA-256'
+    },
+    'hmacWithSHA384': {
+      oid: [1, 2, 840, 113549, 2, 10],
+      hash: 'SHA-384'
+    },
+    'hmacWithSHA512': {
+      oid: [1, 2, 840, 113549, 2, 11],
+      hash: 'SHA-512'
+    }
+  },
+  encryptionSchemes: {
+    'des-ede3-cbc': {
+      oid: [1, 2, 840, 113549, 3, 7],
+      keyLength: 24,
+      ivLength: 8
+    },
+    'aes128-cbc': {
+      oid: [2, 16, 840, 1, 101, 3, 4, 1, 2],
+      keyLength: 16,
+      ivLength: 16
+    },
+    'aes192-cbc': {
+      oid: [2, 16, 840, 1, 101, 3, 4, 1, 22],
+      keyLength: 24,
+      ivLength: 16
+    },
+    'aes256-cbc': {
+      oid: [2, 16, 840, 1, 101, 3, 4, 1, 42],
+      keyLength: 32,
+      ivLength: 16
+    }
+  },
+  hashes: {
+    'SHA-256': {
+      hashSize: 32
+    },
+    'SHA-384': {
+      hashSize: 48
+    },
+    'SHA-512': {
+      hashSize: 64
+    },
+    'SHA-1': {
+      hashSize: 20
+    },
+    // SHOULD NOT USE
+    'MD5': {
+      hashSize: 16 // SHOULD NOT USE
+
+    }
+  }
+};
+/**
+ * Get algorithm name from ObjectIdentifier array loosely.
+ * @param {Array} oid - ObjectIdentifier.
+ * @param {Object} oidDict - Dictionary of ObjectIdentifier.
+ * @return {Array} - Array of ObjectIdentifier array.
+ */
+
+exports.default = _default;
+
+function getAlgorithmFromOid(oid, oidDict) {
+  return Object.keys(oidDict).filter(function (k) {
+    return oidDict[k].oid.toString() === oid.toString();
+  });
+}
+/**
+ * Get algorithm name from ObjectIdentifier array strictly.
+ * @param {Array} oid - ObjectIdentifier.
+ * @param {Object} dict - Dictionary of ObjectIdentifier.
+ * @return {Array} - Exactly one ObjectIdentifier.
+ * @throws {Error} - Throws if UnsupportedAlgorithm.
+ */
+
+
+var getAlgorithmFromOidStrict = function getAlgorithmFromOidStrict(oid, dict) {
+  var array = getAlgorithmFromOid(oid, dict);
+  if (array.length === 0) throw new Error('UnsupportedAlgorithm');
+  return array[0];
+};
+
+exports.getAlgorithmFromOidStrict = getAlgorithmFromOidStrict;

node_modules/js-crypto-key-utils/dist/rfc8018.js

@@ -0,0 +1,631 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decryptEncryptedPrivateKeyInfo = exports.encryptEncryptedPrivateKeyInfo = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _params = _interopRequireWildcard(require("./params.js"));
+
+var _asn1def = require("./asn1def.js");
+
+var _des = _interopRequireDefault(require("des.js"));
+
+var _buffer = _interopRequireDefault(require("buffer"));
+
+var _asn = _interopRequireDefault(require("asn1.js"));
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _jsCryptoPbkdf = _interopRequireDefault(require("js-crypto-pbkdf"));
+
+var _jsCryptoAes = _interopRequireDefault(require("js-crypto-aes"));
+
+var _jsCryptoRandom = _interopRequireDefault(require("js-crypto-random"));
+
+/**
+ * rfc8081
+ */
+var Buffer = _buffer.default.Buffer;
+var BN = _asn.default.bignum; ///////////////////////////////////////////////////////////////////
+
+/**
+ * Generate EncryptedPrivateKeyInfo ASN.1 object.
+ * @param {DER} binKey - Binary key in DER format.
+ * @param {AsnEncryptOptionsWithPassphrase} [options={passphrase: ''}] - Encryption options for ASN.1 private key.
+ * @return {Promise<DER>} - Encrypted private key in DER.
+ */
+
+var encryptEncryptedPrivateKeyInfo =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee(binKey) {
+    var options,
+        kdfAlgorithm,
+        encryptedPBES2,
+        encryptedPBES1,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {
+              passphrase: ''
+            };
+            // default params
+            if (typeof options.algorithm === 'undefined') options.algorithm = 'pbes2';
+            if (typeof options.iterationCount === 'undefined') options.iterationCount = 2048;
+
+            if (!(options.algorithm === 'pbes2')) {
+              _context.next = 15;
+              break;
+            }
+
+            if (typeof options.cipher === 'undefined') options.cipher = 'aes256-cbc';
+            if (typeof options.prf === 'undefined') options.prf = 'hmacWithSHA256';
+            kdfAlgorithm = 'pbkdf2'; // TODO: currently only pbkdf2 is available
+
+            _context.next = 9;
+            return encryptPBES2(binKey, options.passphrase, kdfAlgorithm, options.prf, options.iterationCount, options.cipher);
+
+          case 9:
+            encryptedPBES2 = _context.sent;
+            _context.next = 12;
+            return encodePBES2(encryptedPBES2);
+
+          case 12:
+            return _context.abrupt("return", _context.sent);
+
+          case 15:
+            _context.next = 17;
+            return encryptPBES1(binKey, options.passphrase, options.algorithm, options.iterationCount);
+
+          case 17:
+            encryptedPBES1 = _context.sent;
+            encryptedPBES1.encryptionAlgorithm.algorithm = _params.default.passwordBasedEncryptionSchemes[encryptedPBES1.encryptionAlgorithm.algorithm].oid;
+            encryptedPBES1.encryptionAlgorithm.parameters = _asn1def.PBEParameter.encode(encryptedPBES1.encryptionAlgorithm.parameters, 'der');
+            return _context.abrupt("return", _asn1def.EncryptedPrivateKeyInfo.encode(encryptedPBES1, 'der'));
+
+          case 21:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function encryptEncryptedPrivateKeyInfo(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Decrypt EncryptedPrivateKeyInfo
+ * @param {Object} epki - Parsed encrypted
+ * @param {String} passphrase - Passphrase to decyrpt the object.
+ * @return {Promise<Object>} - Decrypted object.
+ */
+
+
+exports.encryptEncryptedPrivateKeyInfo = encryptEncryptedPrivateKeyInfo;
+
+var decryptEncryptedPrivateKeyInfo =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(epki, passphrase) {
+    var decoded;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            decoded = {}; // encryptionAlgorithm.algorithm
+
+            decoded.encryptionAlgorithm = {
+              algorithm: (0, _params.getAlgorithmFromOidStrict)(epki.encryptionAlgorithm.algorithm, _params.default.passwordBasedEncryptionSchemes)
+            };
+
+            if (decoded.encryptionAlgorithm.algorithm === 'pbes2') {
+              decoded.encryptionAlgorithm.parameters = decodePBES2(epki.encryptionAlgorithm.parameters);
+            } else {
+              decoded.encryptionAlgorithm.parameters = _asn1def.PBEParameter.decode(epki.encryptionAlgorithm.parameters, 'der');
+            }
+
+            decoded.encryptedData = epki.encryptedData; // decrypt
+
+            if (!(decoded.encryptionAlgorithm.algorithm === 'pbes2')) {
+              _context2.next = 10;
+              break;
+            }
+
+            _context2.next = 7;
+            return decryptPBES2(decoded, passphrase);
+
+          case 7:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 10:
+            _context2.next = 12;
+            return decryptPBES1(decoded, passphrase);
+
+          case 12:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function decryptEncryptedPrivateKeyInfo(_x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}(); //////////////////////////////
+
+
+exports.decryptEncryptedPrivateKeyInfo = decryptEncryptedPrivateKeyInfo;
+
+var encodePBES2 = function encodePBES2(decoded) {
+  var epki = {
+    encryptionAlgorithm: {}
+  }; // algorithm
+
+  epki.encryptionAlgorithm.algorithm = _params.default.passwordBasedEncryptionSchemes[decoded.encryptionAlgorithm.algorithm].oid; // kdf
+
+  var kdf = decoded.encryptionAlgorithm.parameters.keyDerivationFunc;
+
+  if (kdf.algorithm === 'pbkdf2') {
+    kdf.parameters.prf.algorithm = _params.default.pbkdf2Prfs[kdf.parameters.prf.algorithm].oid;
+    kdf.parameters = _asn1def.PBKDF2Params.encode(kdf.parameters, 'der');
+  } else throw new Error('UnsupportedKDF');
+
+  kdf.algorithm = _params.default.keyDerivationFunctions[kdf.algorithm].oid; // encryptionScheme
+
+  var eS = decoded.encryptionAlgorithm.parameters.encryptionScheme;
+
+  if (Object.keys(_asn1def.PBES2ESParams).indexOf(eS.algorithm) >= 0) {
+    eS.parameters = _asn1def.PBES2ESParams[eS.algorithm].encode(eS.parameters, 'der');
+  } else throw new Error('UnsupportedCipher');
+
+  eS.algorithm = _params.default.encryptionSchemes[eS.algorithm].oid; // params
+
+  epki.encryptionAlgorithm.parameters = _asn1def.PBES2Params.encode({
+    keyDerivationFunc: kdf,
+    encryptionScheme: eS
+  }, 'der'); // encoded data
+
+  epki.encryptedData = decoded.encryptedData;
+  return _asn1def.EncryptedPrivateKeyInfo.encode(epki, 'der');
+};
+
+var decodePBES2 = function decodePBES2(rawParams) {
+  var pbes2Params = _asn1def.PBES2Params.decode(rawParams, 'der'); // keyDerivationFunc
+
+
+  var kdfAlgorithm = (0, _params.getAlgorithmFromOidStrict)(pbes2Params.keyDerivationFunc.algorithm, _params.default.keyDerivationFunctions);
+  var iterationCount;
+  var salt;
+  var prf;
+
+  if (kdfAlgorithm === 'pbkdf2') {
+    var pbkdf2Params = _asn1def.PBKDF2Params.decode(pbes2Params.keyDerivationFunc.parameters, 'der');
+
+    prf = {
+      algorithm: (0, _params.getAlgorithmFromOidStrict)(pbkdf2Params.prf.algorithm, _params.default.pbkdf2Prfs),
+      parameters: pbkdf2Params.prf.parameters
+    };
+    iterationCount = pbkdf2Params.iterationCount;
+    salt = {
+      type: pbkdf2Params.salt.type,
+      value: pbkdf2Params.salt.value
+    };
+  } else throw new Error('UnsupportedKDF'); //encryptionScheme
+
+
+  var encryptionScheme = (0, _params.getAlgorithmFromOidStrict)(pbes2Params.encryptionScheme.algorithm, _params.default.encryptionSchemes);
+  var encryptionParams;
+
+  if (Object.keys(_asn1def.PBES2ESParams).indexOf(encryptionScheme) >= 0) {
+    encryptionParams = _asn1def.PBES2ESParams[encryptionScheme].decode(pbes2Params.encryptionScheme.parameters, 'der');
+  } else throw new Error('UnsupportedCipher'); // TODO: Other Encryption Scheme
+
+
+  return {
+    keyDerivationFunc: {
+      algorithm: kdfAlgorithm,
+      parameters: {
+        salt: salt,
+        iterationCount: iterationCount,
+        prf: prf
+      }
+    },
+    encryptionScheme: {
+      algorithm: encryptionScheme,
+      parameters: encryptionParams
+    }
+  };
+}; //////////////////////
+// PBES2 RFC8018 Section 6.2.1
+
+
+var encryptPBES2 =
+/*#__PURE__*/
+function () {
+  var _ref3 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee3(binKey, passphrase, kdfAlgorithm, prf, iterationCount, cipher) {
+    var pBuffer, salt, keyLength, key, iv, encryptedData, CBC, ct;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            // kdf
+            pBuffer = _jsEncodingUtils.default.encoder.stringToArrayBuffer(passphrase);
+            _context3.next = 3;
+            return _jsCryptoRandom.default.getRandomBytes(_params.default.keyDerivationFunctions[kdfAlgorithm].defaultSaltLen);
+
+          case 3:
+            salt = _context3.sent;
+            // TODO: currently only salt length of 8 is available
+            keyLength = _params.default.encryptionSchemes[cipher].keyLength; // get keyLength
+
+            if (!(kdfAlgorithm === 'pbkdf2')) {
+              _context3.next = 11;
+              break;
+            }
+
+            _context3.next = 8;
+            return _jsCryptoPbkdf.default.pbkdf2(pBuffer, salt, iterationCount, keyLength, _params.default.pbkdf2Prfs[prf].hash);
+
+          case 8:
+            key = _context3.sent;
+            _context3.next = 12;
+            break;
+
+          case 11:
+            throw new Error('UnsupportedKDF');
+
+          case 12:
+            if (!(cipher === 'des-ede3-cbc')) {
+              _context3.next = 23;
+              break;
+            }
+
+            _context3.t0 = Buffer;
+            _context3.next = 16;
+            return _jsCryptoRandom.default.getRandomBytes(_params.default.encryptionSchemes[cipher].ivLength);
+
+          case 16:
+            _context3.t1 = _context3.sent;
+            iv = _context3.t0.from.call(_context3.t0, _context3.t1);
+            CBC = _des.default.CBC.instantiate(_des.default.EDE);
+            ct = CBC.create({
+              type: 'encrypt',
+              key: Buffer.from(key),
+              iv: iv
+            });
+            encryptedData = Buffer.from(ct.update(binKey).concat(ct.final()));
+            _context3.next = 36;
+            break;
+
+          case 23:
+            if (!(cipher === 'aes128-cbc' || cipher === 'aes192-cbc' || cipher === 'aes256-cbc')) {
+              _context3.next = 35;
+              break;
+            }
+
+            _context3.next = 26;
+            return _jsCryptoRandom.default.getRandomBytes(_params.default.encryptionSchemes[cipher].ivLength);
+
+          case 26:
+            iv = _context3.sent;
+            _context3.t2 = Buffer;
+            _context3.next = 30;
+            return _jsCryptoAes.default.encrypt(new Uint8Array(binKey), key, {
+              name: 'AES-CBC',
+              iv: iv
+            });
+
+          case 30:
+            _context3.t3 = _context3.sent;
+            encryptedData = _context3.t2.from.call(_context3.t2, _context3.t3);
+            iv = Buffer.from(iv);
+            _context3.next = 36;
+            break;
+
+          case 35:
+            throw new Error('UnsupportedCipher');
+
+          case 36:
+            return _context3.abrupt("return", {
+              encryptedData: encryptedData,
+              encryptionAlgorithm: {
+                algorithm: 'pbes2',
+                parameters: {
+                  keyDerivationFunc: {
+                    algorithm: kdfAlgorithm,
+                    parameters: {
+                      salt: {
+                        type: 'specified',
+                        value: Buffer.from(salt)
+                      },
+                      iterationCount: new BN(iterationCount),
+                      prf: {
+                        algorithm: prf,
+                        parameters: Buffer.from([0x05, 0x00])
+                      }
+                    }
+                  },
+                  encryptionScheme: {
+                    algorithm: cipher,
+                    parameters: iv
+                  }
+                }
+              }
+            });
+
+          case 37:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function encryptPBES2(_x4, _x5, _x6, _x7, _x8, _x9) {
+    return _ref3.apply(this, arguments);
+  };
+}(); //////////////////////////////
+// PBES2 RFC8018 Section 6.2.2
+
+
+var decryptPBES2 =
+/*#__PURE__*/
+function () {
+  var _ref4 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee4(decoded, passphrase) {
+    var kdf, eS, keyLength, key, pBuffer, salt, iterationCount, prf, out, iv, CBC, pt, _iv;
+
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            kdf = decoded.encryptionAlgorithm.parameters.keyDerivationFunc;
+            eS = decoded.encryptionAlgorithm.parameters.encryptionScheme; // pbkdf2
+
+            keyLength = _params.default.encryptionSchemes[eS.algorithm].keyLength; // get keyLength
+
+            if (!(kdf.algorithm === 'pbkdf2')) {
+              _context4.next = 15;
+              break;
+            }
+
+            pBuffer = _jsEncodingUtils.default.encoder.stringToArrayBuffer(passphrase);
+
+            if (!(kdf.parameters.salt.type !== 'specified')) {
+              _context4.next = 7;
+              break;
+            }
+
+            throw new Error('UnsupportedSaltSource');
+
+          case 7:
+            salt = new Uint8Array(kdf.parameters.salt.value);
+            iterationCount = kdf.parameters.iterationCount.toNumber();
+            prf = kdf.parameters.prf.algorithm;
+            _context4.next = 12;
+            return _jsCryptoPbkdf.default.pbkdf2(pBuffer, salt, iterationCount, keyLength, _params.default.pbkdf2Prfs[prf].hash);
+
+          case 12:
+            key = _context4.sent;
+            _context4.next = 16;
+            break;
+
+          case 15:
+            throw new Error('UnsupportedKDF');
+
+          case 16:
+            if (!(eS.algorithm === 'des-ede3-cbc')) {
+              _context4.next = 23;
+              break;
+            }
+
+            iv = eS.parameters;
+            CBC = _des.default.CBC.instantiate(_des.default.EDE);
+            pt = CBC.create({
+              type: 'decrypt',
+              key: key,
+              iv: iv
+            });
+            out = Buffer.from(pt.update(decoded.encryptedData).concat(pt.final()));
+            _context4.next = 33;
+            break;
+
+          case 23:
+            if (!(eS.algorithm === 'aes128-cbc' || eS.algorithm === 'aes192-cbc' || eS.algorithm === 'aes256-cbc')) {
+              _context4.next = 32;
+              break;
+            }
+
+            _iv = new Uint8Array(eS.parameters);
+            _context4.t0 = Buffer;
+            _context4.next = 28;
+            return _jsCryptoAes.default.decrypt(new Uint8Array(decoded.encryptedData), key, {
+              name: 'AES-CBC',
+              iv: _iv
+            });
+
+          case 28:
+            _context4.t1 = _context4.sent;
+            out = _context4.t0.from.call(_context4.t0, _context4.t1);
+            _context4.next = 33;
+            break;
+
+          case 32:
+            throw new Error('UnsupportedEncryptionAlgorithm');
+
+          case 33:
+            return _context4.abrupt("return", _asn1def.OneAsymmetricKey.decode(out, 'der'));
+
+          case 34:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function decryptPBES2(_x10, _x11) {
+    return _ref4.apply(this, arguments);
+  };
+}(); //////////////////////////////
+// PBES1 RFC8018 Section 6.1.1
+
+
+var encryptPBES1 =
+/*#__PURE__*/
+function () {
+  var _ref5 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee5(binKey, passphrase, algorithm, iterationCount) {
+    var pBuffer, salt, hash, keyIv, key, iv, encrypt, out, CBC, ct;
+    return _regenerator.default.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            // pbkdf1
+            pBuffer = _jsEncodingUtils.default.encoder.stringToArrayBuffer(passphrase);
+            _context5.next = 3;
+            return _jsCryptoRandom.default.getRandomBytes(8);
+
+          case 3:
+            salt = _context5.sent;
+            // defined as 8 octet
+            hash = _params.default.passwordBasedEncryptionSchemes[algorithm].hash;
+            _context5.next = 7;
+            return _jsCryptoPbkdf.default.pbkdf1(pBuffer, salt, iterationCount, 16, hash);
+
+          case 7:
+            keyIv = _context5.sent;
+            key = keyIv.slice(0, 8);
+            iv = keyIv.slice(8, 16); // decryption
+
+            encrypt = _params.default.passwordBasedEncryptionSchemes[algorithm].encrypt;
+
+            if (!(encrypt === 'DES-CBC')) {
+              _context5.next = 17;
+              break;
+            }
+
+            CBC = _des.default.CBC.instantiate(_des.default.DES);
+            ct = CBC.create({
+              type: 'encrypt',
+              key: key,
+              iv: iv
+            });
+            out = Buffer.from(ct.update(binKey).concat(ct.final()));
+            _context5.next = 18;
+            break;
+
+          case 17:
+            throw new Error('UnsupportedEncryptionAlgorithm');
+
+          case 18:
+            return _context5.abrupt("return", {
+              encryptionAlgorithm: {
+                algorithm: algorithm,
+                parameters: {
+                  salt: Buffer.from(salt),
+                  iterationCount: new BN(iterationCount)
+                }
+              },
+              encryptedData: out
+            });
+
+          case 19:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+
+  return function encryptPBES1(_x12, _x13, _x14, _x15) {
+    return _ref5.apply(this, arguments);
+  };
+}(); //////////////////////////////
+// PBES1 RFC8018 Section 6.1.2
+
+
+var decryptPBES1 =
+/*#__PURE__*/
+function () {
+  var _ref6 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee6(decoded, passphrase) {
+    var pBuffer, salt, hash, iterationCount, keyIv, key, iv, encrypt, out, CBC, ct;
+    return _regenerator.default.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            // pbkdf1
+            pBuffer = _jsEncodingUtils.default.encoder.stringToArrayBuffer(passphrase);
+            salt = new Uint8Array(decoded.encryptionAlgorithm.parameters.salt);
+            hash = _params.default.passwordBasedEncryptionSchemes[decoded.encryptionAlgorithm.algorithm].hash;
+            iterationCount = decoded.encryptionAlgorithm.parameters.iterationCount.toNumber();
+            _context6.next = 6;
+            return _jsCryptoPbkdf.default.pbkdf1(pBuffer, salt, iterationCount, 16, hash);
+
+          case 6:
+            keyIv = _context6.sent;
+            key = keyIv.slice(0, 8);
+            iv = keyIv.slice(8, 16); // decryption
+
+            encrypt = _params.default.passwordBasedEncryptionSchemes[decoded.encryptionAlgorithm.algorithm].encrypt;
+
+            if (!(encrypt === 'DES-CBC')) {
+              _context6.next = 16;
+              break;
+            }
+
+            CBC = _des.default.CBC.instantiate(_des.default.DES);
+            ct = CBC.create({
+              type: 'decrypt',
+              key: key,
+              iv: iv
+            });
+            out = Buffer.from(ct.update(decoded.encryptedData).concat(ct.final()));
+            _context6.next = 17;
+            break;
+
+          case 16:
+            throw new Error('UnsupportedEncryptionAlgorithm');
+
+          case 17:
+            return _context6.abrupt("return", _asn1def.OneAsymmetricKey.decode(out, 'der'));
+
+          case 18:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+
+  return function decryptPBES1(_x16, _x17) {
+    return _ref6.apply(this, arguments);
+  };
+}();

node_modules/js-crypto-key-utils/dist/thumbprint.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getJwkThumbprint = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _jsCryptoHash = _interopRequireDefault(require("js-crypto-hash"));
+
+var _buffer = _interopRequireDefault(require("buffer"));
+
+/**
+ * thumbprint.js
+ */
+var Buffer = _buffer.default.Buffer;
+/**
+ * Compute JWK public key thumbprint specified in RFC7638
+ * https://tools.ietf.org/html/rfc7638
+ * @param {JsonWebKey} jwkey - A key object in JWK format
+ * @param {String} [alg='SHA-256'] - Name of hash algorithm to compute the thumbprint.
+ * @param {JwkThumbpirntFormat} [output='binary'] - Output format, 'binary', 'hex' or 'base64'
+ * @return {Promise<String|Uint8Array>} - The computed JWK thumbprint.
+ */
+
+var getJwkThumbprint =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee(jwkey) {
+    var alg,
+        output,
+        jsonString,
+        uint8json,
+        thumbPrintBuf,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            alg = _args.length > 1 && _args[1] !== undefined ? _args[1] : 'SHA-256';
+            output = _args.length > 2 && _args[2] !== undefined ? _args[2] : 'binary';
+
+            if (!(['hex', 'binary'].indexOf(output) < 0)) {
+              _context.next = 4;
+              break;
+            }
+
+            throw new Error('UnsupportedOutputFormat');
+
+          case 4:
+            if (!(jwkey.kty === 'EC')) {
+              _context.next = 8;
+              break;
+            }
+
+            jsonString = JSON.stringify({
+              crv: jwkey.crv,
+              kty: jwkey.kty,
+              x: jwkey.x,
+              y: jwkey.y
+            });
+            _context.next = 13;
+            break;
+
+          case 8:
+            if (!(jwkey.kty === 'RSA')) {
+              _context.next = 12;
+              break;
+            }
+
+            jsonString = JSON.stringify({
+              e: jwkey.e,
+              kty: jwkey.kty,
+              n: jwkey.n
+            });
+            _context.next = 13;
+            break;
+
+          case 12:
+            throw new Error('UnsupportedKeyType');
+
+          case 13:
+            uint8json = new Uint8Array(Buffer.from(jsonString, 'utf8'));
+            _context.next = 16;
+            return _jsCryptoHash.default.compute(uint8json, alg);
+
+          case 16:
+            thumbPrintBuf = _context.sent;
+
+            if (!(output === 'hex')) {
+              _context.next = 21;
+              break;
+            }
+
+            return _context.abrupt("return", _jsEncodingUtils.default.encoder.arrayBufferToHexString(thumbPrintBuf));
+
+          case 21:
+            if (!(output === 'base64')) {
+              _context.next = 25;
+              break;
+            }
+
+            return _context.abrupt("return", _jsEncodingUtils.default.encoder.encodeBase64(thumbPrintBuf));
+
+          case 25:
+            if (!(output === 'binary')) {
+              _context.next = 27;
+              break;
+            }
+
+            return _context.abrupt("return", thumbPrintBuf);
+
+          case 27:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getJwkThumbprint(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.getJwkThumbprint = getJwkThumbprint;

node_modules/js-crypto-key-utils/dist/typedef.js

@@ -0,0 +1,56 @@
+/**
+ * @typedef {String} PEM - ASN.1 encoded key in PEM format.
+ */
+
+/**
+ * @typedef {Uint8Array|Buffer} DER - ASN.1 encoded key in DER format.
+ */
+
+/**
+ * @typedef {Uint8Array|Buffer|String} OctetEC - SEC1 Octet form EC key.
+ */
+
+/**
+ * @typedef {Object} KeyExportOptions - Export options for Key Class.
+ * @property {boolean} [outputPublic] - Derive public key from private key if true.
+ * @property {boolean} [compact] - Generate compressed EC public key when format = 'der', 'pem' or 'oct', only for EC key if true.
+ * @property {OctetFormat} [output='binary'] - Active only for OctetEC key. 'binary' or 'string'. Default value would be 'binary'.
+ * @property {AsnEncryptOptionsWithPassphrase} [encryptParams] - Generate encrypted der/pem private key when format = 'der' or 'pem'.
+ */
+
+/**
+ * @typedef {Object} JwkExportOptionsInternal - Options for converters to JWK.
+ * @property {String} [namedCurve] - Name of curve used for EC keys.
+ * @property {boolean} [outputPublic] - Export public key even from private key if true.
+ * @property {String} [passphrase] - Encrypt private key if this is given.
+ */
+
+/**
+ * @typedef {Object} AsnEncryptOptionsWithPassphrase - Encryption options for exported key in key Class.
+ * @property {String} passphrase - (Re-)generate encrypted der/pem with the given passphrase
+ * @property {String} [algorithm='pbes2'] - 'pbes2' (default), 'pbeWithMD5AndDES-CBC' or 'pbeWithSHA1AndDES'
+ * @property {String} [prf='hmacWithSHA256] - 'hmacWithSHA256' (default), 'hmacWithSHA384', 'hmacWithSHA512' or 'hmacWithSHA1' when if algorithm = 'pbes2'.
+ * @property {Number} [iterationCount = 2048] - Iteration count for PBKDF 1/2.
+ * @property {String} [cipher='aes256-cbc'] - 'aes256-cbc' (default), 'aes128-cbc' or 'des-ede3-cbc'.
+ */
+
+/**
+ * @typedef {Entity} AsnObject - asn1.js Entity object.
+ */
+
+/**
+ * @typedef {'pem'|'der'} AsnFormat - Key format of ASN.1 encoded key object.
+ */
+
+/**
+ * @typedef {'string'|'binary'} OctetFormat - Representation of SEC1 Octet EC key.
+ */
+
+/**
+ * @typedef {'public'|'private'} PublicOrPrivate - Key type of public or private.
+ */
+
+/**
+ * @typedef {'binary'|'hex'|'base64'} JwkThumbpirntFormat - Representation of JWK thumbprint.
+ */
+"use strict";

node_modules/js-crypto-key-utils/dist/util.js

@@ -0,0 +1,161 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appendLeadingZeros = exports.pruneLeadingZeros = exports.getJwkType = exports.getSec1KeyType = exports.getAsn1KeyType = exports.isAsn1Public = exports.isAsn1Encrypted = void 0;
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _params = _interopRequireDefault(require("./params.js"));
+
+var _asn1def = require("./asn1def.js");
+
+/**
+ * util.js
+ */
+
+/**
+ * Check if the given key is encrypted.
+ * @param {DER|PEM} key - Private key object in ASN.1 encoding.
+ * @param {AsnFormat} [format='pem'] - pem or der
+ * @return {boolean} - True if encrypted.
+ */
+var isAsn1Encrypted = function isAsn1Encrypted(key) {
+  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'pem';
+  var keyType;
+
+  try {
+    keyType = getAsn1KeyType(key, format);
+  } catch (e) {
+    return false;
+  }
+
+  return keyType === 'encryptedPrivate';
+};
+/**
+ * Check if the given key is public.
+ * @param {DER|PEM} key - Public key object in ASN.1 encoding.
+ * @param {AsnFormat} format - pem or der
+ * @return {boolean} - True if public.
+ */
+
+
+exports.isAsn1Encrypted = isAsn1Encrypted;
+
+var isAsn1Public = function isAsn1Public(key) {
+  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'pem';
+  var keyType;
+
+  try {
+    keyType = getAsn1KeyType(key, format);
+  } catch (e) {
+    return false;
+  }
+
+  return keyType === 'public';
+};
+/**
+ * Retrieve the key type of public or private in ASN.1 format
+ * @param {DER|PEM} key - Key object in ASN.1 encoding.
+ * @param {AsnFormat} format - pem or der
+ * @return {'public'|'private'|'encryptedPrivate'} - The key type of the given key.
+ * @throws {Error} - Throws if NotSpkiNorPkcs8Key.
+ */
+
+
+exports.isAsn1Public = isAsn1Public;
+
+var getAsn1KeyType = function getAsn1KeyType(key) {
+  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'pem';
+  // Peel the pem strings
+  var binKey = format === 'pem' ? _jsEncodingUtils.default.formatter.pemToBin(key, 'private') : key;
+
+  var decoded = _asn1def.KeyStructure.decode(Buffer.from(binKey), 'der');
+
+  if (decoded.type === 'encryptedPrivateKeyInfo') return 'encryptedPrivate';else if (decoded.type === 'oneAsymmetricKey') return 'private';else if (decoded.type === 'subjectPublicKeyInfo') return 'public';else throw new Error('NotSpkiNorPkcs8Key');
+};
+/**
+ * Retrieve the type of SEC1 octet key.
+ * @param {OctetEC} sec1key - Key object in OctetEC encoding in String (hex string) or Uint8Array.
+ * @param {String} namedCurve - Name of elliptic curve like 'P-256'.
+ * @return {PublicOrPrivate} - public or private
+ * @throws {Error} - Throws if UnsupportedKeyStructure.
+ */
+
+
+exports.getAsn1KeyType = getAsn1KeyType;
+
+var getSec1KeyType = function getSec1KeyType(sec1key, namedCurve) {
+  var format;
+  if (sec1key instanceof Uint8Array) format = 'binary';else if (typeof sec1key === 'string') format = 'string';else throw new Error('InvalidObjectType');
+  var binKey = format === 'string' ? _jsEncodingUtils.default.encoder.hexStringToArrayBuffer(sec1key) : sec1key;
+  var len = _params.default.namedCurves[namedCurve].payloadSize; // original key type
+
+  if (binKey.length <= len) return 'private';else if (binKey.length === 2 * len + 1 && binKey[0] === 0x04 || binKey.length === len + 1 && (binKey[0] === 0x02 || binKey[0] === 0x03)) return 'public';else throw new Error('UnsupportedKeyStructure');
+};
+/**
+ * Check key type of JWK.
+ * @param {JsonWebKey} jwkey - Key object in JWK format.
+ * @return {PublicOrPrivate} - public or private
+ * @throws {Error} - Throws if InvalidECKey, InvalidRSAKey or UnsupportedJWKType.
+ */
+
+
+exports.getSec1KeyType = getSec1KeyType;
+
+var getJwkType = function getJwkType(jwkey) {
+  if (jwkey.kty === 'EC') {
+    if (jwkey.x && jwkey.y && jwkey.d) return 'private';else if (jwkey.x && jwkey.y) return 'public';else throw new Error('InvalidECKey');
+  } else if (jwkey.kty === 'RSA') {
+    if (jwkey.n && jwkey.e && jwkey.d && jwkey.p && jwkey.q && jwkey.dp && jwkey.dq && jwkey.qi) return 'private';else if (jwkey.n && jwkey.e) return 'public';else throw new Error('InvalidRSAKey');
+  } else throw new Error('UnsupportedJWKType');
+};
+/**
+ * Prune leading zeros of an octet sequence in Uint8Array for jwk formatting of RSA.
+ * https://tools.ietf.org/html/rfc7518#section-6.3
+ * @param {Uint8Array} array - The octet sequence.
+ * @return {Uint8Array} - An octet sequence pruned leading zeros of length equal to or shorter than the input array.
+ * @throws {Error} - Throws if NonUint8Array.
+ */
+
+
+exports.getJwkType = getJwkType;
+
+var pruneLeadingZeros = function pruneLeadingZeros(array) {
+  if (!(array instanceof Uint8Array)) throw new Error('NonUint8Array');
+  var offset = 0;
+
+  for (var i = 0; i < array.length; i++) {
+    if (array[i] !== 0x00) break;
+    offset++;
+  }
+
+  var returnArray = new Uint8Array(array.length - offset);
+  returnArray.set(array.slice(offset, array.length));
+  return returnArray;
+}; // for pem/oct/der formatting from jwk of RSA
+
+/**
+ * Append leading zeros and generate an octet sequence of fixed length.
+ * @param {Uint8Array} array - An octet sequence.
+ * @param {Number} len - Intended length of output sequence.
+ * @returns {Uint8Array} - An octet sequence with leading zeros.
+ * @throws {Error} - Throws if NonUint8Array or InvalidLength.
+ */
+
+
+exports.pruneLeadingZeros = pruneLeadingZeros;
+
+var appendLeadingZeros = function appendLeadingZeros(array, len) {
+  if (!(array instanceof Uint8Array)) throw new Error('NonUint8Array');
+  if (array.length > len) throw new Error('InvalidLength');
+  var returnArray = new Uint8Array(len); // initialized with zeros
+
+  returnArray.set(array, len - array.length);
+  return returnArray;
+};
+
+exports.appendLeadingZeros = appendLeadingZeros;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+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.

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/README.md

@@ -0,0 +1,19 @@
+# @babel/runtime
+
+> babel's modular runtime helpers
+
+See our website [@babel/runtime](https://babeljs.io/docs/en/next/babel-runtime.html) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/runtime
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/runtime 
+```

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/AsyncGenerator.js

@@ -0,0 +1,100 @@
+var AwaitValue = require("./AwaitValue");
+
+function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume("next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen["return"] !== "function") {
+    this["return"] = undefined;
+  }
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype["throw"] = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype["return"] = function (arg) {
+  return this._invoke("return", arg);
+};
+
+module.exports = AsyncGenerator;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/AwaitValue.js

@@ -0,0 +1,5 @@
+function _AwaitValue(value) {
+  this.wrapped = value;
+}
+
+module.exports = _AwaitValue;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js

@@ -0,0 +1,30 @@
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}
+
+module.exports = _applyDecoratedDescriptor;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/arrayWithHoles.js

@@ -0,0 +1,5 @@
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js

@@ -0,0 +1,11 @@
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
+
+module.exports = _arrayWithoutHoles;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/assertThisInitialized.js

@@ -0,0 +1,9 @@
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+module.exports = _assertThisInitialized;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js

@@ -0,0 +1,53 @@
+function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner["throw"] === "function") {
+    iter["throw"] = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner["return"] === "function") {
+    iter["return"] = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}
+
+module.exports = _asyncGeneratorDelegate;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/asyncIterator.js

@@ -0,0 +1,19 @@
+function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof Symbol !== "undefined") {
+    if (Symbol.asyncIterator) {
+      method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      method = iterable[Symbol.iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+module.exports = _asyncIterator;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/asyncToGenerator.js

@@ -0,0 +1,37 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+module.exports = _asyncToGenerator;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js

@@ -0,0 +1,7 @@
+var AwaitValue = require("./AwaitValue");
+
+function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}
+
+module.exports = _awaitAsyncGenerator;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classCallCheck.js

@@ -0,0 +1,7 @@
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+module.exports = _classCallCheck;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classNameTDZError.js

@@ -0,0 +1,5 @@
+function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+
+module.exports = _classNameTDZError;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js

@@ -0,0 +1,28 @@
+function _classPrivateFieldDestructureSet(receiver, privateMap) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  var descriptor = privateMap.get(receiver);
+
+  if (descriptor.set) {
+    if (!("__destrObj" in descriptor)) {
+      descriptor.__destrObj = {
+        set value(v) {
+          descriptor.set.call(receiver, v);
+        }
+
+      };
+    }
+
+    return descriptor.__destrObj;
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    return descriptor;
+  }
+}
+
+module.exports = _classPrivateFieldDestructureSet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js

@@ -0,0 +1,15 @@
+function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}
+
+module.exports = _classPrivateFieldGet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js

@@ -0,0 +1,9 @@
+function _classPrivateFieldBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+
+  return receiver;
+}
+
+module.exports = _classPrivateFieldBase;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js

@@ -0,0 +1,7 @@
+var id = 0;
+
+function _classPrivateFieldKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+
+module.exports = _classPrivateFieldKey;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js

@@ -0,0 +1,21 @@
+function _classPrivateFieldSet(receiver, privateMap, value) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+
+  return value;
+}
+
+module.exports = _classPrivateFieldSet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js

@@ -0,0 +1,9 @@
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}
+
+module.exports = _classPrivateMethodGet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js

@@ -0,0 +1,5 @@
+function _classPrivateMethodSet() {
+  throw new TypeError("attempted to reassign private method");
+}
+
+module.exports = _classPrivateMethodSet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js

@@ -0,0 +1,9 @@
+function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  return descriptor.value;
+}
+
+module.exports = _classStaticPrivateFieldSpecGet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js

@@ -0,0 +1,14 @@
+function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  if (!descriptor.writable) {
+    throw new TypeError("attempted to set read only private field");
+  }
+
+  descriptor.value = value;
+  return value;
+}
+
+module.exports = _classStaticPrivateFieldSpecSet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js

@@ -0,0 +1,9 @@
+function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  return method;
+}
+
+module.exports = _classStaticPrivateMethodGet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js

@@ -0,0 +1,5 @@
+function _classStaticPrivateMethodSet() {
+  throw new TypeError("attempted to set read only static private field");
+}
+
+module.exports = _classStaticPrivateMethodSet;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/construct.js

@@ -0,0 +1,33 @@
+var setPrototypeOf = require("./setPrototypeOf");
+
+function isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (isNativeReflectConstruct()) {
+    module.exports = _construct = Reflect.construct;
+  } else {
+    module.exports = _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+module.exports = _construct;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/createClass.js

@@ -0,0 +1,17 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+module.exports = _createClass;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/decorate.js

@@ -0,0 +1,400 @@
+var toArray = require("./toArray");
+
+var toPropertyKey = require("./toPropertyKey");
+
+function _decorate(decorators, factory, superClass, mixins) {
+  var api = _getDecoratorsApi();
+
+  if (mixins) {
+    for (var i = 0; i < mixins.length; i++) {
+      api = mixins[i](api);
+    }
+  }
+
+  var r = factory(function initialize(O) {
+    api.initializeInstanceElements(O, decorated.elements);
+  }, superClass);
+  var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
+  api.initializeClassElements(r.F, decorated.elements);
+  return api.runClassFinishers(r.F, decorated.finishers);
+}
+
+function _getDecoratorsApi() {
+  _getDecoratorsApi = function _getDecoratorsApi() {
+    return api;
+  };
+
+  var api = {
+    elementsDefinitionOrder: [["method"], ["field"]],
+    initializeInstanceElements: function initializeInstanceElements(O, elements) {
+      ["method", "field"].forEach(function (kind) {
+        elements.forEach(function (element) {
+          if (element.kind === kind && element.placement === "own") {
+            this.defineClassElement(O, element);
+          }
+        }, this);
+      }, this);
+    },
+    initializeClassElements: function initializeClassElements(F, elements) {
+      var proto = F.prototype;
+      ["method", "field"].forEach(function (kind) {
+        elements.forEach(function (element) {
+          var placement = element.placement;
+
+          if (element.kind === kind && (placement === "static" || placement === "prototype")) {
+            var receiver = placement === "static" ? F : proto;
+            this.defineClassElement(receiver, element);
+          }
+        }, this);
+      }, this);
+    },
+    defineClassElement: function defineClassElement(receiver, element) {
+      var descriptor = element.descriptor;
+
+      if (element.kind === "field") {
+        var initializer = element.initializer;
+        descriptor = {
+          enumerable: descriptor.enumerable,
+          writable: descriptor.writable,
+          configurable: descriptor.configurable,
+          value: initializer === void 0 ? void 0 : initializer.call(receiver)
+        };
+      }
+
+      Object.defineProperty(receiver, element.key, descriptor);
+    },
+    decorateClass: function decorateClass(elements, decorators) {
+      var newElements = [];
+      var finishers = [];
+      var placements = {
+        "static": [],
+        prototype: [],
+        own: []
+      };
+      elements.forEach(function (element) {
+        this.addElementPlacement(element, placements);
+      }, this);
+      elements.forEach(function (element) {
+        if (!_hasDecorators(element)) return newElements.push(element);
+        var elementFinishersExtras = this.decorateElement(element, placements);
+        newElements.push(elementFinishersExtras.element);
+        newElements.push.apply(newElements, elementFinishersExtras.extras);
+        finishers.push.apply(finishers, elementFinishersExtras.finishers);
+      }, this);
+
+      if (!decorators) {
+        return {
+          elements: newElements,
+          finishers: finishers
+        };
+      }
+
+      var result = this.decorateConstructor(newElements, decorators);
+      finishers.push.apply(finishers, result.finishers);
+      result.finishers = finishers;
+      return result;
+    },
+    addElementPlacement: function addElementPlacement(element, placements, silent) {
+      var keys = placements[element.placement];
+
+      if (!silent && keys.indexOf(element.key) !== -1) {
+        throw new TypeError("Duplicated element (" + element.key + ")");
+      }
+
+      keys.push(element.key);
+    },
+    decorateElement: function decorateElement(element, placements) {
+      var extras = [];
+      var finishers = [];
+
+      for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
+        var keys = placements[element.placement];
+        keys.splice(keys.indexOf(element.key), 1);
+        var elementObject = this.fromElementDescriptor(element);
+        var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
+        element = elementFinisherExtras.element;
+        this.addElementPlacement(element, placements);
+
+        if (elementFinisherExtras.finisher) {
+          finishers.push(elementFinisherExtras.finisher);
+        }
+
+        var newExtras = elementFinisherExtras.extras;
+
+        if (newExtras) {
+          for (var j = 0; j < newExtras.length; j++) {
+            this.addElementPlacement(newExtras[j], placements);
+          }
+
+          extras.push.apply(extras, newExtras);
+        }
+      }
+
+      return {
+        element: element,
+        finishers: finishers,
+        extras: extras
+      };
+    },
+    decorateConstructor: function decorateConstructor(elements, decorators) {
+      var finishers = [];
+
+      for (var i = decorators.length - 1; i >= 0; i--) {
+        var obj = this.fromClassDescriptor(elements);
+        var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj);
+
+        if (elementsAndFinisher.finisher !== undefined) {
+          finishers.push(elementsAndFinisher.finisher);
+        }
+
+        if (elementsAndFinisher.elements !== undefined) {
+          elements = elementsAndFinisher.elements;
+
+          for (var j = 0; j < elements.length - 1; j++) {
+            for (var k = j + 1; k < elements.length; k++) {
+              if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {
+                throw new TypeError("Duplicated element (" + elements[j].key + ")");
+              }
+            }
+          }
+        }
+      }
+
+      return {
+        elements: elements,
+        finishers: finishers
+      };
+    },
+    fromElementDescriptor: function fromElementDescriptor(element) {
+      var obj = {
+        kind: element.kind,
+        key: element.key,
+        placement: element.placement,
+        descriptor: element.descriptor
+      };
+      var desc = {
+        value: "Descriptor",
+        configurable: true
+      };
+      Object.defineProperty(obj, Symbol.toStringTag, desc);
+      if (element.kind === "field") obj.initializer = element.initializer;
+      return obj;
+    },
+    toElementDescriptors: function toElementDescriptors(elementObjects) {
+      if (elementObjects === undefined) return;
+      return toArray(elementObjects).map(function (elementObject) {
+        var element = this.toElementDescriptor(elementObject);
+        this.disallowProperty(elementObject, "finisher", "An element descriptor");
+        this.disallowProperty(elementObject, "extras", "An element descriptor");
+        return element;
+      }, this);
+    },
+    toElementDescriptor: function toElementDescriptor(elementObject) {
+      var kind = String(elementObject.kind);
+
+      if (kind !== "method" && kind !== "field") {
+        throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"');
+      }
+
+      var key = toPropertyKey(elementObject.key);
+      var placement = String(elementObject.placement);
+
+      if (placement !== "static" && placement !== "prototype" && placement !== "own") {
+        throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"');
+      }
+
+      var descriptor = elementObject.descriptor;
+      this.disallowProperty(elementObject, "elements", "An element descriptor");
+      var element = {
+        kind: kind,
+        key: key,
+        placement: placement,
+        descriptor: Object.assign({}, descriptor)
+      };
+
+      if (kind !== "field") {
+        this.disallowProperty(elementObject, "initializer", "A method descriptor");
+      } else {
+        this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
+        this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
+        this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
+        element.initializer = elementObject.initializer;
+      }
+
+      return element;
+    },
+    toElementFinisherExtras: function toElementFinisherExtras(elementObject) {
+      var element = this.toElementDescriptor(elementObject);
+
+      var finisher = _optionalCallableProperty(elementObject, "finisher");
+
+      var extras = this.toElementDescriptors(elementObject.extras);
+      return {
+        element: element,
+        finisher: finisher,
+        extras: extras
+      };
+    },
+    fromClassDescriptor: function fromClassDescriptor(elements) {
+      var obj = {
+        kind: "class",
+        elements: elements.map(this.fromElementDescriptor, this)
+      };
+      var desc = {
+        value: "Descriptor",
+        configurable: true
+      };
+      Object.defineProperty(obj, Symbol.toStringTag, desc);
+      return obj;
+    },
+    toClassDescriptor: function toClassDescriptor(obj) {
+      var kind = String(obj.kind);
+
+      if (kind !== "class") {
+        throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"');
+      }
+
+      this.disallowProperty(obj, "key", "A class descriptor");
+      this.disallowProperty(obj, "placement", "A class descriptor");
+      this.disallowProperty(obj, "descriptor", "A class descriptor");
+      this.disallowProperty(obj, "initializer", "A class descriptor");
+      this.disallowProperty(obj, "extras", "A class descriptor");
+
+      var finisher = _optionalCallableProperty(obj, "finisher");
+
+      var elements = this.toElementDescriptors(obj.elements);
+      return {
+        elements: elements,
+        finisher: finisher
+      };
+    },
+    runClassFinishers: function runClassFinishers(constructor, finishers) {
+      for (var i = 0; i < finishers.length; i++) {
+        var newConstructor = (0, finishers[i])(constructor);
+
+        if (newConstructor !== undefined) {
+          if (typeof newConstructor !== "function") {
+            throw new TypeError("Finishers must return a constructor.");
+          }
+
+          constructor = newConstructor;
+        }
+      }
+
+      return constructor;
+    },
+    disallowProperty: function disallowProperty(obj, name, objectType) {
+      if (obj[name] !== undefined) {
+        throw new TypeError(objectType + " can't have a ." + name + " property.");
+      }
+    }
+  };
+  return api;
+}
+
+function _createElementDescriptor(def) {
+  var key = toPropertyKey(def.key);
+  var descriptor;
+
+  if (def.kind === "method") {
+    descriptor = {
+      value: def.value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "get") {
+    descriptor = {
+      get: def.value,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "set") {
+    descriptor = {
+      set: def.value,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "field") {
+    descriptor = {
+      configurable: true,
+      writable: true,
+      enumerable: true
+    };
+  }
+
+  var element = {
+    kind: def.kind === "field" ? "field" : "method",
+    key: key,
+    placement: def["static"] ? "static" : def.kind === "field" ? "own" : "prototype",
+    descriptor: descriptor
+  };
+  if (def.decorators) element.decorators = def.decorators;
+  if (def.kind === "field") element.initializer = def.value;
+  return element;
+}
+
+function _coalesceGetterSetter(element, other) {
+  if (element.descriptor.get !== undefined) {
+    other.descriptor.get = element.descriptor.get;
+  } else {
+    other.descriptor.set = element.descriptor.set;
+  }
+}
+
+function _coalesceClassElements(elements) {
+  var newElements = [];
+
+  var isSameElement = function isSameElement(other) {
+    return other.kind === "method" && other.key === element.key && other.placement === element.placement;
+  };
+
+  for (var i = 0; i < elements.length; i++) {
+    var element = elements[i];
+    var other;
+
+    if (element.kind === "method" && (other = newElements.find(isSameElement))) {
+      if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
+        if (_hasDecorators(element) || _hasDecorators(other)) {
+          throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated.");
+        }
+
+        other.descriptor = element.descriptor;
+      } else {
+        if (_hasDecorators(element)) {
+          if (_hasDecorators(other)) {
+            throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ").");
+          }
+
+          other.decorators = element.decorators;
+        }
+
+        _coalesceGetterSetter(element, other);
+      }
+    } else {
+      newElements.push(element);
+    }
+  }
+
+  return newElements;
+}
+
+function _hasDecorators(element) {
+  return element.decorators && element.decorators.length;
+}
+
+function _isDataDescriptor(desc) {
+  return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
+}
+
+function _optionalCallableProperty(obj, name) {
+  var value = obj[name];
+
+  if (value !== undefined && typeof value !== "function") {
+    throw new TypeError("Expected '" + name + "' to be a function");
+  }
+
+  return value;
+}
+
+module.exports = _decorate;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/defaults.js

@@ -0,0 +1,16 @@
+function _defaults(obj, defaults) {
+  var keys = Object.getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defaults;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js

@@ -0,0 +1,24 @@
+function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+    Object.defineProperty(obj, key, desc);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defineEnumerableProperties;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/defineProperty.js

@@ -0,0 +1,16 @@
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+module.exports = _defineProperty;

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js

@@ -0,0 +1,97 @@
+import AwaitValue from "./AwaitValue";
+export default function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume("next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen["return"] !== "function") {
+    this["return"] = undefined;
+  }
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype["throw"] = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype["return"] = function (arg) {
+  return this._invoke("return", arg);
+};

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/AwaitValue.js

@@ -0,0 +1,3 @@
+export default function _AwaitValue(value) {
+  this.wrapped = value;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js

@@ -0,0 +1,28 @@
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js

@@ -0,0 +1,3 @@
+export default function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

@@ -0,0 +1,9 @@
+export default function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js

@@ -0,0 +1,7 @@
+export default function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js

@@ -0,0 +1,51 @@
+export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner["throw"] === "function") {
+    iter["throw"] = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner["return"] === "function") {
+    iter["return"] = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/asyncIterator.js

@@ -0,0 +1,17 @@
+export default function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof Symbol !== "undefined") {
+    if (Symbol.asyncIterator) {
+      method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      method = iterable[Symbol.iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js

@@ -0,0 +1,35 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+export default function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js

@@ -0,0 +1,4 @@
+import AwaitValue from "./AwaitValue";
+export default function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classCallCheck.js

@@ -0,0 +1,5 @@
+export default function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js

@@ -0,0 +1,3 @@
+export default function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js

@@ -0,0 +1,26 @@
+export default function _classPrivateFieldDestructureSet(receiver, privateMap) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  var descriptor = privateMap.get(receiver);
+
+  if (descriptor.set) {
+    if (!("__destrObj" in descriptor)) {
+      descriptor.__destrObj = {
+        set value(v) {
+          descriptor.set.call(receiver, v);
+        }
+
+      };
+    }
+
+    return descriptor.__destrObj;
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    return descriptor;
+  }
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js

@@ -0,0 +1,13 @@
+export default function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js

@@ -0,0 +1,7 @@
+export default function _classPrivateFieldBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+
+  return receiver;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js

@@ -0,0 +1,4 @@
+var id = 0;
+export default function _classPrivateFieldKey(name) {
+  return "__private_" + id++ + "_" + name;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js

@@ -0,0 +1,19 @@
+export default function _classPrivateFieldSet(receiver, privateMap, value) {
+  var descriptor = privateMap.get(receiver);
+
+  if (!descriptor) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+
+  return value;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js

@@ -0,0 +1,7 @@
+export default function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js

@@ -0,0 +1,3 @@
+export default function _classPrivateMethodSet() {
+  throw new TypeError("attempted to reassign private method");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js

@@ -0,0 +1,7 @@
+export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  return descriptor.value;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js

@@ -0,0 +1,12 @@
+export default function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  if (!descriptor.writable) {
+    throw new TypeError("attempted to set read only private field");
+  }
+
+  descriptor.value = value;
+  return value;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js

@@ -0,0 +1,7 @@
+export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+  if (receiver !== classConstructor) {
+    throw new TypeError("Private static access of wrong provenance");
+  }
+
+  return method;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js

@@ -0,0 +1,3 @@
+export default function _classStaticPrivateMethodSet() {
+  throw new TypeError("attempted to set read only static private field");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/construct.js

@@ -0,0 +1,31 @@
+import setPrototypeOf from "./setPrototypeOf";
+
+function isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export default function _construct(Parent, args, Class) {
+  if (isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/createClass.js

@@ -0,0 +1,15 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+export default function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/decorate.js

@@ -0,0 +1,396 @@
+import toArray from "./toArray";
+import toPropertyKey from "./toPropertyKey";
+export default function _decorate(decorators, factory, superClass, mixins) {
+  var api = _getDecoratorsApi();
+
+  if (mixins) {
+    for (var i = 0; i < mixins.length; i++) {
+      api = mixins[i](api);
+    }
+  }
+
+  var r = factory(function initialize(O) {
+    api.initializeInstanceElements(O, decorated.elements);
+  }, superClass);
+  var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
+  api.initializeClassElements(r.F, decorated.elements);
+  return api.runClassFinishers(r.F, decorated.finishers);
+}
+
+function _getDecoratorsApi() {
+  _getDecoratorsApi = function _getDecoratorsApi() {
+    return api;
+  };
+
+  var api = {
+    elementsDefinitionOrder: [["method"], ["field"]],
+    initializeInstanceElements: function initializeInstanceElements(O, elements) {
+      ["method", "field"].forEach(function (kind) {
+        elements.forEach(function (element) {
+          if (element.kind === kind && element.placement === "own") {
+            this.defineClassElement(O, element);
+          }
+        }, this);
+      }, this);
+    },
+    initializeClassElements: function initializeClassElements(F, elements) {
+      var proto = F.prototype;
+      ["method", "field"].forEach(function (kind) {
+        elements.forEach(function (element) {
+          var placement = element.placement;
+
+          if (element.kind === kind && (placement === "static" || placement === "prototype")) {
+            var receiver = placement === "static" ? F : proto;
+            this.defineClassElement(receiver, element);
+          }
+        }, this);
+      }, this);
+    },
+    defineClassElement: function defineClassElement(receiver, element) {
+      var descriptor = element.descriptor;
+
+      if (element.kind === "field") {
+        var initializer = element.initializer;
+        descriptor = {
+          enumerable: descriptor.enumerable,
+          writable: descriptor.writable,
+          configurable: descriptor.configurable,
+          value: initializer === void 0 ? void 0 : initializer.call(receiver)
+        };
+      }
+
+      Object.defineProperty(receiver, element.key, descriptor);
+    },
+    decorateClass: function decorateClass(elements, decorators) {
+      var newElements = [];
+      var finishers = [];
+      var placements = {
+        "static": [],
+        prototype: [],
+        own: []
+      };
+      elements.forEach(function (element) {
+        this.addElementPlacement(element, placements);
+      }, this);
+      elements.forEach(function (element) {
+        if (!_hasDecorators(element)) return newElements.push(element);
+        var elementFinishersExtras = this.decorateElement(element, placements);
+        newElements.push(elementFinishersExtras.element);
+        newElements.push.apply(newElements, elementFinishersExtras.extras);
+        finishers.push.apply(finishers, elementFinishersExtras.finishers);
+      }, this);
+
+      if (!decorators) {
+        return {
+          elements: newElements,
+          finishers: finishers
+        };
+      }
+
+      var result = this.decorateConstructor(newElements, decorators);
+      finishers.push.apply(finishers, result.finishers);
+      result.finishers = finishers;
+      return result;
+    },
+    addElementPlacement: function addElementPlacement(element, placements, silent) {
+      var keys = placements[element.placement];
+
+      if (!silent && keys.indexOf(element.key) !== -1) {
+        throw new TypeError("Duplicated element (" + element.key + ")");
+      }
+
+      keys.push(element.key);
+    },
+    decorateElement: function decorateElement(element, placements) {
+      var extras = [];
+      var finishers = [];
+
+      for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
+        var keys = placements[element.placement];
+        keys.splice(keys.indexOf(element.key), 1);
+        var elementObject = this.fromElementDescriptor(element);
+        var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
+        element = elementFinisherExtras.element;
+        this.addElementPlacement(element, placements);
+
+        if (elementFinisherExtras.finisher) {
+          finishers.push(elementFinisherExtras.finisher);
+        }
+
+        var newExtras = elementFinisherExtras.extras;
+
+        if (newExtras) {
+          for (var j = 0; j < newExtras.length; j++) {
+            this.addElementPlacement(newExtras[j], placements);
+          }
+
+          extras.push.apply(extras, newExtras);
+        }
+      }
+
+      return {
+        element: element,
+        finishers: finishers,
+        extras: extras
+      };
+    },
+    decorateConstructor: function decorateConstructor(elements, decorators) {
+      var finishers = [];
+
+      for (var i = decorators.length - 1; i >= 0; i--) {
+        var obj = this.fromClassDescriptor(elements);
+        var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj);
+
+        if (elementsAndFinisher.finisher !== undefined) {
+          finishers.push(elementsAndFinisher.finisher);
+        }
+
+        if (elementsAndFinisher.elements !== undefined) {
+          elements = elementsAndFinisher.elements;
+
+          for (var j = 0; j < elements.length - 1; j++) {
+            for (var k = j + 1; k < elements.length; k++) {
+              if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {
+                throw new TypeError("Duplicated element (" + elements[j].key + ")");
+              }
+            }
+          }
+        }
+      }
+
+      return {
+        elements: elements,
+        finishers: finishers
+      };
+    },
+    fromElementDescriptor: function fromElementDescriptor(element) {
+      var obj = {
+        kind: element.kind,
+        key: element.key,
+        placement: element.placement,
+        descriptor: element.descriptor
+      };
+      var desc = {
+        value: "Descriptor",
+        configurable: true
+      };
+      Object.defineProperty(obj, Symbol.toStringTag, desc);
+      if (element.kind === "field") obj.initializer = element.initializer;
+      return obj;
+    },
+    toElementDescriptors: function toElementDescriptors(elementObjects) {
+      if (elementObjects === undefined) return;
+      return toArray(elementObjects).map(function (elementObject) {
+        var element = this.toElementDescriptor(elementObject);
+        this.disallowProperty(elementObject, "finisher", "An element descriptor");
+        this.disallowProperty(elementObject, "extras", "An element descriptor");
+        return element;
+      }, this);
+    },
+    toElementDescriptor: function toElementDescriptor(elementObject) {
+      var kind = String(elementObject.kind);
+
+      if (kind !== "method" && kind !== "field") {
+        throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"');
+      }
+
+      var key = toPropertyKey(elementObject.key);
+      var placement = String(elementObject.placement);
+
+      if (placement !== "static" && placement !== "prototype" && placement !== "own") {
+        throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"');
+      }
+
+      var descriptor = elementObject.descriptor;
+      this.disallowProperty(elementObject, "elements", "An element descriptor");
+      var element = {
+        kind: kind,
+        key: key,
+        placement: placement,
+        descriptor: Object.assign({}, descriptor)
+      };
+
+      if (kind !== "field") {
+        this.disallowProperty(elementObject, "initializer", "A method descriptor");
+      } else {
+        this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
+        this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
+        this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
+        element.initializer = elementObject.initializer;
+      }
+
+      return element;
+    },
+    toElementFinisherExtras: function toElementFinisherExtras(elementObject) {
+      var element = this.toElementDescriptor(elementObject);
+
+      var finisher = _optionalCallableProperty(elementObject, "finisher");
+
+      var extras = this.toElementDescriptors(elementObject.extras);
+      return {
+        element: element,
+        finisher: finisher,
+        extras: extras
+      };
+    },
+    fromClassDescriptor: function fromClassDescriptor(elements) {
+      var obj = {
+        kind: "class",
+        elements: elements.map(this.fromElementDescriptor, this)
+      };
+      var desc = {
+        value: "Descriptor",
+        configurable: true
+      };
+      Object.defineProperty(obj, Symbol.toStringTag, desc);
+      return obj;
+    },
+    toClassDescriptor: function toClassDescriptor(obj) {
+      var kind = String(obj.kind);
+
+      if (kind !== "class") {
+        throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"');
+      }
+
+      this.disallowProperty(obj, "key", "A class descriptor");
+      this.disallowProperty(obj, "placement", "A class descriptor");
+      this.disallowProperty(obj, "descriptor", "A class descriptor");
+      this.disallowProperty(obj, "initializer", "A class descriptor");
+      this.disallowProperty(obj, "extras", "A class descriptor");
+
+      var finisher = _optionalCallableProperty(obj, "finisher");
+
+      var elements = this.toElementDescriptors(obj.elements);
+      return {
+        elements: elements,
+        finisher: finisher
+      };
+    },
+    runClassFinishers: function runClassFinishers(constructor, finishers) {
+      for (var i = 0; i < finishers.length; i++) {
+        var newConstructor = (0, finishers[i])(constructor);
+
+        if (newConstructor !== undefined) {
+          if (typeof newConstructor !== "function") {
+            throw new TypeError("Finishers must return a constructor.");
+          }
+
+          constructor = newConstructor;
+        }
+      }
+
+      return constructor;
+    },
+    disallowProperty: function disallowProperty(obj, name, objectType) {
+      if (obj[name] !== undefined) {
+        throw new TypeError(objectType + " can't have a ." + name + " property.");
+      }
+    }
+  };
+  return api;
+}
+
+function _createElementDescriptor(def) {
+  var key = toPropertyKey(def.key);
+  var descriptor;
+
+  if (def.kind === "method") {
+    descriptor = {
+      value: def.value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "get") {
+    descriptor = {
+      get: def.value,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "set") {
+    descriptor = {
+      set: def.value,
+      configurable: true,
+      enumerable: false
+    };
+  } else if (def.kind === "field") {
+    descriptor = {
+      configurable: true,
+      writable: true,
+      enumerable: true
+    };
+  }
+
+  var element = {
+    kind: def.kind === "field" ? "field" : "method",
+    key: key,
+    placement: def["static"] ? "static" : def.kind === "field" ? "own" : "prototype",
+    descriptor: descriptor
+  };
+  if (def.decorators) element.decorators = def.decorators;
+  if (def.kind === "field") element.initializer = def.value;
+  return element;
+}
+
+function _coalesceGetterSetter(element, other) {
+  if (element.descriptor.get !== undefined) {
+    other.descriptor.get = element.descriptor.get;
+  } else {
+    other.descriptor.set = element.descriptor.set;
+  }
+}
+
+function _coalesceClassElements(elements) {
+  var newElements = [];
+
+  var isSameElement = function isSameElement(other) {
+    return other.kind === "method" && other.key === element.key && other.placement === element.placement;
+  };
+
+  for (var i = 0; i < elements.length; i++) {
+    var element = elements[i];
+    var other;
+
+    if (element.kind === "method" && (other = newElements.find(isSameElement))) {
+      if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
+        if (_hasDecorators(element) || _hasDecorators(other)) {
+          throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated.");
+        }
+
+        other.descriptor = element.descriptor;
+      } else {
+        if (_hasDecorators(element)) {
+          if (_hasDecorators(other)) {
+            throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ").");
+          }
+
+          other.decorators = element.decorators;
+        }
+
+        _coalesceGetterSetter(element, other);
+      }
+    } else {
+      newElements.push(element);
+    }
+  }
+
+  return newElements;
+}
+
+function _hasDecorators(element) {
+  return element.decorators && element.decorators.length;
+}
+
+function _isDataDescriptor(desc) {
+  return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
+}
+
+function _optionalCallableProperty(obj, name) {
+  var value = obj[name];
+
+  if (value !== undefined && typeof value !== "function") {
+    throw new TypeError("Expected '" + name + "' to be a function");
+  }
+
+  return value;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/defaults.js

@@ -0,0 +1,14 @@
+export default function _defaults(obj, defaults) {
+  var keys = Object.getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js

@@ -0,0 +1,22 @@
+export default function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+    Object.defineProperty(obj, key, desc);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/defineProperty.js

@@ -0,0 +1,14 @@
+export default function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/extends.js

@@ -0,0 +1,17 @@
+export default function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/get.js

@@ -0,0 +1,20 @@
+import superPropBase from "./superPropBase";
+export default function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.get) {
+    _get = Reflect.get;
+  } else {
+    _get = function _get(target, property, receiver) {
+      var base = superPropBase(target, property);
+      if (!base) return;
+      var desc = Object.getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js

@@ -0,0 +1,6 @@
+export default function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/inherits.js

@@ -0,0 +1,15 @@
+import setPrototypeOf from "./setPrototypeOf";
+export default function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) setPrototypeOf(subClass, superClass);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js

@@ -0,0 +1,5 @@
+export default function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js

@@ -0,0 +1,9 @@
+export default function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js

@@ -0,0 +1,3 @@
+export default function _initializerWarningHelper(descriptor, context) {
+  throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.');
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/instanceof.js

@@ -0,0 +1,7 @@
+export default function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js

@@ -0,0 +1,5 @@
+export default function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js

@@ -0,0 +1,24 @@
+export default function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj["default"] = obj;
+    return newObj;
+  }
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js

@@ -0,0 +1,3 @@
+export default function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/iterableToArray.js

@@ -0,0 +1,3 @@
+export default function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js

@@ -0,0 +1,25 @@
+export default function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimitLoose.js

@@ -0,0 +1,11 @@
+export default function _iterableToArrayLimitLoose(arr, i) {
+  var _arr = [];
+
+  for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  }
+
+  return _arr;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/jsx.js

@@ -0,0 +1,46 @@
+var REACT_ELEMENT_TYPE;
+export default function _createRawReactElement(type, props, key, children) {
+  if (!REACT_ELEMENT_TYPE) {
+    REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7;
+  }
+
+  var defaultProps = type && type.defaultProps;
+  var childrenLength = arguments.length - 3;
+
+  if (!props && childrenLength !== 0) {
+    props = {
+      children: void 0
+    };
+  }
+
+  if (props && defaultProps) {
+    for (var propName in defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  } else if (!props) {
+    props = defaultProps || {};
+  }
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = new Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 3];
+    }
+
+    props.children = childArray;
+  }
+
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key === undefined ? null : '' + key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js

@@ -0,0 +1,5 @@
+export default function _newArrowCheck(innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js

@@ -0,0 +1,3 @@
+export default function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js

@@ -0,0 +1,3 @@
+export default function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js

@@ -0,0 +1,3 @@
+export default function _objectDestructuringEmpty(obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/objectSpread.js

@@ -0,0 +1,19 @@
+import defineProperty from "./defineProperty";
+export default function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/objectSpread2.js

@@ -0,0 +1,35 @@
+import defineProperty from "./defineProperty";
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+export default function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(source, true).forEach(function (key) {
+        defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(source).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js

@@ -0,0 +1,19 @@
+import objectWithoutPropertiesLoose from "./objectWithoutPropertiesLoose";
+export default function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js

@@ -0,0 +1,14 @@
+export default function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}

node_modules/js-crypto-key-utils/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js

@@ -0,0 +1,9 @@
+import _typeof from "../../helpers/esm/typeof";
+import assertThisInitialized from "./assertThisInitialized";
+export default function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return assertThisInitialized(self);
+}