V1

node_modules/js-crypto-ec/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-ec/README.md

@@ -0,0 +1,112 @@
+Universal Module for Elliptic Curve Cryptography (ECDSA and ECDH) in JavaScript
+--
+[![npm version](https://badge.fury.io/js/js-crypto-ec.svg)](https://badge.fury.io/js/js-crypto-ec)
+[![Dependencies](https://david-dm.org/junkurihara/jscu.svg?path=packages/js-crypto-ec)](https://david-dm.org/junkurihara/jscu?path=packages/js-crypto-ec)
+[![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 an elliptic curve cryptography functions, i.e., it works both on most modern browsers and on Node.js just by importing from NPM/source code. Note that in the design principle, the library fully utilizes native APIs like WebCrypto API to accelerate its operation if available. This library provides APIs to employ ECDSA, ECDH and their key generation, i.e., `sign`, `verify`, `generateKey` and `deriveSecret`.
+
+# Installation
+
+At your project directory, do either one of the following.
+
+- From npm/yarn:
+  ```shell
+  $ npm install --save js-crypto-ec // npm
+  $ yarn add js-crypto-ec // yarn
+  ```
+- From GitHub:
+  ```shell
+  $ git clone https://github.com/junkurihara/jscu.git
+  $ cd js-crypto-utils/packages/js-crypto-ec
+  & yarn build
+  ```
+
+Then you should import the package as follows.
+
+```shell
+import ec from 'js-crypto-ec'; // for npm
+import ec from 'path/to/js-crypto-ec/dist/index.js'; // for github
+```
+
+The bundled file is also given as `js-crypto-ec/dist/jscec.bundle.js` for a use case where the module is imported as a `window.jscec` object via `script` tags.
+
+  
+# Usage
+This library always uses JWK-formatted keys ([RFC7517](https://tools.ietf.org/html/rfc7517)) to do any operations. If you utilize keys of other format, like PEM, please use [`js-crypto-key-utils`](https://github.com/junkurihara/js-crypto-key-utils) to convert them to JWK.
+
+## Key generation
+
+```javascript
+elliptic.generateKey('P-256').then( (key) => {
+  // now you get the JWK public and private keys
+  const publicKey = key.publicKey;
+  const privateKey = key.privateKey;
+})
+```
+
+## Sign and verify
+
+```javascript
+const publicJwk = {kty: 'EC', crv: 'P-256', x: '...', y: '...'}; // public key
+const privateJwk = {ktyp: 'EC', crv: 'P-256', x: '...', y: '...', d: '...'}; // paired private key
+const msg = ...; // Uint8Array
+
+// sign
+ec.sign(
+  msg,
+  privateJwk,
+  'SHA-256',
+  'raw' // output signature is not formatted. DER-encoded signature is available with 'der'.
+  ).then( (signature) => {
+  // now you get the signature in Uint8Array
+  return ec.verify(
+    msg,
+    sign,
+    publicJwk,
+    'SHA-256',
+    'raw' // input signature is not formatted. DER-encoded signature is available with 'der'. 
+    );  
+}).then( (valid) => {
+  // now you get the result of verification in boolean
+});
+```
+
+## Derive shared secret
+
+```javascript
+const publicJwkA = {kty: 'EC', crv: 'P-256', x: '...', y: '...'}; // public key of player A
+const privateJwkA = {ktyp: 'EC', crv: 'P-256', x: '...', y: '...', d: '...'}; // paired private key of player A
+
+const publicJwkB = {kty: 'EC', crv: 'P-256', x: '...', y: '...'}; // public key of player B
+const privateJwkB = {ktyp: 'EC', crv: 'P-256', x: '...', y: '...', d: '...'}; // paired private key of player B
+
+// At A's side
+const sharedAtPlayerA = ec.deriveSecret(publicJwkB, privateJwkA).then( (secretAtA) => {
+  // now you get the shared secret from my (player A's) private key and player B's public key
+})
+
+// At B's side
+const sharedAtPlayerB = ec.deriveSecret(publicJwkA, privateJwkB).then( (secretAtB) => {
+  // now you get the shared secret from my (player B's) private key and player A's public key
+})
+```
+
+**NOTE:** We SHOULD NOT use the derived secret as an encryption key directly. We should employ an appropriate key derivation procedure like HKDF to use the secret for symmetric key encryption.
+
+# Note
+
+At this point, 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-ec/dist/asn1enc.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encodeAsn1Signature = exports.decodeAsn1Signature = void 0;
+
+var _params = _interopRequireDefault(require("./params.js"));
+
+var _asn = _interopRequireDefault(require("asn1.js"));
+
+var _buffer = _interopRequireDefault(require("buffer"));
+
+/**
+ * asn1enc.js
+ */
+var Buffer = _buffer.default.Buffer;
+var BN = _asn.default.bignum;
+/**
+ * Decode ASN.1 encoded signature byte array.
+ * @param {Uint8Array} asn1sig - Byte array of ASN.1 encoded signature.
+ * @param {String} namedCurve - Name of curve like 'P-256'.
+ * @return {Uint8Array} - Decoded raw signature.
+ */
+
+var decodeAsn1Signature = function decodeAsn1Signature(asn1sig, namedCurve) {
+  var asn1sigBuffer = Buffer.from(asn1sig); // This must be Buffer object to get decoded;
+
+  var decoded = ECDSASignature.decode(asn1sigBuffer, 'der');
+  var len = _params.default.namedCurves[namedCurve].payloadSize;
+  var r = new Uint8Array(decoded.r.toArray('be', len));
+  var s = new Uint8Array(decoded.s.toArray('be', len));
+  var signature = new Uint8Array(len * 2);
+  signature.set(r);
+  signature.set(s, len);
+  return signature;
+};
+/**
+ * Encode raw signature and obtain ASN.1-encoded signature.
+ * @param {Uint8Array} signature - Byte array of raw signature.
+ * @param {String} namedCurve - Name of curve like 'P-256'.
+ * @return {Uint8Array} - Encoded ASN.1 signature.
+ */
+
+
+exports.decodeAsn1Signature = decodeAsn1Signature;
+
+var encodeAsn1Signature = function encodeAsn1Signature(signature, namedCurve) {
+  var len = _params.default.namedCurves[namedCurve].payloadSize;
+  var r = signature.slice(0, len);
+  var s = signature.slice(len, signature.length);
+  var asn1sig = ECDSASignature.encode({
+    r: new BN(r),
+    s: new BN(s)
+  }, 'der');
+  return new Uint8Array(asn1sig);
+}; /////////////////////////////////////////////////////////////////////////////////////////
+// RFC5759 https://tools.ietf.org/html/rfc5759.html
+
+
+exports.encodeAsn1Signature = encodeAsn1Signature;
+
+var ECDSASignature = _asn.default.define('ECDSASignature', function () {
+  this.seq().obj(this.key('r').int(), this.key('s').int());
+});

node_modules/js-crypto-ec/dist/ec.js

@@ -0,0 +1,456 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deriveSecret = exports.verify = exports.sign = exports.generateKey = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var util = _interopRequireWildcard(require("js-crypto-env"));
+
+var webapi = _interopRequireWildcard(require("./webapi.js"));
+
+var nodeapi = _interopRequireWildcard(require("./nodeapi.js"));
+
+var purejs = _interopRequireWildcard(require("./purejs.js"));
+
+/**
+ * ec.js
+ */
+
+/**
+ * Generate elliptic curve cryptography public/private key pair. Generated keys are in JWK.
+ * @param {String} [namedCurve='P-256'] - Name of curve like 'P-256'.
+ * @return {Promise<{publicKey: JsonWebKey, privateKey: JsonWebKey }>} - The generated keys.
+ * @throws {Error} - Throws if UnsupportedEnvironment, i.e., neither WebCrypto, NodeCrypto, nor PureJS codes works.
+ */
+var generateKey =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee() {
+    var namedCurve,
+        webCrypto,
+        nodeCrypto,
+        native,
+        errMsg,
+        keyPair,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            namedCurve = _args.length > 0 && _args[0] !== undefined ? _args[0] : 'P-256';
+            webCrypto = util.getWebCrypto(); // web crypto api
+
+            nodeCrypto = util.getNodeCrypto(); // implementation on node.js
+
+            native = true;
+            keyPair = {};
+
+            if (!(typeof webCrypto !== 'undefined' && typeof webCrypto.generateKey === 'function' && typeof webCrypto.exportKey === 'function')) {
+              _context.next = 11;
+              break;
+            }
+
+            _context.next = 8;
+            return webapi.generateKey(namedCurve, webCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 8:
+            keyPair = _context.sent;
+            _context.next = 18;
+            break;
+
+          case 11:
+            if (!(typeof nodeCrypto !== 'undefined')) {
+              _context.next = 17;
+              break;
+            }
+
+            _context.next = 14;
+            return nodeapi.generateKey(namedCurve, nodeCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 14:
+            keyPair = _context.sent;
+            _context.next = 18;
+            break;
+
+          case 17:
+            native = false;
+
+          case 18:
+            if (!(native === false)) {
+              _context.next = 22;
+              break;
+            }
+
+            _context.next = 21;
+            return purejs.generateKey(namedCurve).catch(function (e) {
+              errMsg = "".concat(errMsg, " => ").concat(e.message);
+              throw new Error("UnsupportedEnvironment: ".concat(errMsg));
+            });
+
+          case 21:
+            keyPair = _context.sent;
+
+          case 22:
+            return _context.abrupt("return", keyPair);
+
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function generateKey() {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Sign message with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message to be signed.
+ * @param {JsonWebKey} privateJwk - Private key object in JWK format.
+ * @param {String} [hash='SHA-256'] - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} [signatureFormat='raw'] - Signature format. 'raw' indicates the purely raw byte array of signature. It can also take 'der', and then the output is ASN.1 DER formatted.
+ * @return {Promise<Uint8Array>} - Output signature byte array in raw or der format.
+ * @throws {Error} - Throws if UnsupportedEnvironment, i.e., neither WebCrypto, NodeCrypto, nor PureJS codes works.
+ */
+
+
+exports.generateKey = generateKey;
+
+var sign =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(msg, privateJwk) {
+    var hash,
+        signatureFormat,
+        webCrypto,
+        nodeCrypto,
+        native,
+        errMsg,
+        signature,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            hash = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : 'SHA-256';
+            signatureFormat = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 'raw';
+
+            if (!(signatureFormat !== 'raw' && signatureFormat !== 'der')) {
+              _context2.next = 4;
+              break;
+            }
+
+            throw new Error('InvalidSignatureFormat');
+
+          case 4:
+            webCrypto = util.getWebCrypto(); // web crypto api
+
+            nodeCrypto = util.getNodeCrypto(); // implementation on node.js
+
+            native = true;
+
+            if (!(typeof webCrypto !== 'undefined' && typeof webCrypto.importKey === 'function' && typeof webCrypto.sign === 'function')) {
+              _context2.next = 13;
+              break;
+            }
+
+            _context2.next = 10;
+            return webapi.sign(msg, privateJwk, hash, signatureFormat, webCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 10:
+            signature = _context2.sent;
+            _context2.next = 20;
+            break;
+
+          case 13:
+            if (!(typeof nodeCrypto !== 'undefined')) {
+              _context2.next = 19;
+              break;
+            }
+
+            _context2.next = 16;
+            return nodeapi.sign(msg, privateJwk, hash, signatureFormat, nodeCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 16:
+            signature = _context2.sent;
+            _context2.next = 20;
+            break;
+
+          case 19:
+            native = false;
+
+          case 20:
+            if (!(native === false)) {
+              _context2.next = 24;
+              break;
+            }
+
+            _context2.next = 23;
+            return purejs.sign(msg, privateJwk, hash, signatureFormat).catch(function (e) {
+              errMsg = "".concat(errMsg, " => ").concat(e.message);
+              throw new Error("UnsupportedEnvironment: ".concat(errMsg));
+            });
+
+          case 23:
+            signature = _context2.sent;
+
+          case 24:
+            return _context2.abrupt("return", signature);
+
+          case 25:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function sign(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Verify signature with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message that have been signed.
+ * @param {Uint8Array} signature - Byte array of signature for the given message.
+ * @param {JsonWebKey} publicJwk - Public key object in JWK format.
+ * @param {String} [hash='SHA-256'] - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} [signatureFormat='raw'] - Signature format. 'raw' indicates the purely raw byte array of signature. It can also take 'der', and then the input must be in ASN.1 DER format.
+ * @return {Promise<boolean>} - The result of verification.
+ * @throws {Error} - Throws if UnsupportedEnvironment, i.e., neither WebCrypto, NodeCrypto, nor PureJS codes works.
+ */
+
+
+exports.sign = sign;
+
+var verify =
+/*#__PURE__*/
+function () {
+  var _ref3 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee3(msg, signature, publicJwk) {
+    var hash,
+        signatureFormat,
+        webCrypto,
+        nodeCrypto,
+        native,
+        errMsg,
+        valid,
+        _args3 = arguments;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            hash = _args3.length > 3 && _args3[3] !== undefined ? _args3[3] : 'SHA-256';
+            signatureFormat = _args3.length > 4 && _args3[4] !== undefined ? _args3[4] : 'raw';
+
+            if (!(signatureFormat !== 'raw' && signatureFormat !== 'der')) {
+              _context3.next = 4;
+              break;
+            }
+
+            throw new Error('InvalidSignatureFormat');
+
+          case 4:
+            webCrypto = util.getWebCrypto(); // web crypto api
+
+            nodeCrypto = util.getNodeCrypto(); // implementation on node.js
+
+            native = true;
+
+            if (!(typeof webCrypto !== 'undefined' && typeof webCrypto.importKey === 'function' && typeof webCrypto.verify === 'function')) {
+              _context3.next = 13;
+              break;
+            }
+
+            _context3.next = 10;
+            return webapi.verify(msg, signature, publicJwk, hash, signatureFormat, webCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 10:
+            valid = _context3.sent;
+            _context3.next = 20;
+            break;
+
+          case 13:
+            if (!(typeof nodeCrypto !== 'undefined')) {
+              _context3.next = 19;
+              break;
+            }
+
+            _context3.next = 16;
+            return nodeapi.verify(msg, signature, publicJwk, hash, signatureFormat, nodeCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 16:
+            valid = _context3.sent;
+            _context3.next = 20;
+            break;
+
+          case 19:
+            native = false;
+
+          case 20:
+            if (!(native === false)) {
+              _context3.next = 24;
+              break;
+            }
+
+            _context3.next = 23;
+            return purejs.verify(msg, signature, publicJwk, hash, signatureFormat).catch(function (e) {
+              errMsg = "".concat(errMsg, " => ").concat(e.message);
+              throw new Error("UnsupportedEnvironment: ".concat(errMsg));
+            });
+
+          case 23:
+            valid = _context3.sent;
+
+          case 24:
+            return _context3.abrupt("return", valid);
+
+          case 25:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function verify(_x3, _x4, _x5) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * ECDH: Elliptic Curve Diffie-Hellman Key Exchange, which derives shared secret from my private key and destination's public key.
+ * **NOTE** We SHOULD NOT use the derived secret as an encryption key directly.
+ * We should employ an appropriate key derivation procedure like HKDF to use the secret for symmetric key encryption.
+ * @param {JsonWebKey} publicJwk - Remote public key object in JWK format.
+ * @param {JsonWebKey} privateJwk - Local (my) private key object in JWK format.
+ * @return {Promise<Uint8Array>} - The derived master secret via ECDH.
+ * @throws {Error} - Throws if UnsupportedEnvironment, i.e., neither WebCrypto, NodeCrypto, nor PureJS codes works.
+ */
+
+
+exports.verify = verify;
+
+var deriveSecret =
+/*#__PURE__*/
+function () {
+  var _ref4 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee4(publicJwk, privateJwk) {
+    var webCrypto, nodeCrypto, native, errMsg, secret;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(publicJwk.crv !== privateJwk.crv)) {
+              _context4.next = 2;
+              break;
+            }
+
+            throw new Error('UnmatchedCurveName');
+
+          case 2:
+            webCrypto = util.getWebCrypto(); // web crypto api
+
+            nodeCrypto = util.getNodeCrypto(); // implementation on node.js
+
+            native = true;
+
+            if (!(typeof webCrypto !== 'undefined' && typeof webCrypto.importKey === 'function' && typeof webCrypto.deriveBits === 'function')) {
+              _context4.next = 11;
+              break;
+            }
+
+            _context4.next = 8;
+            return webapi.deriveSecret(publicJwk, privateJwk, webCrypto).catch(function (e) {
+              errMsg = e.message;
+              native = false;
+            });
+
+          case 8:
+            secret = _context4.sent;
+            _context4.next = 12;
+            break;
+
+          case 11:
+            if (typeof nodeCrypto !== 'undefined') {
+              // for node
+              try {
+                secret = nodeapi.deriveSecret(publicJwk, privateJwk, nodeCrypto);
+              } catch (e) {
+                errMsg = e.message;
+                native = false;
+              }
+            } else native = false;
+
+          case 12:
+            if (!(native === false)) {
+              _context4.next = 23;
+              break;
+            }
+
+            _context4.prev = 13;
+            _context4.next = 16;
+            return purejs.deriveSecret(publicJwk, privateJwk);
+
+          case 16:
+            secret = _context4.sent;
+            _context4.next = 23;
+            break;
+
+          case 19:
+            _context4.prev = 19;
+            _context4.t0 = _context4["catch"](13);
+            errMsg = "".concat(errMsg, " => ").concat(_context4.t0.message);
+            throw new Error("UnsupportedEnvironment: ".concat(errMsg));
+
+          case 23:
+            return _context4.abrupt("return", secret);
+
+          case 24:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[13, 19]]);
+  }));
+
+  return function deriveSecret(_x6, _x7) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+exports.deriveSecret = deriveSecret;

node_modules/js-crypto-ec/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "generateKey", {
+  enumerable: true,
+  get: function get() {
+    return _ec.generateKey;
+  }
+});
+Object.defineProperty(exports, "sign", {
+  enumerable: true,
+  get: function get() {
+    return _ec.sign;
+  }
+});
+Object.defineProperty(exports, "verify", {
+  enumerable: true,
+  get: function get() {
+    return _ec.verify;
+  }
+});
+Object.defineProperty(exports, "deriveSecret", {
+  enumerable: true,
+  get: function get() {
+    return _ec.deriveSecret;
+  }
+});
+exports.default = void 0;
+
+var _ec = require("./ec.js");
+
+/**
+ * index.js
+ */
+var _default = {
+  generateKey: _ec.generateKey,
+  sign: _ec.sign,
+  verify: _ec.verify,
+  deriveSecret: _ec.deriveSecret
+};
+exports.default = _default;

node_modules/js-crypto-ec/dist/nodeapi.js

@@ -0,0 +1,247 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deriveSecret = exports.verify = exports.sign = exports.generateKey = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _params = _interopRequireDefault(require("./params.js"));
+
+var asn1enc = _interopRequireWildcard(require("./asn1enc.js"));
+
+var _jsCryptoKeyUtils = require("js-crypto-key-utils");
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+/**
+ * nodeapi.js
+ */
+
+/**
+ * Generate elliptic curve cryptography public/private key pair. Generated keys are in JWK.
+ * @param {String} namedCurve - Name of curve like 'P-256'.
+ * @param {Object} nodeCrypto - NodeCrypto object.
+ * @return {Promise<{publicKey: JsonWebKey, privateKey: JsonWebKey}>} - The generated keys.
+ * @throws {Error} - Throws if NotPublic/PrivateKeyForECCKeyGenNode
+ */
+var generateKey =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee(namedCurve, nodeCrypto) {
+    var ecdh, publicOct, privateOct, publicKey, publicJwk, privateKey, privateJwk;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            ecdh = nodeCrypto.ECDH(_params.default.namedCurves[namedCurve].nodeName);
+            ecdh.generateKeys();
+            publicOct = new Uint8Array(ecdh.getPublicKey());
+            privateOct = new Uint8Array(ecdh.getPrivateKey());
+            publicKey = new _jsCryptoKeyUtils.Key('oct', publicOct, {
+              namedCurve: namedCurve
+            });
+
+            if (!publicKey.isPrivate) {
+              _context.next = 7;
+              break;
+            }
+
+            throw new Error('NotPublicKeyForECCKeyGenNode');
+
+          case 7:
+            _context.next = 9;
+            return publicKey.export('jwk', {
+              outputPublic: true
+            });
+
+          case 9:
+            publicJwk = _context.sent;
+            privateKey = new _jsCryptoKeyUtils.Key('oct', privateOct, {
+              namedCurve: namedCurve
+            });
+
+            if (privateKey.isPrivate) {
+              _context.next = 13;
+              break;
+            }
+
+            throw new Error('NotPrivateKeyForECCKeyGenNode');
+
+          case 13:
+            _context.next = 15;
+            return privateKey.export('jwk');
+
+          case 15:
+            privateJwk = _context.sent;
+            return _context.abrupt("return", {
+              publicKey: publicJwk,
+              privateKey: privateJwk
+            });
+
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function generateKey(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Sign message with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message to be signed.
+ * @param {JsonWebKey} privateJwk - Private key object in JWK format.
+ * @param {String} hash - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} signatureFormat - Signature format, 'raw' or 'der'
+ * @param {Object} nodeCrypto - NodeCrypto object.
+ * @return {Promise<Uint8Array>} - Output signature byte array in raw or der format.
+ * @throws {Error} - Throws if NotPrivateKeyForECCSignNode.
+ */
+
+
+exports.generateKey = generateKey;
+
+var sign =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(msg, privateJwk, hash, signatureFormat, nodeCrypto) {
+    var privateKey, privatePem, sign, asn1sig;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            privateKey = new _jsCryptoKeyUtils.Key('jwk', privateJwk);
+
+            if (privateKey.isPrivate) {
+              _context2.next = 3;
+              break;
+            }
+
+            throw new Error('NotPrivateKeyForECCSignNode');
+
+          case 3:
+            _context2.next = 5;
+            return privateKey.export('pem');
+
+          case 5:
+            privatePem = _context2.sent;
+            sign = nodeCrypto.createSign(_params.default.hashes[hash].nodeName);
+            sign.update(msg);
+            asn1sig = sign.sign(privatePem);
+            return _context2.abrupt("return", signatureFormat === 'raw' ? asn1enc.decodeAsn1Signature(asn1sig, privateJwk.crv) : asn1sig);
+
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function sign(_x3, _x4, _x5, _x6, _x7) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Verify signature with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message that have been signed.
+ * @param {Uint8Array} signature - Byte array of signature for the given message.
+ * @param {JsonWebKey} publicJwk - Public key object in JWK format.
+ * @param {String} hash - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} signatureFormat - Signature format,'raw' or 'der'.
+ * @param {Object} nodeCrypto - NodeCrypto object.
+ * @return {Promise<boolean>} - The result of verification.
+ * @throws {Error} - Throws if NotPublicKeyForEccVerifyNode.
+ */
+
+
+exports.sign = sign;
+
+var verify =
+/*#__PURE__*/
+function () {
+  var _ref3 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee3(msg, signature, publicJwk, hash, signatureFormat, nodeCrypto) {
+    var publicKey, publicPem, verify, asn1sig;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            publicKey = new _jsCryptoKeyUtils.Key('jwk', publicJwk);
+
+            if (publicKey.isPrivate) {
+              _context3.next = 3;
+              break;
+            }
+
+            throw new Error('NotPrivateKeyForECCVerifyNode');
+
+          case 3:
+            _context3.next = 5;
+            return publicKey.export('pem', {
+              outputPublic: true,
+              compact: false
+            });
+
+          case 5:
+            publicPem = _context3.sent;
+            verify = nodeCrypto.createVerify(_params.default.hashes[hash].nodeName);
+            verify.update(msg);
+            asn1sig = signatureFormat === 'raw' ? asn1enc.encodeAsn1Signature(signature, publicJwk.crv) : signature;
+            return _context3.abrupt("return", verify.verify(publicPem, asn1sig));
+
+          case 10:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function verify(_x8, _x9, _x10, _x11, _x12, _x13) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Key Derivation for ECDH, Elliptic Curve Diffie-Hellman Key Exchange.
+ * @param {JsonWebKey} publicJwk - Remote public key object in JWK format.
+ * @param {JsonWebKey} privateJwk - Local (my) private key object in JWK format.
+ * @param {Object} nodeCrypto - NodeCrypto object.
+ * @return {Uint8Array} - The derived master secret via ECDH.
+ */
+
+
+exports.verify = verify;
+
+var deriveSecret = function deriveSecret(publicJwk, privateJwk, nodeCrypto) {
+  var curve = _params.default.namedCurves[privateJwk.crv].nodeName;
+  var payloadSize = _params.default.namedCurves[privateJwk.crv].payloadSize;
+  var ecdh = nodeCrypto.createECDH(curve);
+
+  var privKeyBuf = _jsEncodingUtils.default.encoder.decodeBase64Url(privateJwk.d);
+
+  var pubKeyBuf = new Uint8Array(payloadSize * 2 + 1);
+  pubKeyBuf[0] = 0xFF & 0x04;
+  pubKeyBuf.set(_jsEncodingUtils.default.encoder.decodeBase64Url(publicJwk.x), 1);
+  pubKeyBuf.set(_jsEncodingUtils.default.encoder.decodeBase64Url(publicJwk.y), payloadSize + 1);
+  ecdh.setPrivateKey(privKeyBuf);
+  return new Uint8Array(ecdh.computeSecret(pubKeyBuf));
+};
+
+exports.deriveSecret = deriveSecret;

node_modules/js-crypto-ec/dist/params.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * params.js
+ */
+var _default = {
+  namedCurves: {
+    'P-256': {
+      indutnyName: 'p256',
+      nodeName: 'prime256v1',
+      payloadSize: 32
+    },
+    'P-384': {
+      indutnyName: 'p384',
+      nodeName: 'secp384r1',
+      payloadSize: 48
+    },
+    'P-521': {
+      indutnyName: 'p521',
+      nodeName: 'secp521r1',
+      payloadSize: 66
+    },
+    'P-256K': {
+      indutnyName: 'secp256k1',
+      nodeName: 'secp256k1',
+      payloadSize: 32
+    }
+  },
+  hashes: {
+    'SHA-256': {
+      nodeName: 'sha256'
+    },
+    //, hashSize: 32},
+    'SHA-384': {
+      nodeName: 'sha384'
+    },
+    //, hashSize: 48},
+    'SHA-512': {
+      nodeName: 'sha512'
+    },
+    //, hashSize: 64}
+    'SHA-1': {
+      nodeName: 'sha1'
+    } //, hashSize: 20},
+
+  }
+};
+exports.default = _default;

node_modules/js-crypto-ec/dist/purejs.js

@@ -0,0 +1,351 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deriveSecret = exports.verify = exports.sign = exports.generateKey = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _params = _interopRequireDefault(require("./params.js"));
+
+var asn1enc = _interopRequireWildcard(require("./asn1enc.js"));
+
+var _jsCryptoRandom = _interopRequireDefault(require("js-crypto-random"));
+
+var _jsCryptoHash = _interopRequireDefault(require("js-crypto-hash"));
+
+var _jsCryptoKeyUtils = require("js-crypto-key-utils");
+
+var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));
+
+var _elliptic = _interopRequireDefault(require("elliptic"));
+
+/**
+ * purejs.js
+ */
+var Ec = _elliptic.default.ec;
+/**
+ * Generate elliptic curve cryptography public/private key pair. Generated keys are in JWK.
+ * @param {String} namedCurve - Name of curve like 'P-256'.
+ * @return {Promise<{publicKey: JsonWebKey, privateKey: JsonWebKey}>} - The generated keys.
+ * @throws {Error} - Throws if NotPublic/PrivateKeyForECCKeyGenPureJS
+ */
+
+var generateKey =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee(namedCurve) {
+    var curve, ec, ecKey, len, publicOct, privateOct, publicKey, publicJwk, privateKey, privateJwk;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            curve = _params.default.namedCurves[namedCurve].indutnyName;
+            ec = new Ec(curve);
+            _context.t0 = ec;
+            _context.t1 = _jsEncodingUtils.default.encoder;
+            _context.next = 6;
+            return _jsCryptoRandom.default.getRandomBytes(32);
+
+          case 6:
+            _context.t2 = _context.sent;
+            _context.t3 = _context.t1.arrayBufferToString.call(_context.t1, _context.t2);
+            _context.t4 = {
+              entropy: _context.t3
+            };
+            ecKey = _context.t0.genKeyPair.call(_context.t0, _context.t4);
+            len = _params.default.namedCurves[namedCurve].payloadSize;
+            publicOct = new Uint8Array(ecKey.getPublic('array'));
+            privateOct = new Uint8Array(ecKey.getPrivate().toArray('be', len));
+            publicKey = new _jsCryptoKeyUtils.Key('oct', publicOct, {
+              namedCurve: namedCurve
+            });
+
+            if (!publicKey.isPrivate) {
+              _context.next = 16;
+              break;
+            }
+
+            throw new Error('NotPublicKeyForECCKeyGenPureJS');
+
+          case 16:
+            _context.next = 18;
+            return publicKey.export('jwk', {
+              outputPublic: true
+            });
+
+          case 18:
+            publicJwk = _context.sent;
+            privateKey = new _jsCryptoKeyUtils.Key('oct', privateOct, {
+              namedCurve: namedCurve
+            });
+
+            if (privateKey.isPrivate) {
+              _context.next = 22;
+              break;
+            }
+
+            throw new Error('NotPrivateKeyForECCKeyGenPureJS');
+
+          case 22:
+            _context.next = 24;
+            return privateKey.export('jwk');
+
+          case 24:
+            privateJwk = _context.sent;
+            return _context.abrupt("return", {
+              publicKey: publicJwk,
+              privateKey: privateJwk
+            });
+
+          case 26:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function generateKey(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Sign message with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message to be signed.
+ * @param {JsonWebKey} privateJwk - Private key object in JWK format.
+ * @param {String} hash - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} signatureFormat - Signature format, 'raw' or 'der'
+ * @return {Promise<Uint8Array>} - Output signature byte array in raw or der format.
+ * @throws {Error} - Throws if NotPrivateKeyForECCSIgnPureJS
+ */
+
+
+exports.generateKey = generateKey;
+
+var sign =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(msg, privateJwk, hash, signatureFormat) {
+    var namedCurve, curve, ec, privateKey, privateOct, ecKey, md, signature, len, arrayR, arrayS, concat;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            namedCurve = privateJwk.crv;
+            curve = _params.default.namedCurves[namedCurve].indutnyName;
+            ec = new Ec(curve);
+            privateKey = new _jsCryptoKeyUtils.Key('jwk', privateJwk);
+
+            if (privateKey.isPrivate) {
+              _context2.next = 6;
+              break;
+            }
+
+            throw new Error('NotPrivateKeyForECCSignPureJS');
+
+          case 6:
+            _context2.next = 8;
+            return privateKey.export('oct');
+
+          case 8:
+            privateOct = _context2.sent;
+            ecKey = ec.keyFromPrivate(privateOct); // get hash
+
+            _context2.next = 12;
+            return _jsCryptoHash.default.compute(msg, hash);
+
+          case 12:
+            md = _context2.sent;
+            // generate signature
+            signature = ecKey.sign(md); // formatting
+
+            len = _params.default.namedCurves[namedCurve].payloadSize;
+            arrayR = new Uint8Array(signature.r.toArray('be', len));
+            arrayS = new Uint8Array(signature.s.toArray('be', len));
+            concat = new Uint8Array(arrayR.length + arrayS.length);
+            concat.set(arrayR);
+            concat.set(arrayS, arrayR.length);
+            return _context2.abrupt("return", signatureFormat === 'raw' ? concat : asn1enc.encodeAsn1Signature(concat, namedCurve));
+
+          case 21:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function sign(_x2, _x3, _x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Verify signature with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message that have been signed.
+ * @param {Uint8Array} signature - Byte array of signature for the given message.
+ * @param {JsonWebKey} publicJwk - Public key object in JWK format.
+ * @param {String} hash - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} signatureFormat - Signature format,'raw' or 'der'.
+ * @return {Promise<boolean>} - The result of verification.
+ * @throws {Error} - Throws if NotPublicKeyForEccVerifyPureJS.
+ */
+
+
+exports.sign = sign;
+
+var verify =
+/*#__PURE__*/
+function () {
+  var _ref3 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee3(msg, signature, publicJwk, hash, signatureFormat) {
+    var namedCurve, curve, ec, publicKey, publicOct, ecKey, len, sigR, sigS, md;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            namedCurve = publicJwk.crv;
+            curve = _params.default.namedCurves[namedCurve].indutnyName;
+            ec = new Ec(curve);
+            publicKey = new _jsCryptoKeyUtils.Key('jwk', publicJwk);
+
+            if (!publicKey.isPrivate) {
+              _context3.next = 6;
+              break;
+            }
+
+            throw new Error('NotPublicKeyForECCVerifyPureJS');
+
+          case 6:
+            _context3.next = 8;
+            return publicKey.export('oct', {
+              compact: false,
+              outputPublic: true
+            });
+
+          case 8:
+            publicOct = _context3.sent;
+            ecKey = ec.keyFromPublic(publicOct); // parse signature
+
+            len = _params.default.namedCurves[namedCurve].payloadSize;
+            if (!(signature instanceof Uint8Array)) signature = new Uint8Array(signature);
+            signature = signatureFormat === 'raw' ? signature : asn1enc.decodeAsn1Signature(signature, namedCurve);
+            sigR = signature.slice(0, len);
+            sigS = signature.slice(len, len + sigR.length); // get hash
+
+            _context3.next = 17;
+            return _jsCryptoHash.default.compute(msg, hash);
+
+          case 17:
+            md = _context3.sent;
+            _context3.next = 20;
+            return ecKey.verify(md, {
+              s: sigS,
+              r: sigR
+            });
+
+          case 20:
+            return _context3.abrupt("return", _context3.sent);
+
+          case 21:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function verify(_x6, _x7, _x8, _x9, _x10) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Key Derivation for ECDH, Elliptic Curve Diffie-Hellman Key Exchange.
+ * @param {JsonWebKey} publicJwk - Remote public key object in JWK format.
+ * @param {JsonWebKey} privateJwk - Local (my) private key object in JWK format.
+ * @return {Promise<Uint8Array>} - The derived master secret via ECDH.
+ * @throws {Error} - Throws if NotPublic/PrivateKeyForECCSDeriveKeyPureJS.
+ */
+
+
+exports.verify = verify;
+
+var deriveSecret =
+/*#__PURE__*/
+function () {
+  var _ref4 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee4(publicJwk, privateJwk) {
+    var namedCurve, curve, ec, priKeyObj, privateOct, pubKeyObj, publicOct, privateKey, publicKey, len;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            namedCurve = privateJwk.crv;
+            curve = _params.default.namedCurves[namedCurve].indutnyName;
+            ec = new Ec(curve);
+            priKeyObj = new _jsCryptoKeyUtils.Key('jwk', privateJwk);
+
+            if (priKeyObj.isPrivate) {
+              _context4.next = 6;
+              break;
+            }
+
+            throw new Error('NotPrivateKeyForECCSDeriveKeyPureJS');
+
+          case 6:
+            _context4.next = 8;
+            return priKeyObj.export('oct');
+
+          case 8:
+            privateOct = _context4.sent;
+            pubKeyObj = new _jsCryptoKeyUtils.Key('jwk', publicJwk);
+
+            if (!pubKeyObj.isPrivate) {
+              _context4.next = 12;
+              break;
+            }
+
+            throw new Error('NotPublicKeyForECCDeriveKeyPureJS');
+
+          case 12:
+            _context4.next = 14;
+            return pubKeyObj.export('oct', {
+              compact: false,
+              outputPublic: true
+            });
+
+          case 14:
+            publicOct = _context4.sent;
+            privateKey = ec.keyFromPrivate(privateOct);
+            publicKey = ec.keyFromPublic(publicOct); // derive shared key
+
+            len = _params.default.namedCurves[namedCurve].payloadSize;
+            return _context4.abrupt("return", new Uint8Array(privateKey.derive(publicKey.getPublic()).toArray('be', len)));
+
+          case 19:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function deriveSecret(_x11, _x12) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+exports.deriveSecret = deriveSecret;

node_modules/js-crypto-ec/dist/webapi.js

@@ -0,0 +1,261 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deriveSecret = exports.verify = exports.sign = exports.generateKey = 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 asn1enc = _interopRequireWildcard(require("./asn1enc.js"));
+
+/**
+ * webapi.js
+ */
+
+/**
+ * Generate elliptic curve cryptography public/private key pair. Generated keys are in JWK.
+ * @param {String} namedCurve - Name of curve like 'P-256'.
+ * @param {Object} webCrypto - WebCryptoSubtle object.
+ * @return {Promise<{publicKey: JsonWebKey, privateKey: JsonWebKey}>} - The generated keys.
+ */
+var generateKey =
+/*#__PURE__*/
+function () {
+  var _ref = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee(namedCurve, webCrypto) {
+    var keys, publicKey, privateKey;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return webCrypto.generateKey({
+              name: 'ECDSA',
+              namedCurve: namedCurve,
+              hash: {
+                name: 'SHA-256'
+              }
+            }, true, ['sign', 'verify']);
+
+          case 2:
+            keys = _context.sent;
+            _context.next = 5;
+            return webCrypto.exportKey('jwk', keys.publicKey);
+
+          case 5:
+            publicKey = _context.sent;
+            _context.next = 8;
+            return webCrypto.exportKey('jwk', keys.privateKey);
+
+          case 8:
+            privateKey = _context.sent;
+            // delete optional entries to export as general ecdsa/ecdh key
+            ['key_ops', 'alg', 'ext'].forEach(function (elem) {
+              delete publicKey[elem];
+              delete privateKey[elem];
+            });
+            return _context.abrupt("return", {
+              publicKey: publicKey,
+              privateKey: privateKey
+            });
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function generateKey(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Sign message with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message to be signed.
+ * @param {JsonWebKey} privateJwk - Private key object in JWK format.
+ * @param {String} hash - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} signatureFormat - Signature format, 'raw' or 'der'
+ * @param {Object} webCrypto - WebCryptoSubtle object.
+ * @return {Promise<Uint8Array>} - Output signature byte array in raw or der format.
+ */
+
+
+exports.generateKey = generateKey;
+
+var sign =
+/*#__PURE__*/
+function () {
+  var _ref2 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee2(msg, privateJwk, hash, signatureFormat, webCrypto) {
+    var algo, key, signature;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            algo = {
+              name: 'ECDSA',
+              namedCurve: privateJwk.crv,
+              hash: {
+                name: hash
+              }
+            };
+            _context2.next = 3;
+            return webCrypto.importKey('jwk', privateJwk, algo, false, ['sign']);
+
+          case 3:
+            key = _context2.sent;
+            _context2.next = 6;
+            return webCrypto.sign(algo, key, msg);
+
+          case 6:
+            signature = _context2.sent;
+            return _context2.abrupt("return", signatureFormat === 'raw' ? new Uint8Array(signature) : asn1enc.encodeAsn1Signature(new Uint8Array(signature), privateJwk.crv));
+
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function sign(_x3, _x4, _x5, _x6, _x7) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Verify signature with ECDSA.
+ * @param {Uint8Array} msg - Byte array of message that have been signed.
+ * @param {Uint8Array} signature - Byte array of signature for the given message.
+ * @param {JsonWebKey} publicJwk - Public key object in JWK format.
+ * @param {String} hash - Name of hash algorithm used in singing, like 'SHA-256'.
+ * @param {String} signatureFormat - Signature format,'raw' or 'der'.
+ * @param {Object} webCrypto - WebCryptoSubtle object.
+ * @return {Promise<boolean>} - The result of verification.
+ */
+
+
+exports.sign = sign;
+
+var verify =
+/*#__PURE__*/
+function () {
+  var _ref3 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee3(msg, signature, publicJwk, hash, signatureFormat, webCrypto) {
+    var algo, key, rawSignature;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            algo = {
+              name: 'ECDSA',
+              namedCurve: publicJwk.crv,
+              hash: {
+                name: hash
+              }
+            };
+            _context3.next = 3;
+            return webCrypto.importKey('jwk', publicJwk, algo, false, ['verify']);
+
+          case 3:
+            key = _context3.sent;
+            rawSignature = signatureFormat === 'raw' ? signature : asn1enc.decodeAsn1Signature(signature, publicJwk.crv);
+            _context3.next = 7;
+            return webCrypto.verify(algo, key, rawSignature, msg);
+
+          case 7:
+            return _context3.abrupt("return", _context3.sent);
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function verify(_x8, _x9, _x10, _x11, _x12, _x13) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Key Derivation for ECDH, Elliptic Curve Diffie-Hellman Key Exchange.
+ * @param {JsonWebKey} publicJwk - Remote public key object in JWK format.
+ * @param {JsonWebKey} privateJwk - Local (my) private key object in JWK format.
+ * @param {Object} webCrypto - WebCryptoSubtle object.
+ * @return {Promise<Uint8Array>} - The derived master secret via ECDH.
+ */
+
+
+exports.verify = verify;
+
+var deriveSecret =
+/*#__PURE__*/
+function () {
+  var _ref4 = (0, _asyncToGenerator2.default)(
+  /*#__PURE__*/
+  _regenerator.default.mark(function _callee4(publicJwk, privateJwk, webCrypto) {
+    var algo, privateKey, publicKey, bitLen;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            algo = {
+              name: 'ECDH',
+              namedCurve: privateJwk.crv
+            };
+            _context4.next = 3;
+            return webCrypto.importKey('jwk', privateJwk, algo, false, ['deriveBits']);
+
+          case 3:
+            privateKey = _context4.sent;
+            _context4.next = 6;
+            return webCrypto.importKey('jwk', publicJwk, algo, false, []);
+
+          case 6:
+            publicKey = _context4.sent;
+
+            bitLen = function bitLen() {
+              var arr = _jsEncodingUtils.default.encoder.decodeBase64Url(privateJwk.x);
+
+              return 8 * arr.length;
+            };
+
+            _context4.t0 = Uint8Array;
+            _context4.next = 11;
+            return webCrypto.deriveBits(Object.assign(algo, {
+              public: publicKey
+            }), privateKey, bitLen());
+
+          case 11:
+            _context4.t1 = _context4.sent;
+            return _context4.abrupt("return", new _context4.t0(_context4.t1));
+
+          case 13:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function deriveSecret(_x14, _x15, _x16) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+exports.deriveSecret = deriveSecret;

node_modules/js-crypto-ec/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-ec/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-ec/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-ec/node_modules/@babel/runtime/helpers/AwaitValue.js

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

node_modules/js-crypto-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/node_modules/@babel/runtime/helpers/esm/AwaitValue.js

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

node_modules/js-crypto-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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-ec/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);
+}

node_modules/js-crypto-ec/node_modules/@babel/runtime/helpers/esm/readOnlyError.js

@@ -0,0 +1,3 @@
+export default function _readOnlyError(name) {
+  throw new Error("\"" + name + "\" is read-only");
+}

node_modules/js-crypto-ec/node_modules/@babel/runtime/helpers/esm/set.js

@@ -0,0 +1,51 @@
+import superPropBase from "./superPropBase";
+import defineProperty from "./defineProperty";
+
+function set(target, property, value, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.set) {
+    set = Reflect.set;
+  } else {
+    set = function set(target, property, value, receiver) {
+      var base = superPropBase(target, property);
+      var desc;
+
+      if (base) {
+        desc = Object.getOwnPropertyDescriptor(base, property);
+
+        if (desc.set) {
+          desc.set.call(receiver, value);
+          return true;
+        } else if (!desc.writable) {
+          return false;
+        }
+      }
+
+      desc = Object.getOwnPropertyDescriptor(receiver, property);
+
+      if (desc) {
+        if (!desc.writable) {
+          return false;
+        }
+
+        desc.value = value;
+        Object.defineProperty(receiver, property, desc);
+      } else {
+        defineProperty(receiver, property, value);
+      }
+
+      return true;
+    };
+  }
+
+  return set(target, property, value, receiver);
+}
+
+export default function _set(target, property, value, receiver, isStrict) {
+  var s = set(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error('failed to set property');
+  }
+
+  return value;
+}

node_modules/js-crypto-ec/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js

@@ -0,0 +1,8 @@
+export default function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}

node_modules/js-crypto-ec/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js

@@ -0,0 +1,7 @@
+export default function _skipFirstGeneratorNext(fn) {
+  return function () {
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}

node_modules/js-crypto-ec/node_modules/@babel/runtime/helpers/esm/slicedToArray.js

@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArrayLimit from "./iterableToArrayLimit";
+import nonIterableRest from "./nonIterableRest";
+export default function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+}

node_modules/js-crypto-ec/node_modules/@babel/runtime/helpers/esm/slicedToArrayLoose.js

@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArrayLimitLoose from "./iterableToArrayLimitLoose";
+import nonIterableRest from "./nonIterableRest";
+export default function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+}