remove git ignore for the test

hardhat/.gitignore

@@ -1,17 +1,17 @@
-node_modules
+# node_modules
-.env
+# .env
 
-# Hardhat files
+# # Hardhat files
-/cache
+# /cache
-/artifacts
+# /artifacts
 
-# TypeChain files
+# # TypeChain files
-/typechain
+# /typechain
-/typechain-types
+# /typechain-types
 
-# solidity-coverage files
+# # solidity-coverage files
-/coverage
+# /coverage
-/coverage.json
+# /coverage.json
 
-# Hardhat Ignition default folder for deployments against a local node
+# # Hardhat Ignition default folder for deployments against a local node
-ignition/deployments/chain-31337
+# ignition/deployments/chain-31337

hardhat/artifacts/contracts/Lock.sol/Lock.dbg.json

@@ -0,0 +1,4 @@
+{
+  "_format": "hh-sol-dbg-1",
+  "buildInfo": "../../build-info/ad47b6fd82fea4f651540333f2a0887a.json"
+}

hardhat/artifacts/contracts/Lock.sol/Lock.json

@@ -0,0 +1,74 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "Lock",
+  "sourceName": "contracts/Lock.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "_unlockTime",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "when",
+          "type": "uint256"
+        }
+      ],
+      "name": "Withdrawal",
+      "type": "event"
+    },
+    {
+      "inputs": [],
+      "name": "owner",
+      "outputs": [
+        {
+          "internalType": "address payable",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "unlockTime",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "withdraw",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x60806040526040516105d83803806105d8833981810160405281019061002591906100f0565b804210610067576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161005e906101a0565b60405180910390fd5b8060008190555033600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506101c0565b600080fd5b6000819050919050565b6100cd816100ba565b81146100d857600080fd5b50565b6000815190506100ea816100c4565b92915050565b600060208284031215610106576101056100b5565b5b6000610114848285016100db565b91505092915050565b600082825260208201905092915050565b7f556e6c6f636b2074696d652073686f756c6420626520696e207468652066757460008201527f7572650000000000000000000000000000000000000000000000000000000000602082015250565b600061018a60238361011d565b91506101958261012e565b604082019050919050565b600060208201905081810360008301526101b98161017d565b9050919050565b610409806101cf6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063251c1aa3146100465780633ccfd60b146100645780638da5cb5b1461006e575b600080fd5b61004e61008c565b60405161005b919061024a565b60405180910390f35b61006c610092565b005b61007661020b565b60405161008391906102a6565b60405180910390f35b60005481565b6000544210156100d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ce9061031e565b60405180910390fd5b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610167576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161015e9061038a565b60405180910390fd5b7fbf2ed60bd5b5965d685680c01195c9514e4382e28e3a5a2d2d5244bf59411b9347426040516101989291906103aa565b60405180910390a1600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc479081150290604051600060405180830381858888f19350505050158015610208573d6000803e3d6000fd5b50565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000819050919050565b61024481610231565b82525050565b600060208201905061025f600083018461023b565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600061029082610265565b9050919050565b6102a081610285565b82525050565b60006020820190506102bb6000830184610297565b92915050565b600082825260208201905092915050565b7f596f752063616e27742077697468647261772079657400000000000000000000600082015250565b60006103086016836102c1565b9150610313826102d2565b602082019050919050565b60006020820190508181036000830152610337816102fb565b9050919050565b7f596f75206172656e277420746865206f776e6572000000000000000000000000600082015250565b60006103746014836102c1565b915061037f8261033e565b602082019050919050565b600060208201905081810360008301526103a381610367565b9050919050565b60006040820190506103bf600083018561023b565b6103cc602083018461023b565b939250505056fea26469706673582212202d2006ef26cbefcc4deab66c32f5ff5efb638f080c7490b6633879942caf232764736f6c634300081c0033",
+  "deployedBytecode": "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",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

hardhat/cache/solidity-files-cache.json

@@ -0,0 +1,41 @@
+{
+  "_format": "hh-sol-cache-2",
+  "files": {
+    "/home/radostina.lyubomirova/homework/go-ethereum-task/hardhat/contracts/Lock.sol": {
+      "lastModificationDate": 1748971399969,
+      "contentHash": "7eee587c347fe6b1de50c96688cb9477",
+      "sourceName": "contracts/Lock.sol",
+      "solcConfig": {
+        "version": "0.8.28",
+        "settings": {
+          "evmVersion": "paris",
+          "optimizer": {
+            "enabled": false,
+            "runs": 200
+          },
+          "outputSelection": {
+            "*": {
+              "*": [
+                "abi",
+                "evm.bytecode",
+                "evm.deployedBytecode",
+                "evm.methodIdentifiers",
+                "metadata"
+              ],
+              "": [
+                "ast"
+              ]
+            }
+          }
+        }
+      },
+      "imports": [],
+      "versionPragmas": [
+        "^0.8.28"
+      ],
+      "artifacts": [
+        "Lock"
+      ]
+    }
+  }
+}

hardhat/node_modules/.bin/_mocha

@@ -0,0 +1 @@
+../mocha/bin/_mocha

hardhat/node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

hardhat/node_modules/.bin/escodegen

@@ -0,0 +1 @@
+../escodegen/bin/escodegen.js

hardhat/node_modules/.bin/esgenerate

@@ -0,0 +1 @@
+../escodegen/bin/esgenerate.js

hardhat/node_modules/.bin/esparse

@@ -0,0 +1 @@
+../esprima/bin/esparse.js

hardhat/node_modules/.bin/esvalidate

@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js

hardhat/node_modules/.bin/flat

@@ -0,0 +1 @@
+../flat/cli.js

hardhat/node_modules/.bin/handlebars

@@ -0,0 +1 @@
+../handlebars/bin/handlebars

hardhat/node_modules/.bin/hardhat

@@ -0,0 +1 @@
+../hardhat/internal/cli/bootstrap.js

hardhat/node_modules/.bin/he

@@ -0,0 +1 @@
+../he/bin/he

hardhat/node_modules/.bin/istanbul

@@ -0,0 +1 @@
+../sc-istanbul/lib/cli.js

hardhat/node_modules/.bin/js-yaml

@@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js

hardhat/node_modules/.bin/json5

@@ -0,0 +1 @@
+../json5/lib/cli.js

hardhat/node_modules/.bin/mkdirp

@@ -0,0 +1 @@
+../mkdirp/bin/cmd.js

hardhat/node_modules/.bin/mocha

@@ -0,0 +1 @@
+../mocha/bin/mocha.js

hardhat/node_modules/.bin/ndjson

@@ -0,0 +1 @@
+../ndjson/cli.js

hardhat/node_modules/.bin/node-gyp-build

@@ -0,0 +1 @@
+../node-gyp-build/bin.js

hardhat/node_modules/.bin/node-gyp-build-optional

@@ -0,0 +1 @@
+../node-gyp-build/optional.js

hardhat/node_modules/.bin/node-gyp-build-test

@@ -0,0 +1 @@
+../node-gyp-build/build-test.js

hardhat/node_modules/.bin/nopt

@@ -0,0 +1 @@
+../nopt/bin/nopt.js

hardhat/node_modules/.bin/prettier

@@ -0,0 +1 @@
+../prettier/bin-prettier.js

hardhat/node_modules/.bin/rlp

@@ -0,0 +1 @@
+../rlp/bin/rlp

hardhat/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

hardhat/node_modules/.bin/sha.js

@@ -0,0 +1 @@
+../sha.js/bin.js

hardhat/node_modules/.bin/shjs

@@ -0,0 +1 @@
+../shelljs/bin/shjs

hardhat/node_modules/.bin/solcjs

@@ -0,0 +1 @@
+../solc/solc.js

hardhat/node_modules/.bin/solidity-coverage

@@ -0,0 +1 @@
+../solidity-coverage/plugins/bin.js

hardhat/node_modules/.bin/testrpc-sc

@@ -0,0 +1 @@
+../ghost-testrpc/index.js

hardhat/node_modules/.bin/ts-node

@@ -0,0 +1 @@
+../ts-node/dist/bin.js

hardhat/node_modules/.bin/ts-node-cwd

@@ -0,0 +1 @@
+../ts-node/dist/bin-cwd.js

hardhat/node_modules/.bin/ts-node-esm

@@ -0,0 +1 @@
+../ts-node/dist/bin-esm.js

hardhat/node_modules/.bin/ts-node-script

@@ -0,0 +1 @@
+../ts-node/dist/bin-script.js

hardhat/node_modules/.bin/ts-node-transpile-only

@@ -0,0 +1 @@
+../ts-node/dist/bin-transpile.js

hardhat/node_modules/.bin/ts-script

@@ -0,0 +1 @@
+../ts-node/dist/bin-script-deprecated.js

hardhat/node_modules/.bin/tsc

@@ -0,0 +1 @@
+../typescript/bin/tsc

hardhat/node_modules/.bin/tsserver

@@ -0,0 +1 @@
+../typescript/bin/tsserver

hardhat/node_modules/.bin/typechain

@@ -0,0 +1 @@
+../typechain/dist/cli/cli.js

hardhat/node_modules/.bin/uglifyjs

@@ -0,0 +1 @@
+../uglify-js/bin/uglifyjs

hardhat/node_modules/.bin/uuid

@@ -0,0 +1 @@
+../uuid/dist/bin/uuid

hardhat/node_modules/.bin/which

@@ -0,0 +1 @@
+../which/bin/which

hardhat/node_modules/.bin/write-markdown

@@ -0,0 +1 @@
+../ts-command-line-args/dist/write-markdown.js

hardhat/node_modules/@adraffy/ens-normalize/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Andrew Raffensperger
+
+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.

hardhat/node_modules/@adraffy/ens-normalize/README.md

@@ -0,0 +1,206 @@
+# ens-normalize.js
+0-dependancy [Ethereum Name Service](https://ens.domains/) (ENS) Name Normalizer.
+
+* 🏛️ Follows [ENSIP-15: ENS Name Normalization Standard](https://docs.ens.domains/ens-improvement-proposals/ensip-15-normalization-standard)
+	* Other implementations:
+		* Python — [namehash/ens-normalize-python](https://github.com/namehash/ens-normalize-python)
+		* C# — [adraffy/ENSNormalize.cs](https://github.com/adraffy/ENSNormalize.cs)
+		* Java — [adraffy/ENSNormalize.java](https://github.com/adraffy/ENSNormalize.java)
+		* Javascript — [ensdomains/eth-ens-namehash](https://github.com/ensdomains/eth-ens-namehash)
+	* [Breakdown Reports from ENSIP-1](https://adraffy.github.io/ens-norm-tests/test-breakdown/output-20230226/)	
+* ✅️ Passes **100%** [ENSIP-15 Validation Tests](https://adraffy.github.io/ens-normalize.js/test/validate.html)
+* ✅️ Passes **100%** [Unicode Normalization Tests](https://adraffy.github.io/ens-normalize.js/test/report-nf.html)
+* Minified File Sizes: 
+	* [`28KB`](./dist/index-xnf.min.js) — native `NFC` via [nf-native.js](./src/nf-native.js) using `String.normalize()` ⚠️
+	* [`37KB` **Default**](./dist/index.min.js) — custom `NFC` via [nf.js](./src/nf.js)
+	* [`43KB`](./dist/all.min.js) *Everything!* — custom `NFC` + sub-libraries: [parts.js](./src/parts.js), [utils.js](./src/utils.js)
+* Included Apps:
+	* [**Resolver Demo**](https://adraffy.github.io/ens-normalize.js/test/resolver.html) ⭐
+	* [Supported Emoji](https://adraffy.github.io/ens-normalize.js/test/emoji.html)
+	* [Character Viewer](https://adraffy.github.io/ens-normalize.js/test/chars.html)
+	* [Confused Explainer](https://adraffy.github.io/ens-normalize.js/test/confused.html)
+* Related Projects:
+	* [Recent .eth Registrations](https://raffy.antistupid.com/eth/ens-regs.html) • [.eth Renews](https://raffy.antistupid.com/eth/ens-renews.html)
+	* [.eth Expirations](https://raffy.antistupid.com/eth/ens-exp.html)
+	* [Emoji Frequency Explorer](https://raffy.antistupid.com/eth/ens-emoji-freq.html)
+	* [ENS+NFT Matcher](https://raffy.antistupid.com/eth/ens-nft-matcher.html)
+	* [Batch Resolver](https://raffy.antistupid.com/eth/ens-batch-resolver.html)
+	* [Label Database](https://github.com/adraffy/ens-labels/) • [Labelhash⁻¹](https://adraffy.github.io/ens-labels/demo.html)
+	* [adraffy/punycode.js](https://github.com/adraffy/punycode.js/) • [Punycode Coder](https://adraffy.github.io/punycode.js/test/demo.html)
+	* [adraffy/keccak.js](https://github.com/adraffy/keccak.js/) • [Keccak Hasher](https://adraffy.github.io/keccak.js/test/demo.html)
+	* [adraffy/emoji.js](https://github.com/adraffy/emoji.js/) • [Emoji Parser](https://adraffy.github.io/emoji.js/test/demo.html)
+
+```js
+import {ens_normalize} from '@adraffy/ens-normalize'; // or require()
+// npm i @adraffy/ens-normalize
+// browser: https://cdn.jsdelivr.net/npm/@adraffy/ens-normalize@latest/dist/index.min.mjs (or .cjs)
+
+// *** ALL errors thrown by this library are safe to print ***
+// - characters are shown as {HEX} if should_escape()
+// - potentially different bidi directions inside "quotes"
+// - 200E is used near "quotes" to prevent spillover
+// - an "error type" can be extracted by slicing up to the first (:)
+// - labels are middle-truncated with ellipsis (…) at 63 cps
+
+// string -> string
+// throws on invalid names
+// output ready for namehash
+let normalized = ens_normalize('RaFFY🚴‍♂️.eTh');
+// => "raffy🚴‍♂.eth"
+
+// note: does not enforce .eth registrar 3-character minimum
+```
+
+Format names with fully-qualified emoji:
+```js
+// works like ens_normalize()
+// output ready for display
+let pretty = ens_beautify('1⃣2⃣.eth'); 
+// => "1️⃣2️⃣.eth"
+
+// note: normalization is unchanged:
+// ens_normalize(ens_beautify(x)) == ens_normalize(x)
+```
+
+Normalize name fragments for [substring search](./test/fragment.js):
+```js
+// these fragments fail ens_normalize() 
+// but will normalize fine as fragments
+let frag1 = ens_normalize_fragment('AB--');    // expected error: label ext
+let frag2 = ens_normalize_fragment('\u{303}'); // expected error: leading cm
+let frag3 = ens_normalize_fragment('οо');      // expected error: mixture
+```
+
+Input-based tokenization:
+```js
+// string -> Token[]
+// never throws
+let tokens = ens_tokenize('_R💩\u{FE0F}a\u{FE0F}\u{304}\u{AD}./');
+// [
+//     { type: 'valid', cp: [ 95 ] }, // valid (as-is)
+//     {
+//         type: 'mapped', 
+//         cp: 82,         // input
+//         cps: [ 114 ]    // output
+//     }, 
+//     { 
+//         type: 'emoji',
+//         input: Emoji(2) [ 128169, 65039 ],  // input 
+//         emoji: [ 128169, 65039 ],           // fully-qualified
+//         cps: Emoji(1) [ 128169 ]            // output (normalized)
+//     },
+//     {
+//         type: 'nfc',
+//         input: [ 97, 772 ],  // input  (before nfc)
+//         tokens0: [           // tokens (before nfc)
+//             { type: 'valid', cps: [ 97 ] },
+//             { type: 'ignored', cp: 65039 },
+//             { type: 'valid', cps: [ 772 ] }
+//         ],
+//         cps: [ 257 ],        // output (after nfc)
+//         tokens: [            // tokens (after nfc)
+//             { type: 'valid', cps: [ 257 ] }
+//         ]
+//     },
+//     { type: 'ignored', cp: 173 },
+//     { type: 'stop', cp: 46 },
+//     { type: 'disallowed', cp: 47 }
+// ]
+
+// note: if name is normalizable, then:
+// ens_normalize(ens_tokenize(name).map(token => {
+//     ** convert valid/mapped/nfc/stop to string **
+// }).join('')) == ens_normalize(name)
+```
+
+Output-based tokenization:
+```js
+// string -> Label[]
+// never throws
+let labels = ens_split('💩Raffy.eth_');
+// [
+//   {
+//     input: [ 128169, 82, 97, 102, 102, 121 ],  
+//     offset: 0, // index of codepoint, not substring index!
+//                // (corresponding length can be inferred from input)
+//     tokens: [
+//       Emoji(2) [ 128169, 65039 ],   // emoji
+//       [ 114, 97, 102, 102, 121 ]    // nfc-text
+//     ],
+//     output: [ 128169, 114, 97, 102, 102, 121 ],
+//     emoji: true,
+//     type: 'Latin'
+//   },
+//   {
+//     input: [ 101, 116, 104, 95 ],
+//     offset: 7,
+//     tokens: [ [ 101, 116, 104, 95 ] ],
+//     output: [ 101, 116, 104, 95 ],
+//     error: Error('underscore allowed only at start')
+//   }
+// ]
+```
+
+Generate a sorted array of (beautified) supported emoji codepoints:
+```js
+// () -> number[][]
+let emojis = ens_emoji();
+// [
+//     [ 2764 ],
+//     [ 128169, 65039 ],
+//     [ 128105, 127997, 8205, 9877, 65039 ],
+//     ...
+// ]
+```
+
+Determine if a character shouldn't be printed directly:
+```js
+// number -> bool
+should_escape(0x202E); // eg. RIGHT-TO-LEFT OVERRIDE => true
+```
+
+Determine if a character is a combining mark:
+```js
+// number -> bool
+is_combining_mark(0x20E3); // eg. COMBINING ENCLOSING KEYCAP => true
+```
+
+Format codepoints as print-safe string:
+```js
+// number[] -> string
+safe_str_from_cps([0x300, 0, 32, 97]); // "◌̀{00} a"
+safe_str_from_cps(Array(100).fill(97), 4); // "aa…aa" => middle-truncated
+```
+
+## Build
+
+* `git clone` this repo, then `npm install` 
+* Follow instructions in [/derive/](./derive/) to generate data files
+	* `npm run derive` 
+		* [spec.json](./derive/output/spec.json)
+		* [nf.json](./derive/output/nf.json)
+		* [nf-tests.json](./derive/output/nf-tests.json)
+* `npm run make` — compress data files from [/derive/output/](./derive/output/)
+	* [include-ens.js](./src/include-ens.js)
+	* [include-nf.js](./src/include-nf.js)
+	* [include-versions.js](./src/include-versions.js)
+* Follow instructions in [/validate/](./validate/) to generate validation tests
+	* `npm run validate`
+		* [tests.json](./validate/tests.json)
+* `npm run test` — perform validation tests
+* `npm run build` — create [/dist/](./dist/)
+* `npm run rebuild` — run all the commands above
+* `npm run order` — create optimal group ordering and rebuild again
+
+### Publishing to NPM
+
+This project uses `.js` instead of `.mjs` so [package.json](./package.json) uses `type: module`.  To avoid bundling issues, `type` is [dropped during packing](./src/prepost.js).  `pre/post` hooks aren't used because they're buggy.
+* `npm run pack` instead of `npm pack`
+* `npm run pub` instead of `npm publish`
+
+## Security
+
+* [Build](#build) and compare against [include-versions.js](./src/include-versions.js)
+	* `spec_hash` — SHA-256 of [spec.json](./derive/output/spec.json) bytes
+	* `base64_ens_hash` — SHA-256 of [include-ens.js](./src/include-ens.js) base64 literal
+	* `base64_nf_hash` — SHA-256 of [include-nf.js](./src/include-nf.js) base64 literal

hardhat/node_modules/@adraffy/ens-normalize/dist/index.d.ts

@@ -0,0 +1,59 @@
+interface DisallowedToken {
+	type: 'disallowed';
+	cp: number;
+}
+interface IgnoredToken {
+	type: 'ignored';
+	cp: number;
+}
+interface ValidToken {
+	type: 'valid';
+	cps: number[];
+}
+interface MappedToken {
+	type: 'mapped';	
+	cp: number;
+	cps: number[];
+}
+type TextToken = DisallowedToken | IgnoredToken | ValidToken | MappedToken;
+interface EmojiToken {
+	type: 'emoji';
+	input: number[];
+	emoji: number[];
+	cps: number[];
+}
+interface NFCToken {
+	type: 'nfc';
+	input: number[];
+	cps: number[];
+	tokens: TextToken[]; 
+}
+interface StopToken {
+	type: 'stop';
+}
+type Token = TextToken | EmojiToken | NFCToken | StopToken;
+
+interface Label {
+	input: number[];
+	offset: number;
+	error?: Error;
+	tokens?: number[][];
+	output?: number[];
+	emoji?: boolean;
+	type?: string;
+}
+
+export function ens_normalize(name: string): string;
+export function ens_normalize_fragment(frag: string, decompose?: boolean): string;
+export function ens_beautify(name: string): string;
+export function ens_tokenize(name: string, options?: {nf?: boolean}): Token[];
+export function ens_split(name: string, preserve_emoji?: boolean): Label[];
+
+export function ens_emoji(): number[][];
+
+export function should_escape(cp: number): boolean;
+export function is_combining_mark(cp: number): boolean;
+export function safe_str_from_cps(cps: number[]): string;
+
+export function nfd(cps: number[]): number[];
+export function nfc(cps: number[]): number[];

hardhat/node_modules/@adraffy/ens-normalize/package.json

@@ -0,0 +1,76 @@
+{
+	"name": "@adraffy/ens-normalize",
+	"version": "1.10.1",
+	"description": "Ethereum Name Service (ENS) Name Normalizer",
+	"keywords": [
+		"ENS",
+		"ENSIP-1",
+		"ENSIP-15",
+		"Ethereum",
+		"UTS-46",
+		"UTS-51",
+		"IDNA",
+		"Name",
+		"Normalize",
+		"Normalization",
+		"NFC",
+		"NFD"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"default": "./dist/index.cjs"
+		},
+		"./xnf": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index-xnf.mjs",
+			"default": "./dist/index-xnf.cjs"
+		}
+	},
+	"types": "./dist/index.d.ts",
+	"typesVersions": {
+		"*": {
+			"*": [
+				"./dist/index.d.ts"
+			]
+		}
+	},
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.mjs",
+	"files": [
+		"./dist"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/adraffy/ens-normalize.js.git"
+	},
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/adraffy/ens-normalize.js/issues"
+	},
+	"homepage": "https://github.com/adraffy/ens-normalize.js#readme",
+	"author": {
+		"name": "raffy.eth",
+		"email": "raffy@me.com",
+		"url": "http://raffy.antistupid.com"
+	},
+	"scripts": {
+		"unicode": "node derive/download.js",
+		"labels": "node validate/download-labels.js",
+		"derive": "node derive/make.js",
+		"make": "node src/make.js",
+		"validate": "node validate/make.js",
+		"test": "node test/coder.js && node test/nf.js && node test/validate.js && node test/init.js",
+		"build": "rollup -c",
+		"rebuild": "npm run derive && npm run make && npm run validate && npm run test && npm run build",
+		"order": "node validate/dump-group-order.js save && npm run rebuild",
+		"pack": "node ./src/prepost.js pack",
+		"pub": "node ./src/prepost.js publish"
+	},
+	"devDependencies": {
+		"@rollup/plugin-alias": "^5.0.0",
+		"@rollup/plugin-terser": "^0.4.0",
+		"rollup": "^3.24.1"
+	}
+}

hardhat/node_modules/@cspotcode/source-map-support/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Evan Wallace
+
+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.

hardhat/node_modules/@cspotcode/source-map-support/README.md

@@ -0,0 +1,289 @@
+# Source Map Support
+
+[![NPM version](https://img.shields.io/npm/v/@cspotcode/source-map-support.svg?style=flat)](https://npmjs.org/package/@cspotcode/source-map-support)
+[![NPM downloads](https://img.shields.io/npm/dm/@cspotcode/source-map-support.svg?style=flat)](https://npmjs.org/package/@cspotcode/source-map-support)
+[![Build status](https://img.shields.io/github/workflow/status/cspotcode/node-source-map-support/Continuous%20Integration)](https://github.com/cspotcode/node-source-map-support/actions?query=workflow%3A%22Continuous+Integration%22)
+
+This module provides source map support for stack traces in node via the [V8 stack trace API](https://github.com/v8/v8/wiki/Stack-Trace-API). It uses the [source-map](https://github.com/mozilla/source-map) module to replace the paths and line numbers of source-mapped files with their original paths and line numbers. The output mimics node's stack trace format with the goal of making every compile-to-JS language more of a first-class citizen. Source maps are completely general (not specific to any one language) so you can use source maps with multiple compile-to-JS languages in the same node process.
+
+## Installation and Usage
+
+#### Node support
+
+```
+$ npm install @cspotcode/source-map-support
+```
+
+Source maps can be generated using libraries such as [source-map-index-generator](https://github.com/twolfson/source-map-index-generator). Once you have a valid source map, place a source mapping comment somewhere in the file (usually done automatically or with an option by your transpiler):
+
+```
+//# sourceMappingURL=path/to/source.map
+```
+
+If multiple sourceMappingURL comments exist in one file, the last sourceMappingURL comment will be
+respected (e.g. if a file mentions the comment in code, or went through multiple transpilers).
+The path should either be absolute or relative to the compiled file.
+
+From here you have two options.
+
+##### CLI Usage
+
+```bash
+node -r @cspotcode/source-map-support/register compiled.js
+# Or to enable hookRequire
+node -r @cspotcode/source-map-support/register-hook-require compiled.js
+```
+
+##### Programmatic Usage
+
+Put the following line at the top of the compiled file.
+
+```js
+require('@cspotcode/source-map-support').install();
+```
+
+It is also possible to install the source map support directly by
+requiring the `register` module which can be handy with ES6:
+
+```js
+import '@cspotcode/source-map-support/register'
+
+// Instead of:
+import sourceMapSupport from '@cspotcode/source-map-support'
+sourceMapSupport.install()
+```
+Note: if you're using babel-register, it includes source-map-support already.
+
+It is also very useful with Mocha:
+
+```
+$ mocha --require @cspotcode/source-map-support/register tests/
+```
+
+#### Browser support
+
+This library also works in Chrome. While the DevTools console already supports source maps, the V8 engine doesn't and `Error.prototype.stack` will be incorrect without this library. Everything will just work if you deploy your source files using [browserify](http://browserify.org/). Just make sure to pass the `--debug` flag to the browserify command so your source maps are included in the bundled code.
+
+This library also works if you use another build process or just include the source files directly. In this case, include the file `browser-source-map-support.js` in your page and call `sourceMapSupport.install()`. It contains the whole library already bundled for the browser using browserify.
+
+```html
+<script src="browser-source-map-support.js"></script>
+<script>sourceMapSupport.install();</script>
+```
+
+This library also works if you use AMD (Asynchronous Module Definition), which is used in tools like [RequireJS](http://requirejs.org/). Just list `browser-source-map-support` as a dependency:
+
+```html
+<script>
+  define(['browser-source-map-support'], function(sourceMapSupport) {
+    sourceMapSupport.install();
+  });
+</script>
+```
+
+## Options
+
+This module installs two things: a change to the `stack` property on `Error` objects and a handler for uncaught exceptions that mimics node's default exception handler (the handler can be seen in the demos below). You may want to disable the handler if you have your own uncaught exception handler. This can be done by passing an argument to the installer:
+
+```js
+require('@cspotcode/source-map-support').install({
+  handleUncaughtExceptions: false
+});
+```
+
+This module loads source maps from the filesystem by default. You can provide alternate loading behavior through a callback as shown below. For example, [Meteor](https://github.com/meteor) keeps all source maps cached in memory to avoid disk access.
+
+```js
+require('@cspotcode/source-map-support').install({
+  retrieveSourceMap: function(source) {
+    if (source === 'compiled.js') {
+      return {
+        url: 'original.js',
+        map: fs.readFileSync('compiled.js.map', 'utf8')
+      };
+    }
+    return null;
+  }
+});
+```
+
+The module will by default assume a browser environment if XMLHttpRequest and window are defined. If either of these do not exist it will instead assume a node environment.
+In some rare cases, e.g. when running a browser emulation and where both variables are also set, you can explictly specify the environment to be either 'browser' or 'node'.
+
+```js
+require('@cspotcode/source-map-support').install({
+  environment: 'node'
+});
+```
+
+To support files with inline source maps, the `hookRequire` options can be specified, which will monitor all source files for inline source maps.
+
+
+```js
+require('@cspotcode/source-map-support').install({
+  hookRequire: true
+});
+```
+
+This monkey patches the `require` module loading chain, so is not enabled by default and is not recommended for any sort of production usage.
+
+## Demos
+
+#### Basic Demo
+
+original.js:
+
+```js
+throw new Error('test'); // This is the original code
+```
+
+compiled.js:
+
+```js
+require('@cspotcode/source-map-support').install();
+
+throw new Error('test'); // This is the compiled code
+// The next line defines the sourceMapping.
+//# sourceMappingURL=compiled.js.map
+```
+
+compiled.js.map:
+
+```json
+{
+  "version": 3,
+  "file": "compiled.js",
+  "sources": ["original.js"],
+  "names": [],
+  "mappings": ";;AAAA,MAAM,IAAI"
+}
+```
+
+Run compiled.js using node (notice how the stack trace uses original.js instead of compiled.js):
+
+```
+$ node compiled.js
+
+original.js:1
+throw new Error('test'); // This is the original code
+      ^
+Error: test
+    at Object.<anonymous> (original.js:1:7)
+    at Module._compile (module.js:456:26)
+    at Object.Module._extensions..js (module.js:474:10)
+    at Module.load (module.js:356:32)
+    at Function.Module._load (module.js:312:12)
+    at Function.Module.runMain (module.js:497:10)
+    at startup (node.js:119:16)
+    at node.js:901:3
+```
+
+#### TypeScript Demo
+
+demo.ts:
+
+```typescript
+declare function require(name: string);
+require('@cspotcode/source-map-support').install();
+class Foo {
+  constructor() { this.bar(); }
+  bar() { throw new Error('this is a demo'); }
+}
+new Foo();
+```
+
+Compile and run the file using the TypeScript compiler from the terminal:
+
+```
+$ npm install source-map-support typescript
+$ node_modules/typescript/bin/tsc -sourcemap demo.ts
+$ node demo.js
+
+demo.ts:5
+  bar() { throw new Error('this is a demo'); }
+                ^
+Error: this is a demo
+    at Foo.bar (demo.ts:5:17)
+    at new Foo (demo.ts:4:24)
+    at Object.<anonymous> (demo.ts:7:1)
+    at Module._compile (module.js:456:26)
+    at Object.Module._extensions..js (module.js:474:10)
+    at Module.load (module.js:356:32)
+    at Function.Module._load (module.js:312:12)
+    at Function.Module.runMain (module.js:497:10)
+    at startup (node.js:119:16)
+    at node.js:901:3
+```
+
+There is also the option to use `-r source-map-support/register` with typescript, without the need add the `require('@cspotcode/source-map-support').install()` in the code base:
+
+```
+$ npm install source-map-support typescript
+$ node_modules/typescript/bin/tsc  -sourcemap demo.ts
+$ node -r source-map-support/register demo.js
+
+demo.ts:5
+  bar() { throw new Error('this is a demo'); }
+                ^
+Error: this is a demo
+    at Foo.bar (demo.ts:5:17)
+    at new Foo (demo.ts:4:24)
+    at Object.<anonymous> (demo.ts:7:1)
+    at Module._compile (module.js:456:26)
+    at Object.Module._extensions..js (module.js:474:10)
+    at Module.load (module.js:356:32)
+    at Function.Module._load (module.js:312:12)
+    at Function.Module.runMain (module.js:497:10)
+    at startup (node.js:119:16)
+    at node.js:901:3
+```
+
+#### CoffeeScript Demo
+
+demo.coffee:
+
+```coffee
+require('@cspotcode/source-map-support').install()
+foo = ->
+  bar = -> throw new Error 'this is a demo'
+  bar()
+foo()
+```
+
+Compile and run the file using the CoffeeScript compiler from the terminal:
+
+```sh
+$ npm install @cspotcode/source-map-support coffeescript
+$ node_modules/.bin/coffee --map --compile demo.coffee
+$ node demo.js
+
+demo.coffee:3
+  bar = -> throw new Error 'this is a demo'
+                     ^
+Error: this is a demo
+    at bar (demo.coffee:3:22)
+    at foo (demo.coffee:4:3)
+    at Object.<anonymous> (demo.coffee:5:1)
+    at Object.<anonymous> (demo.coffee:1:1)
+    at Module._compile (module.js:456:26)
+    at Object.Module._extensions..js (module.js:474:10)
+    at Module.load (module.js:356:32)
+    at Function.Module._load (module.js:312:12)
+    at Function.Module.runMain (module.js:497:10)
+    at startup (node.js:119:16)
+```
+
+## Tests
+
+This repo contains both automated tests for node and manual tests for the browser. The automated tests can be run using mocha (type `mocha` in the root directory). To run the manual tests:
+
+* Build the tests using `build.js`
+* Launch the HTTP server (`npm run serve-tests`) and visit
+  * http://127.0.0.1:1336/amd-test
+  * http://127.0.0.1:1336/browser-test
+  * http://127.0.0.1:1336/browserify-test - **Currently not working** due to a bug with browserify (see [pull request #66](https://github.com/evanw/node-source-map-support/pull/66) for details).
+* For `header-test`, run `server.js` inside that directory and visit http://127.0.0.1:1337/
+
+## License
+
+This code is available under the [MIT license](http://opensource.org/licenses/MIT).

hardhat/node_modules/@cspotcode/source-map-support/browser-source-map-support.js

@@ -0,0 +1,114 @@
+/*
+ * Support for source maps in V8 stack traces
+ * https://github.com/evanw/node-source-map-support
+ */
+/*
+ The buffer module from node.js, for the browser.
+
+ @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ license  MIT
+*/
+(this.define||function(R,U){this.sourceMapSupport=U()})("browser-source-map-support",function(R){(function e(C,J,A){function p(f,c){if(!J[f]){if(!C[f]){var l="function"==typeof require&&require;if(!c&&l)return l(f,!0);if(t)return t(f,!0);throw Error("Cannot find module '"+f+"'");}l=J[f]={exports:{}};C[f][0].call(l.exports,function(q){var r=C[f][1][q];return p(r?r:q)},l,l.exports,e,C,J,A)}return J[f].exports}for(var t="function"==typeof require&&require,m=0;m<A.length;m++)p(A[m]);return p})({1:[function(C,
+J,A){R=C("./source-map-support")},{"./source-map-support":21}],2:[function(C,J,A){(function(e){function p(m){m=m.charCodeAt(0);if(43===m)return 62;if(47===m)return 63;if(48>m)return-1;if(58>m)return m-48+52;if(91>m)return m-65;if(123>m)return m-97+26}var t="undefined"!==typeof Uint8Array?Uint8Array:Array;e.toByteArray=function(m){function f(d){q[k++]=d}if(0<m.length%4)throw Error("Invalid string. Length must be a multiple of 4");var c=m.length;var l="="===m.charAt(c-2)?2:"="===m.charAt(c-1)?1:0;var q=
+new t(3*m.length/4-l);var r=0<l?m.length-4:m.length;var k=0;for(c=0;c<r;c+=4){var u=p(m.charAt(c))<<18|p(m.charAt(c+1))<<12|p(m.charAt(c+2))<<6|p(m.charAt(c+3));f((u&16711680)>>16);f((u&65280)>>8);f(u&255)}2===l?(u=p(m.charAt(c))<<2|p(m.charAt(c+1))>>4,f(u&255)):1===l&&(u=p(m.charAt(c))<<10|p(m.charAt(c+1))<<4|p(m.charAt(c+2))>>2,f(u>>8&255),f(u&255));return q};e.fromByteArray=function(m){var f=m.length%3,c="",l;var q=0;for(l=m.length-f;q<l;q+=3){var r=(m[q]<<16)+(m[q+1]<<8)+m[q+2];r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r>>
+18&63)+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r>>12&63)+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r>>6&63)+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r&63);c+=r}switch(f){case 1:r=m[m.length-1];c+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r>>2);c+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r<<4&63);c+="==";break;case 2:r=(m[m.length-2]<<8)+
+m[m.length-1],c+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r>>10),c+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r>>4&63),c+="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(r<<2&63),c+="="}return c}})("undefined"===typeof A?this.base64js={}:A)},{}],3:[function(C,J,A){},{}],4:[function(C,J,A){(function(e){var p=Object.prototype.toString,t="function"===typeof e.alloc&&"function"===typeof e.allocUnsafe&&"function"===
+typeof e.from;J.exports=function(m,f,c){if("number"===typeof m)throw new TypeError('"value" argument must not be a number');if("ArrayBuffer"===p.call(m).slice(8,-1)){f>>>=0;var l=m.byteLength-f;if(0>l)throw new RangeError("'offset' is out of bounds");if(void 0===c)c=l;else if(c>>>=0,c>l)throw new RangeError("'length' is out of bounds");return t?e.from(m.slice(f,f+c)):new e(new Uint8Array(m.slice(f,f+c)))}if("string"===typeof m){c=f;if("string"!==typeof c||""===c)c="utf8";if(!e.isEncoding(c))throw new TypeError('"encoding" must be a valid string encoding');
+return t?e.from(m,c):new e(m,c)}return t?e.from(m):new e(m)}}).call(this,C("buffer").Buffer)},{buffer:5}],5:[function(C,J,A){function e(a,b,h){if(!(this instanceof e))return new e(a,b,h);var w=typeof a;if("number"===w)var y=0<a?a>>>0:0;else if("string"===w){if("base64"===b)for(a=(a.trim?a.trim():a.replace(/^\s+|\s+$/g,"")).replace(L,"");0!==a.length%4;)a+="=";y=e.byteLength(a,b)}else if("object"===w&&null!==a)"Buffer"===a.type&&z(a.data)&&(a=a.data),y=0<+a.length?Math.floor(+a.length):0;else throw new TypeError("must start with number, buffer, array or string");
+if(this.length>G)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+G.toString(16)+" bytes");if(e.TYPED_ARRAY_SUPPORT)var I=e._augment(new Uint8Array(y));else I=this,I.length=y,I._isBuffer=!0;if(e.TYPED_ARRAY_SUPPORT&&"number"===typeof a.byteLength)I._set(a);else{var K=a;if(z(K)||e.isBuffer(K)||K&&"object"===typeof K&&"number"===typeof K.length)if(e.isBuffer(a))for(b=0;b<y;b++)I[b]=a.readUInt8(b);else for(b=0;b<y;b++)I[b]=(a[b]%256+256)%256;else if("string"===w)I.write(a,
+0,b);else if("number"===w&&!e.TYPED_ARRAY_SUPPORT&&!h)for(b=0;b<y;b++)I[b]=0}return I}function p(a,b,h){var w="";for(h=Math.min(a.length,h);b<h;b++)w+=String.fromCharCode(a[b]);return w}function t(a,b,h){if(0!==a%1||0>a)throw new RangeError("offset is not uint");if(a+b>h)throw new RangeError("Trying to access beyond buffer length");}function m(a,b,h,w,y,I){if(!e.isBuffer(a))throw new TypeError("buffer must be a Buffer instance");if(b>y||b<I)throw new TypeError("value is out of bounds");if(h+w>a.length)throw new TypeError("index out of range");
+}function f(a,b,h,w){0>b&&(b=65535+b+1);for(var y=0,I=Math.min(a.length-h,2);y<I;y++)a[h+y]=(b&255<<8*(w?y:1-y))>>>8*(w?y:1-y)}function c(a,b,h,w){0>b&&(b=4294967295+b+1);for(var y=0,I=Math.min(a.length-h,4);y<I;y++)a[h+y]=b>>>8*(w?y:3-y)&255}function l(a,b,h,w,y,I){if(b>y||b<I)throw new TypeError("value is out of bounds");if(h+w>a.length)throw new TypeError("index out of range");}function q(a,b,h,w,y){y||l(a,b,h,4,3.4028234663852886E38,-3.4028234663852886E38);v.write(a,b,h,w,23,4);return h+4}function r(a,
+b,h,w,y){y||l(a,b,h,8,1.7976931348623157E308,-1.7976931348623157E308);v.write(a,b,h,w,52,8);return h+8}function k(a){for(var b=[],h=0;h<a.length;h++){var w=a.charCodeAt(h);if(127>=w)b.push(w);else{var y=h;55296<=w&&57343>=w&&h++;w=encodeURIComponent(a.slice(y,h+1)).substr(1).split("%");for(y=0;y<w.length;y++)b.push(parseInt(w[y],16))}}return b}function u(a){for(var b=[],h=0;h<a.length;h++)b.push(a.charCodeAt(h)&255);return b}function d(a,b,h,w,y){y&&(w-=w%y);for(y=0;y<w&&!(y+h>=b.length||y>=a.length);y++)b[y+
+h]=a[y];return y}function g(a){try{return decodeURIComponent(a)}catch(b){return String.fromCharCode(65533)}}var n=C("base64-js"),v=C("ieee754"),z=C("is-array");A.Buffer=e;A.SlowBuffer=e;A.INSPECT_MAX_BYTES=50;e.poolSize=8192;var G=1073741823;e.TYPED_ARRAY_SUPPORT=function(){try{var a=new ArrayBuffer(0),b=new Uint8Array(a);b.foo=function(){return 42};return 42===b.foo()&&"function"===typeof b.subarray&&0===(new Uint8Array(1)).subarray(1,1).byteLength}catch(h){return!1}}();e.isBuffer=function(a){return!(null==
+a||!a._isBuffer)};e.compare=function(a,b){if(!e.isBuffer(a)||!e.isBuffer(b))throw new TypeError("Arguments must be Buffers");for(var h=a.length,w=b.length,y=0,I=Math.min(h,w);y<I&&a[y]===b[y];y++);y!==I&&(h=a[y],w=b[y]);return h<w?-1:w<h?1:0};e.isEncoding=function(a){switch(String(a).toLowerCase()){case "hex":case "utf8":case "utf-8":case "ascii":case "binary":case "base64":case "raw":case "ucs2":case "ucs-2":case "utf16le":case "utf-16le":return!0;default:return!1}};e.concat=function(a,b){if(!z(a))throw new TypeError("Usage: Buffer.concat(list[, length])");
+if(0===a.length)return new e(0);if(1===a.length)return a[0];var h;if(void 0===b)for(h=b=0;h<a.length;h++)b+=a[h].length;var w=new e(b),y=0;for(h=0;h<a.length;h++){var I=a[h];I.copy(w,y);y+=I.length}return w};e.byteLength=function(a,b){a+="";switch(b||"utf8"){case "ascii":case "binary":case "raw":var h=a.length;break;case "ucs2":case "ucs-2":case "utf16le":case "utf-16le":h=2*a.length;break;case "hex":h=a.length>>>1;break;case "utf8":case "utf-8":h=k(a).length;break;case "base64":h=n.toByteArray(a).length;
+break;default:h=a.length}return h};e.prototype.length=void 0;e.prototype.parent=void 0;e.prototype.toString=function(a,b,h){var w=!1;b>>>=0;h=void 0===h||Infinity===h?this.length:h>>>0;a||(a="utf8");0>b&&(b=0);h>this.length&&(h=this.length);if(h<=b)return"";for(;;)switch(a){case "hex":a=b;b=h;h=this.length;if(!a||0>a)a=0;if(!b||0>b||b>h)b=h;w="";for(h=a;h<b;h++)a=w,w=this[h],w=16>w?"0"+w.toString(16):w.toString(16),w=a+w;return w;case "utf8":case "utf-8":w=a="";for(h=Math.min(this.length,h);b<h;b++)127>=
+this[b]?(a+=g(w)+String.fromCharCode(this[b]),w=""):w+="%"+this[b].toString(16);return a+g(w);case "ascii":return p(this,b,h);case "binary":return p(this,b,h);case "base64":return b=0===b&&h===this.length?n.fromByteArray(this):n.fromByteArray(this.slice(b,h)),b;case "ucs2":case "ucs-2":case "utf16le":case "utf-16le":b=this.slice(b,h);h="";for(a=0;a<b.length;a+=2)h+=String.fromCharCode(b[a]+256*b[a+1]);return h;default:if(w)throw new TypeError("Unknown encoding: "+a);a=(a+"").toLowerCase();w=!0}};
+e.prototype.equals=function(a){if(!e.isBuffer(a))throw new TypeError("Argument must be a Buffer");return 0===e.compare(this,a)};e.prototype.inspect=function(){var a="",b=A.INSPECT_MAX_BYTES;0<this.length&&(a=this.toString("hex",0,b).match(/.{2}/g).join(" "),this.length>b&&(a+=" ... "));return"<Buffer "+a+">"};e.prototype.compare=function(a){if(!e.isBuffer(a))throw new TypeError("Argument must be a Buffer");return e.compare(this,a)};e.prototype.get=function(a){console.log(".get() is deprecated. Access using array indexes instead.");
+return this.readUInt8(a)};e.prototype.set=function(a,b){console.log(".set() is deprecated. Access using array indexes instead.");return this.writeUInt8(a,b)};e.prototype.write=function(a,b,h,w){if(isFinite(b))isFinite(h)||(w=h,h=void 0);else{var y=w;w=b;b=h;h=y}b=Number(b)||0;y=this.length-b;h?(h=Number(h),h>y&&(h=y)):h=y;w=String(w||"utf8").toLowerCase();switch(w){case "hex":b=Number(b)||0;w=this.length-b;h?(h=Number(h),h>w&&(h=w)):h=w;w=a.length;if(0!==w%2)throw Error("Invalid hex string");h>w/
+2&&(h=w/2);for(w=0;w<h;w++){y=parseInt(a.substr(2*w,2),16);if(isNaN(y))throw Error("Invalid hex string");this[b+w]=y}a=w;break;case "utf8":case "utf-8":a=d(k(a),this,b,h);break;case "ascii":a=d(u(a),this,b,h);break;case "binary":a=d(u(a),this,b,h);break;case "base64":a=d(n.toByteArray(a),this,b,h);break;case "ucs2":case "ucs-2":case "utf16le":case "utf-16le":y=[];for(var I=0;I<a.length;I++){var K=a.charCodeAt(I);w=K>>8;K%=256;y.push(K);y.push(w)}a=d(y,this,b,h,2);break;default:throw new TypeError("Unknown encoding: "+
+w);}return a};e.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};e.prototype.slice=function(a,b){var h=this.length;a=~~a;b=void 0===b?h:~~b;0>a?(a+=h,0>a&&(a=0)):a>h&&(a=h);0>b?(b+=h,0>b&&(b=0)):b>h&&(b=h);b<a&&(b=a);if(e.TYPED_ARRAY_SUPPORT)return e._augment(this.subarray(a,b));h=b-a;for(var w=new e(h,void 0,!0),y=0;y<h;y++)w[y]=this[y+a];return w};e.prototype.readUInt8=function(a,b){b||t(a,1,this.length);return this[a]};e.prototype.readUInt16LE=
+function(a,b){b||t(a,2,this.length);return this[a]|this[a+1]<<8};e.prototype.readUInt16BE=function(a,b){b||t(a,2,this.length);return this[a]<<8|this[a+1]};e.prototype.readUInt32LE=function(a,b){b||t(a,4,this.length);return(this[a]|this[a+1]<<8|this[a+2]<<16)+16777216*this[a+3]};e.prototype.readUInt32BE=function(a,b){b||t(a,4,this.length);return 16777216*this[a]+(this[a+1]<<16|this[a+2]<<8|this[a+3])};e.prototype.readInt8=function(a,b){b||t(a,1,this.length);return this[a]&128?-1*(255-this[a]+1):this[a]};
+e.prototype.readInt16LE=function(a,b){b||t(a,2,this.length);var h=this[a]|this[a+1]<<8;return h&32768?h|4294901760:h};e.prototype.readInt16BE=function(a,b){b||t(a,2,this.length);var h=this[a+1]|this[a]<<8;return h&32768?h|4294901760:h};e.prototype.readInt32LE=function(a,b){b||t(a,4,this.length);return this[a]|this[a+1]<<8|this[a+2]<<16|this[a+3]<<24};e.prototype.readInt32BE=function(a,b){b||t(a,4,this.length);return this[a]<<24|this[a+1]<<16|this[a+2]<<8|this[a+3]};e.prototype.readFloatLE=function(a,
+b){b||t(a,4,this.length);return v.read(this,a,!0,23,4)};e.prototype.readFloatBE=function(a,b){b||t(a,4,this.length);return v.read(this,a,!1,23,4)};e.prototype.readDoubleLE=function(a,b){b||t(a,8,this.length);return v.read(this,a,!0,52,8)};e.prototype.readDoubleBE=function(a,b){b||t(a,8,this.length);return v.read(this,a,!1,52,8)};e.prototype.writeUInt8=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,1,255,0);e.TYPED_ARRAY_SUPPORT||(a=Math.floor(a));this[b]=a;return b+1};e.prototype.writeUInt16LE=function(a,
+b,h){a=+a;b>>>=0;h||m(this,a,b,2,65535,0);e.TYPED_ARRAY_SUPPORT?(this[b]=a,this[b+1]=a>>>8):f(this,a,b,!0);return b+2};e.prototype.writeUInt16BE=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,2,65535,0);e.TYPED_ARRAY_SUPPORT?(this[b]=a>>>8,this[b+1]=a):f(this,a,b,!1);return b+2};e.prototype.writeUInt32LE=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,4,4294967295,0);e.TYPED_ARRAY_SUPPORT?(this[b+3]=a>>>24,this[b+2]=a>>>16,this[b+1]=a>>>8,this[b]=a):c(this,a,b,!0);return b+4};e.prototype.writeUInt32BE=function(a,
+b,h){a=+a;b>>>=0;h||m(this,a,b,4,4294967295,0);e.TYPED_ARRAY_SUPPORT?(this[b]=a>>>24,this[b+1]=a>>>16,this[b+2]=a>>>8,this[b+3]=a):c(this,a,b,!1);return b+4};e.prototype.writeInt8=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,1,127,-128);e.TYPED_ARRAY_SUPPORT||(a=Math.floor(a));0>a&&(a=255+a+1);this[b]=a;return b+1};e.prototype.writeInt16LE=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,2,32767,-32768);e.TYPED_ARRAY_SUPPORT?(this[b]=a,this[b+1]=a>>>8):f(this,a,b,!0);return b+2};e.prototype.writeInt16BE=function(a,
+b,h){a=+a;b>>>=0;h||m(this,a,b,2,32767,-32768);e.TYPED_ARRAY_SUPPORT?(this[b]=a>>>8,this[b+1]=a):f(this,a,b,!1);return b+2};e.prototype.writeInt32LE=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,4,2147483647,-2147483648);e.TYPED_ARRAY_SUPPORT?(this[b]=a,this[b+1]=a>>>8,this[b+2]=a>>>16,this[b+3]=a>>>24):c(this,a,b,!0);return b+4};e.prototype.writeInt32BE=function(a,b,h){a=+a;b>>>=0;h||m(this,a,b,4,2147483647,-2147483648);0>a&&(a=4294967295+a+1);e.TYPED_ARRAY_SUPPORT?(this[b]=a>>>24,this[b+1]=a>>>16,this[b+
+2]=a>>>8,this[b+3]=a):c(this,a,b,!1);return b+4};e.prototype.writeFloatLE=function(a,b,h){return q(this,a,b,!0,h)};e.prototype.writeFloatBE=function(a,b,h){return q(this,a,b,!1,h)};e.prototype.writeDoubleLE=function(a,b,h){return r(this,a,b,!0,h)};e.prototype.writeDoubleBE=function(a,b,h){return r(this,a,b,!1,h)};e.prototype.copy=function(a,b,h,w){h||(h=0);w||0===w||(w=this.length);b||(b=0);if(w!==h&&0!==a.length&&0!==this.length){if(w<h)throw new TypeError("sourceEnd < sourceStart");if(0>b||b>=a.length)throw new TypeError("targetStart out of bounds");
+if(0>h||h>=this.length)throw new TypeError("sourceStart out of bounds");if(0>w||w>this.length)throw new TypeError("sourceEnd out of bounds");w>this.length&&(w=this.length);a.length-b<w-h&&(w=a.length-b+h);w-=h;if(1E3>w||!e.TYPED_ARRAY_SUPPORT)for(var y=0;y<w;y++)a[y+b]=this[y+h];else a._set(this.subarray(h,h+w),b)}};e.prototype.fill=function(a,b,h){a||(a=0);b||(b=0);h||(h=this.length);if(h<b)throw new TypeError("end < start");if(h!==b&&0!==this.length){if(0>b||b>=this.length)throw new TypeError("start out of bounds");
+if(0>h||h>this.length)throw new TypeError("end out of bounds");if("number"===typeof a)for(;b<h;b++)this[b]=a;else{a=k(a.toString());for(var w=a.length;b<h;b++)this[b]=a[b%w]}return this}};e.prototype.toArrayBuffer=function(){if("undefined"!==typeof Uint8Array){if(e.TYPED_ARRAY_SUPPORT)return(new e(this)).buffer;for(var a=new Uint8Array(this.length),b=0,h=a.length;b<h;b+=1)a[b]=this[b];return a.buffer}throw new TypeError("Buffer.toArrayBuffer not supported in this browser");};var D=e.prototype;e._augment=
+function(a){a.constructor=e;a._isBuffer=!0;a._get=a.get;a._set=a.set;a.get=D.get;a.set=D.set;a.write=D.write;a.toString=D.toString;a.toLocaleString=D.toString;a.toJSON=D.toJSON;a.equals=D.equals;a.compare=D.compare;a.copy=D.copy;a.slice=D.slice;a.readUInt8=D.readUInt8;a.readUInt16LE=D.readUInt16LE;a.readUInt16BE=D.readUInt16BE;a.readUInt32LE=D.readUInt32LE;a.readUInt32BE=D.readUInt32BE;a.readInt8=D.readInt8;a.readInt16LE=D.readInt16LE;a.readInt16BE=D.readInt16BE;a.readInt32LE=D.readInt32LE;a.readInt32BE=
+D.readInt32BE;a.readFloatLE=D.readFloatLE;a.readFloatBE=D.readFloatBE;a.readDoubleLE=D.readDoubleLE;a.readDoubleBE=D.readDoubleBE;a.writeUInt8=D.writeUInt8;a.writeUInt16LE=D.writeUInt16LE;a.writeUInt16BE=D.writeUInt16BE;a.writeUInt32LE=D.writeUInt32LE;a.writeUInt32BE=D.writeUInt32BE;a.writeInt8=D.writeInt8;a.writeInt16LE=D.writeInt16LE;a.writeInt16BE=D.writeInt16BE;a.writeInt32LE=D.writeInt32LE;a.writeInt32BE=D.writeInt32BE;a.writeFloatLE=D.writeFloatLE;a.writeFloatBE=D.writeFloatBE;a.writeDoubleLE=
+D.writeDoubleLE;a.writeDoubleBE=D.writeDoubleBE;a.fill=D.fill;a.inspect=D.inspect;a.toArrayBuffer=D.toArrayBuffer;return a};var L=/[^+\/0-9A-z]/g},{"base64-js":2,ieee754:6,"is-array":7}],6:[function(C,J,A){A.read=function(e,p,t,m,f){var c=8*f-m-1;var l=(1<<c)-1,q=l>>1,r=-7;f=t?f-1:0;var k=t?-1:1,u=e[p+f];f+=k;t=u&(1<<-r)-1;u>>=-r;for(r+=c;0<r;t=256*t+e[p+f],f+=k,r-=8);c=t&(1<<-r)-1;t>>=-r;for(r+=m;0<r;c=256*c+e[p+f],f+=k,r-=8);if(0===t)t=1-q;else{if(t===l)return c?NaN:Infinity*(u?-1:1);c+=Math.pow(2,
+m);t-=q}return(u?-1:1)*c*Math.pow(2,t-m)};A.write=function(e,p,t,m,f,c){var l,q=8*c-f-1,r=(1<<q)-1,k=r>>1,u=23===f?Math.pow(2,-24)-Math.pow(2,-77):0;c=m?0:c-1;var d=m?1:-1,g=0>p||0===p&&0>1/p?1:0;p=Math.abs(p);isNaN(p)||Infinity===p?(p=isNaN(p)?1:0,m=r):(m=Math.floor(Math.log(p)/Math.LN2),1>p*(l=Math.pow(2,-m))&&(m--,l*=2),p=1<=m+k?p+u/l:p+u*Math.pow(2,1-k),2<=p*l&&(m++,l/=2),m+k>=r?(p=0,m=r):1<=m+k?(p=(p*l-1)*Math.pow(2,f),m+=k):(p=p*Math.pow(2,k-1)*Math.pow(2,f),m=0));for(;8<=f;e[t+c]=p&255,c+=
+d,p/=256,f-=8);m=m<<f|p;for(q+=f;0<q;e[t+c]=m&255,c+=d,m/=256,q-=8);e[t+c-d]|=128*g}},{}],7:[function(C,J,A){var e=Object.prototype.toString;J.exports=Array.isArray||function(p){return!!p&&"[object Array]"==e.call(p)}},{}],8:[function(C,J,A){(function(e){function p(c,l){for(var q=0,r=c.length-1;0<=r;r--){var k=c[r];"."===k?c.splice(r,1):".."===k?(c.splice(r,1),q++):q&&(c.splice(r,1),q--)}if(l)for(;q--;q)c.unshift("..");return c}function t(c,l){if(c.filter)return c.filter(l);for(var q=[],r=0;r<c.length;r++)l(c[r],
+r,c)&&q.push(c[r]);return q}var m=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;A.resolve=function(){for(var c="",l=!1,q=arguments.length-1;-1<=q&&!l;q--){var r=0<=q?arguments[q]:e.cwd();if("string"!==typeof r)throw new TypeError("Arguments to path.resolve must be strings");r&&(c=r+"/"+c,l="/"===r.charAt(0))}c=p(t(c.split("/"),function(k){return!!k}),!l).join("/");return(l?"/":"")+c||"."};A.normalize=function(c){var l=A.isAbsolute(c),q="/"===f(c,-1);(c=p(t(c.split("/"),function(r){return!!r}),
+!l).join("/"))||l||(c=".");c&&q&&(c+="/");return(l?"/":"")+c};A.isAbsolute=function(c){return"/"===c.charAt(0)};A.join=function(){var c=Array.prototype.slice.call(arguments,0);return A.normalize(t(c,function(l,q){if("string"!==typeof l)throw new TypeError("Arguments to path.join must be strings");return l}).join("/"))};A.relative=function(c,l){function q(n){for(var v=0;v<n.length&&""===n[v];v++);for(var z=n.length-1;0<=z&&""===n[z];z--);return v>z?[]:n.slice(v,z-v+1)}c=A.resolve(c).substr(1);l=A.resolve(l).substr(1);
+for(var r=q(c.split("/")),k=q(l.split("/")),u=Math.min(r.length,k.length),d=u,g=0;g<u;g++)if(r[g]!==k[g]){d=g;break}u=[];for(g=d;g<r.length;g++)u.push("..");u=u.concat(k.slice(d));return u.join("/")};A.sep="/";A.delimiter=":";A.dirname=function(c){var l=m.exec(c).slice(1);c=l[0];l=l[1];if(!c&&!l)return".";l&&(l=l.substr(0,l.length-1));return c+l};A.basename=function(c,l){var q=m.exec(c).slice(1)[2];l&&q.substr(-1*l.length)===l&&(q=q.substr(0,q.length-l.length));return q};A.extname=function(c){return m.exec(c).slice(1)[3]};
+var f="b"==="ab".substr(-1)?function(c,l,q){return c.substr(l,q)}:function(c,l,q){0>l&&(l=c.length+l);return c.substr(l,q)}}).call(this,C("g5I+bs"))},{"g5I+bs":9}],9:[function(C,J,A){function e(){}C=J.exports={};C.nextTick=function(){if("undefined"!==typeof window&&window.setImmediate)return function(t){return window.setImmediate(t)};if("undefined"!==typeof window&&window.postMessage&&window.addEventListener){var p=[];window.addEventListener("message",function(t){var m=t.source;m!==window&&null!==
+m||"process-tick"!==t.data||(t.stopPropagation(),0<p.length&&p.shift()())},!0);return function(t){p.push(t);window.postMessage("process-tick","*")}}return function(t){setTimeout(t,0)}}();C.title="browser";C.browser=!0;C.env={};C.argv=[];C.on=e;C.addListener=e;C.once=e;C.off=e;C.removeListener=e;C.removeAllListeners=e;C.emit=e;C.binding=function(p){throw Error("process.binding is not supported");};C.cwd=function(){return"/"};C.chdir=function(p){throw Error("process.chdir is not supported");}},{}],
+10:[function(C,J,A){function e(){this._array=[];this._set=m?new Map:Object.create(null)}var p=C("./util"),t=Object.prototype.hasOwnProperty,m="undefined"!==typeof Map;e.fromArray=function(f,c){for(var l=new e,q=0,r=f.length;q<r;q++)l.add(f[q],c);return l};e.prototype.size=function(){return m?this._set.size:Object.getOwnPropertyNames(this._set).length};e.prototype.add=function(f,c){var l=m?f:p.toSetString(f),q=m?this.has(f):t.call(this._set,l),r=this._array.length;q&&!c||this._array.push(f);q||(m?
+this._set.set(f,r):this._set[l]=r)};e.prototype.has=function(f){if(m)return this._set.has(f);f=p.toSetString(f);return t.call(this._set,f)};e.prototype.indexOf=function(f){if(m){var c=this._set.get(f);if(0<=c)return c}else if(c=p.toSetString(f),t.call(this._set,c))return this._set[c];throw Error('"'+f+'" is not in the set.');};e.prototype.at=function(f){if(0<=f&&f<this._array.length)return this._array[f];throw Error("No element indexed by "+f);};e.prototype.toArray=function(){return this._array.slice()};
+A.ArraySet=e},{"./util":19}],11:[function(C,J,A){var e=C("./base64");A.encode=function(p){var t="",m=0>p?(-p<<1)+1:p<<1;do p=m&31,m>>>=5,0<m&&(p|=32),t+=e.encode(p);while(0<m);return t};A.decode=function(p,t,m){var f=p.length,c=0,l=0;do{if(t>=f)throw Error("Expected more digits in base 64 VLQ value.");var q=e.decode(p.charCodeAt(t++));if(-1===q)throw Error("Invalid base64 digit: "+p.charAt(t-1));var r=!!(q&32);q&=31;c+=q<<l;l+=5}while(r);p=c>>1;m.value=1===(c&1)?-p:p;m.rest=t}},{"./base64":12}],12:[function(C,
+J,A){var e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");A.encode=function(p){if(0<=p&&p<e.length)return e[p];throw new TypeError("Must be between 0 and 63: "+p);};A.decode=function(p){return 65<=p&&90>=p?p-65:97<=p&&122>=p?p-97+26:48<=p&&57>=p?p-48+52:43==p?62:47==p?63:-1}},{}],13:[function(C,J,A){function e(p,t,m,f,c,l){var q=Math.floor((t-p)/2)+p,r=c(m,f[q],!0);return 0===r?q:0<r?1<t-q?e(q,t,m,f,c,l):l==A.LEAST_UPPER_BOUND?t<f.length?t:-1:q:1<q-p?e(p,q,m,f,c,l):l==
+A.LEAST_UPPER_BOUND?q:0>p?-1:p}A.GREATEST_LOWER_BOUND=1;A.LEAST_UPPER_BOUND=2;A.search=function(p,t,m,f){if(0===t.length)return-1;p=e(-1,t.length,p,t,m,f||A.GREATEST_LOWER_BOUND);if(0>p)return-1;for(;0<=p-1&&0===m(t[p],t[p-1],!0);)--p;return p}},{}],14:[function(C,J,A){function e(){this._array=[];this._sorted=!0;this._last={generatedLine:-1,generatedColumn:0}}var p=C("./util");e.prototype.unsortedForEach=function(t,m){this._array.forEach(t,m)};e.prototype.add=function(t){var m=this._last,f=m.generatedLine,
+c=t.generatedLine,l=m.generatedColumn,q=t.generatedColumn;c>f||c==f&&q>=l||0>=p.compareByGeneratedPositionsInflated(m,t)?this._last=t:this._sorted=!1;this._array.push(t)};e.prototype.toArray=function(){this._sorted||(this._array.sort(p.compareByGeneratedPositionsInflated),this._sorted=!0);return this._array};A.MappingList=e},{"./util":19}],15:[function(C,J,A){function e(t,m,f){var c=t[m];t[m]=t[f];t[f]=c}function p(t,m,f,c){if(f<c){var l=f-1;e(t,Math.round(f+Math.random()*(c-f)),c);for(var q=t[c],
+r=f;r<c;r++)0>=m(t[r],q)&&(l+=1,e(t,l,r));e(t,l+1,r);l+=1;p(t,m,f,l-1);p(t,m,l+1,c)}}A.quickSort=function(t,m){p(t,m,0,t.length-1)}},{}],16:[function(C,J,A){function e(k,u){var d=k;"string"===typeof k&&(d=f.parseSourceMapInput(k));return null!=d.sections?new m(d,u):new p(d,u)}function p(k,u){var d=k;"string"===typeof k&&(d=f.parseSourceMapInput(k));var g=f.getArg(d,"version"),n=f.getArg(d,"sources"),v=f.getArg(d,"names",[]),z=f.getArg(d,"sourceRoot",null),G=f.getArg(d,"sourcesContent",null),D=f.getArg(d,
+"mappings");d=f.getArg(d,"file",null);if(g!=this._version)throw Error("Unsupported version: "+g);z&&(z=f.normalize(z));n=n.map(String).map(f.normalize).map(function(L){return z&&f.isAbsolute(z)&&f.isAbsolute(L)?f.relative(z,L):L});this._names=l.fromArray(v.map(String),!0);this._sources=l.fromArray(n,!0);this.sourceRoot=z;this.sourcesContent=G;this._mappings=D;this._sourceMapURL=u;this.file=d}function t(){this.generatedColumn=this.generatedLine=0;this.name=this.originalColumn=this.originalLine=this.source=
+null}function m(k,u){var d=k;"string"===typeof k&&(d=f.parseSourceMapInput(k));var g=f.getArg(d,"version");d=f.getArg(d,"sections");if(g!=this._version)throw Error("Unsupported version: "+g);this._sources=new l;this._names=new l;var n={line:-1,column:0};this._sections=d.map(function(v){if(v.url)throw Error("Support for url field in sections not implemented.");var z=f.getArg(v,"offset"),G=f.getArg(z,"line"),D=f.getArg(z,"column");if(G<n.line||G===n.line&&D<n.column)throw Error("Section offsets must be ordered and non-overlapping.");
+n=z;return{generatedOffset:{generatedLine:G+1,generatedColumn:D+1},consumer:new e(f.getArg(v,"map"),u)}})}var f=C("./util"),c=C("./binary-search"),l=C("./array-set").ArraySet,q=C("./base64-vlq"),r=C("./quick-sort").quickSort;e.fromSourceMap=function(k){return p.fromSourceMap(k)};e.prototype._version=3;e.prototype.__generatedMappings=null;Object.defineProperty(e.prototype,"_generatedMappings",{configurable:!0,enumerable:!0,get:function(){this.__generatedMappings||this._parseMappings(this._mappings,
+this.sourceRoot);return this.__generatedMappings}});e.prototype.__originalMappings=null;Object.defineProperty(e.prototype,"_originalMappings",{configurable:!0,enumerable:!0,get:function(){this.__originalMappings||this._parseMappings(this._mappings,this.sourceRoot);return this.__originalMappings}});e.prototype._charIsMappingSeparator=function(k,u){var d=k.charAt(u);return";"===d||","===d};e.prototype._parseMappings=function(k,u){throw Error("Subclasses must implement _parseMappings");};e.GENERATED_ORDER=
+1;e.ORIGINAL_ORDER=2;e.GREATEST_LOWER_BOUND=1;e.LEAST_UPPER_BOUND=2;e.prototype.eachMapping=function(k,u,d){u=u||null;switch(d||e.GENERATED_ORDER){case e.GENERATED_ORDER:d=this._generatedMappings;break;case e.ORIGINAL_ORDER:d=this._originalMappings;break;default:throw Error("Unknown order of iteration.");}var g=this.sourceRoot;d.map(function(n){var v=null===n.source?null:this._sources.at(n.source);v=f.computeSourceURL(g,v,this._sourceMapURL);return{source:v,generatedLine:n.generatedLine,generatedColumn:n.generatedColumn,
+originalLine:n.originalLine,originalColumn:n.originalColumn,name:null===n.name?null:this._names.at(n.name)}},this).forEach(k,u)};e.prototype.allGeneratedPositionsFor=function(k){var u=f.getArg(k,"line"),d={source:f.getArg(k,"source"),originalLine:u,originalColumn:f.getArg(k,"column",0)};null!=this.sourceRoot&&(d.source=f.relative(this.sourceRoot,d.source));if(!this._sources.has(d.source))return[];d.source=this._sources.indexOf(d.source);var g=[];d=this._findMapping(d,this._originalMappings,"originalLine",
+"originalColumn",f.compareByOriginalPositions,c.LEAST_UPPER_BOUND);if(0<=d){var n=this._originalMappings[d];if(void 0===k.column)for(u=n.originalLine;n&&n.originalLine===u;)g.push({line:f.getArg(n,"generatedLine",null),column:f.getArg(n,"generatedColumn",null),lastColumn:f.getArg(n,"lastGeneratedColumn",null)}),n=this._originalMappings[++d];else for(k=n.originalColumn;n&&n.originalLine===u&&n.originalColumn==k;)g.push({line:f.getArg(n,"generatedLine",null),column:f.getArg(n,"generatedColumn",null),
+lastColumn:f.getArg(n,"lastGeneratedColumn",null)}),n=this._originalMappings[++d]}return g};A.SourceMapConsumer=e;p.prototype=Object.create(e.prototype);p.prototype.consumer=e;p.fromSourceMap=function(k,u){var d=Object.create(p.prototype),g=d._names=l.fromArray(k._names.toArray(),!0),n=d._sources=l.fromArray(k._sources.toArray(),!0);d.sourceRoot=k._sourceRoot;d.sourcesContent=k._generateSourcesContent(d._sources.toArray(),d.sourceRoot);d.file=k._file;d._sourceMapURL=u;for(var v=k._mappings.toArray().slice(),
+z=d.__generatedMappings=[],G=d.__originalMappings=[],D=0,L=v.length;D<L;D++){var a=v[D],b=new t;b.generatedLine=a.generatedLine;b.generatedColumn=a.generatedColumn;a.source&&(b.source=n.indexOf(a.source),b.originalLine=a.originalLine,b.originalColumn=a.originalColumn,a.name&&(b.name=g.indexOf(a.name)),G.push(b));z.push(b)}r(d.__originalMappings,f.compareByOriginalPositions);return d};p.prototype._version=3;Object.defineProperty(p.prototype,"sources",{get:function(){return this._sources.toArray().map(function(k){return f.computeSourceURL(this.sourceRoot,
+k,this._sourceMapURL)},this)}});p.prototype._parseMappings=function(k,u){for(var d=1,g=0,n=0,v=0,z=0,G=0,D=k.length,L=0,a={},b={},h=[],w=[],y,I,K,N,P;L<D;)if(";"===k.charAt(L))d++,L++,g=0;else if(","===k.charAt(L))L++;else{y=new t;y.generatedLine=d;for(N=L;N<D&&!this._charIsMappingSeparator(k,N);N++);I=k.slice(L,N);if(K=a[I])L+=I.length;else{for(K=[];L<N;)q.decode(k,L,b),P=b.value,L=b.rest,K.push(P);if(2===K.length)throw Error("Found a source, but no line and column");if(3===K.length)throw Error("Found a source and line, but no column");
+a[I]=K}y.generatedColumn=g+K[0];g=y.generatedColumn;1<K.length&&(y.source=z+K[1],z+=K[1],y.originalLine=n+K[2],n=y.originalLine,y.originalLine+=1,y.originalColumn=v+K[3],v=y.originalColumn,4<K.length&&(y.name=G+K[4],G+=K[4]));w.push(y);"number"===typeof y.originalLine&&h.push(y)}r(w,f.compareByGeneratedPositionsDeflated);this.__generatedMappings=w;r(h,f.compareByOriginalPositions);this.__originalMappings=h};p.prototype._findMapping=function(k,u,d,g,n,v){if(0>=k[d])throw new TypeError("Line must be greater than or equal to 1, got "+
+k[d]);if(0>k[g])throw new TypeError("Column must be greater than or equal to 0, got "+k[g]);return c.search(k,u,n,v)};p.prototype.computeColumnSpans=function(){for(var k=0;k<this._generatedMappings.length;++k){var u=this._generatedMappings[k];if(k+1<this._generatedMappings.length){var d=this._generatedMappings[k+1];if(u.generatedLine===d.generatedLine){u.lastGeneratedColumn=d.generatedColumn-1;continue}}u.lastGeneratedColumn=Infinity}};p.prototype.originalPositionFor=function(k){var u={generatedLine:f.getArg(k,
+"line"),generatedColumn:f.getArg(k,"column")};k=this._findMapping(u,this._generatedMappings,"generatedLine","generatedColumn",f.compareByGeneratedPositionsDeflated,f.getArg(k,"bias",e.GREATEST_LOWER_BOUND));if(0<=k&&(k=this._generatedMappings[k],k.generatedLine===u.generatedLine)){u=f.getArg(k,"source",null);null!==u&&(u=this._sources.at(u),u=f.computeSourceURL(this.sourceRoot,u,this._sourceMapURL));var d=f.getArg(k,"name",null);null!==d&&(d=this._names.at(d));return{source:u,line:f.getArg(k,"originalLine",
+null),column:f.getArg(k,"originalColumn",null),name:d}}return{source:null,line:null,column:null,name:null}};p.prototype.hasContentsOfAllSources=function(){return this.sourcesContent?this.sourcesContent.length>=this._sources.size()&&!this.sourcesContent.some(function(k){return null==k}):!1};p.prototype.sourceContentFor=function(k,u){if(!this.sourcesContent)return null;var d=k;null!=this.sourceRoot&&(d=f.relative(this.sourceRoot,d));if(this._sources.has(d))return this.sourcesContent[this._sources.indexOf(d)];
+var g=this.sources,n;for(n=0;n<g.length;++n)if(g[n]==k)return this.sourcesContent[n];var v;if(null!=this.sourceRoot&&(v=f.urlParse(this.sourceRoot))){g=d.replace(/^file:\/\//,"");if("file"==v.scheme&&this._sources.has(g))return this.sourcesContent[this._sources.indexOf(g)];if((!v.path||"/"==v.path)&&this._sources.has("/"+d))return this.sourcesContent[this._sources.indexOf("/"+d)]}if(u)return null;throw Error('"'+d+'" is not in the SourceMap.');};p.prototype.generatedPositionFor=function(k){var u=
+f.getArg(k,"source");null!=this.sourceRoot&&(u=f.relative(this.sourceRoot,u));if(!this._sources.has(u))return{line:null,column:null,lastColumn:null};u=this._sources.indexOf(u);u={source:u,originalLine:f.getArg(k,"line"),originalColumn:f.getArg(k,"column")};k=this._findMapping(u,this._originalMappings,"originalLine","originalColumn",f.compareByOriginalPositions,f.getArg(k,"bias",e.GREATEST_LOWER_BOUND));return 0<=k&&(k=this._originalMappings[k],k.source===u.source)?{line:f.getArg(k,"generatedLine",
+null),column:f.getArg(k,"generatedColumn",null),lastColumn:f.getArg(k,"lastGeneratedColumn",null)}:{line:null,column:null,lastColumn:null}};A.BasicSourceMapConsumer=p;m.prototype=Object.create(e.prototype);m.prototype.constructor=e;m.prototype._version=3;Object.defineProperty(m.prototype,"sources",{get:function(){for(var k=[],u=0;u<this._sections.length;u++)for(var d=0;d<this._sections[u].consumer.sources.length;d++)k.push(this._sections[u].consumer.sources[d]);return k}});m.prototype.originalPositionFor=
+function(k){var u={generatedLine:f.getArg(k,"line"),generatedColumn:f.getArg(k,"column")},d=c.search(u,this._sections,function(g,n){var v=g.generatedLine-n.generatedOffset.generatedLine;return v?v:g.generatedColumn-n.generatedOffset.generatedColumn});return(d=this._sections[d])?d.consumer.originalPositionFor({line:u.generatedLine-(d.generatedOffset.generatedLine-1),column:u.generatedColumn-(d.generatedOffset.generatedLine===u.generatedLine?d.generatedOffset.generatedColumn-1:0),bias:k.bias}):{source:null,
+line:null,column:null,name:null}};m.prototype.hasContentsOfAllSources=function(){return this._sections.every(function(k){return k.consumer.hasContentsOfAllSources()})};m.prototype.sourceContentFor=function(k,u){for(var d=0;d<this._sections.length;d++){var g=this._sections[d].consumer.sourceContentFor(k,!0);if(g)return g}if(u)return null;throw Error('"'+k+'" is not in the SourceMap.');};m.prototype.generatedPositionFor=function(k){for(var u=0;u<this._sections.length;u++){var d=this._sections[u];if(-1!==
+d.consumer.sources.indexOf(f.getArg(k,"source"))){var g=d.consumer.generatedPositionFor(k);if(g)return{line:g.line+(d.generatedOffset.generatedLine-1),column:g.column+(d.generatedOffset.generatedLine===g.line?d.generatedOffset.generatedColumn-1:0)}}}return{line:null,column:null}};m.prototype._parseMappings=function(k,u){this.__generatedMappings=[];this.__originalMappings=[];for(var d=0;d<this._sections.length;d++)for(var g=this._sections[d],n=g.consumer._generatedMappings,v=0;v<n.length;v++){var z=
+n[v],G=g.consumer._sources.at(z.source);G=f.computeSourceURL(g.consumer.sourceRoot,G,this._sourceMapURL);this._sources.add(G);G=this._sources.indexOf(G);var D=null;z.name&&(D=g.consumer._names.at(z.name),this._names.add(D),D=this._names.indexOf(D));z={source:G,generatedLine:z.generatedLine+(g.generatedOffset.generatedLine-1),generatedColumn:z.generatedColumn+(g.generatedOffset.generatedLine===z.generatedLine?g.generatedOffset.generatedColumn-1:0),originalLine:z.originalLine,originalColumn:z.originalColumn,
+name:D};this.__generatedMappings.push(z);"number"===typeof z.originalLine&&this.__originalMappings.push(z)}r(this.__generatedMappings,f.compareByGeneratedPositionsDeflated);r(this.__originalMappings,f.compareByOriginalPositions)};A.IndexedSourceMapConsumer=m},{"./array-set":10,"./base64-vlq":11,"./binary-search":13,"./quick-sort":15,"./util":19}],17:[function(C,J,A){function e(c){c||(c={});this._file=t.getArg(c,"file",null);this._sourceRoot=t.getArg(c,"sourceRoot",null);this._skipValidation=t.getArg(c,
+"skipValidation",!1);this._sources=new m;this._names=new m;this._mappings=new f;this._sourcesContents=null}var p=C("./base64-vlq"),t=C("./util"),m=C("./array-set").ArraySet,f=C("./mapping-list").MappingList;e.prototype._version=3;e.fromSourceMap=function(c){var l=c.sourceRoot,q=new e({file:c.file,sourceRoot:l});c.eachMapping(function(r){var k={generated:{line:r.generatedLine,column:r.generatedColumn}};null!=r.source&&(k.source=r.source,null!=l&&(k.source=t.relative(l,k.source)),k.original={line:r.originalLine,
+column:r.originalColumn},null!=r.name&&(k.name=r.name));q.addMapping(k)});c.sources.forEach(function(r){var k=r;null!==l&&(k=t.relative(l,r));q._sources.has(k)||q._sources.add(k);k=c.sourceContentFor(r);null!=k&&q.setSourceContent(r,k)});return q};e.prototype.addMapping=function(c){var l=t.getArg(c,"generated"),q=t.getArg(c,"original",null),r=t.getArg(c,"source",null);c=t.getArg(c,"name",null);this._skipValidation||this._validateMapping(l,q,r,c);null!=r&&(r=String(r),this._sources.has(r)||this._sources.add(r));
+null!=c&&(c=String(c),this._names.has(c)||this._names.add(c));this._mappings.add({generatedLine:l.line,generatedColumn:l.column,originalLine:null!=q&&q.line,originalColumn:null!=q&&q.column,source:r,name:c})};e.prototype.setSourceContent=function(c,l){var q=c;null!=this._sourceRoot&&(q=t.relative(this._sourceRoot,q));null!=l?(this._sourcesContents||(this._sourcesContents=Object.create(null)),this._sourcesContents[t.toSetString(q)]=l):this._sourcesContents&&(delete this._sourcesContents[t.toSetString(q)],
+0===Object.keys(this._sourcesContents).length&&(this._sourcesContents=null))};e.prototype.applySourceMap=function(c,l,q){var r=l;if(null==l){if(null==c.file)throw Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map\'s "file" property. Both were omitted.');r=c.file}var k=this._sourceRoot;null!=k&&(r=t.relative(k,r));var u=new m,d=new m;this._mappings.unsortedForEach(function(g){if(g.source===r&&null!=g.originalLine){var n=c.originalPositionFor({line:g.originalLine,
+column:g.originalColumn});null!=n.source&&(g.source=n.source,null!=q&&(g.source=t.join(q,g.source)),null!=k&&(g.source=t.relative(k,g.source)),g.originalLine=n.line,g.originalColumn=n.column,null!=n.name&&(g.name=n.name))}n=g.source;null==n||u.has(n)||u.add(n);g=g.name;null==g||d.has(g)||d.add(g)},this);this._sources=u;this._names=d;c.sources.forEach(function(g){var n=c.sourceContentFor(g);null!=n&&(null!=q&&(g=t.join(q,g)),null!=k&&(g=t.relative(k,g)),this.setSourceContent(g,n))},this)};e.prototype._validateMapping=
+function(c,l,q,r){if(l&&"number"!==typeof l.line&&"number"!==typeof l.column)throw Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");if(!(c&&"line"in c&&"column"in c&&0<c.line&&0<=c.column&&!l&&!q&&!r||c&&"line"in c&&"column"in c&&l&&"line"in l&&"column"in l&&0<c.line&&0<=c.column&&0<l.line&&0<=l.column&&
+q))throw Error("Invalid mapping: "+JSON.stringify({generated:c,source:q,original:l,name:r}));};e.prototype._serializeMappings=function(){for(var c=0,l=1,q=0,r=0,k=0,u=0,d="",g,n,v,z=this._mappings.toArray(),G=0,D=z.length;G<D;G++){n=z[G];g="";if(n.generatedLine!==l)for(c=0;n.generatedLine!==l;)g+=";",l++;else if(0<G){if(!t.compareByGeneratedPositionsInflated(n,z[G-1]))continue;g+=","}g+=p.encode(n.generatedColumn-c);c=n.generatedColumn;null!=n.source&&(v=this._sources.indexOf(n.source),g+=p.encode(v-
+u),u=v,g+=p.encode(n.originalLine-1-r),r=n.originalLine-1,g+=p.encode(n.originalColumn-q),q=n.originalColumn,null!=n.name&&(n=this._names.indexOf(n.name),g+=p.encode(n-k),k=n));d+=g}return d};e.prototype._generateSourcesContent=function(c,l){return c.map(function(q){if(!this._sourcesContents)return null;null!=l&&(q=t.relative(l,q));q=t.toSetString(q);return Object.prototype.hasOwnProperty.call(this._sourcesContents,q)?this._sourcesContents[q]:null},this)};e.prototype.toJSON=function(){var c={version:this._version,
+sources:this._sources.toArray(),names:this._names.toArray(),mappings:this._serializeMappings()};null!=this._file&&(c.file=this._file);null!=this._sourceRoot&&(c.sourceRoot=this._sourceRoot);this._sourcesContents&&(c.sourcesContent=this._generateSourcesContent(c.sources,c.sourceRoot));return c};e.prototype.toString=function(){return JSON.stringify(this.toJSON())};A.SourceMapGenerator=e},{"./array-set":10,"./base64-vlq":11,"./mapping-list":14,"./util":19}],18:[function(C,J,A){function e(f,c,l,q,r){this.children=
+[];this.sourceContents={};this.line=null==f?null:f;this.column=null==c?null:c;this.source=null==l?null:l;this.name=null==r?null:r;this.$$$isSourceNode$$$=!0;null!=q&&this.add(q)}var p=C("./source-map-generator").SourceMapGenerator,t=C("./util"),m=/(\r?\n)/;e.fromStringWithSourceMap=function(f,c,l){function q(z,G){if(null===z||void 0===z.source)r.add(G);else{var D=l?t.join(l,z.source):z.source;r.add(new e(z.originalLine,z.originalColumn,D,G,z.name))}}var r=new e,k=f.split(m),u=0,d=function(){var z=
+u<k.length?k[u++]:void 0,G=(u<k.length?k[u++]:void 0)||"";return z+G},g=1,n=0,v=null;c.eachMapping(function(z){if(null!==v)if(g<z.generatedLine)q(v,d()),g++,n=0;else{var G=k[u]||"",D=G.substr(0,z.generatedColumn-n);k[u]=G.substr(z.generatedColumn-n);n=z.generatedColumn;q(v,D);v=z;return}for(;g<z.generatedLine;)r.add(d()),g++;n<z.generatedColumn&&(G=k[u]||"",r.add(G.substr(0,z.generatedColumn)),k[u]=G.substr(z.generatedColumn),n=z.generatedColumn);v=z},this);u<k.length&&(v&&q(v,d()),r.add(k.splice(u).join("")));
+c.sources.forEach(function(z){var G=c.sourceContentFor(z);null!=G&&(null!=l&&(z=t.join(l,z)),r.setSourceContent(z,G))});return r};e.prototype.add=function(f){if(Array.isArray(f))f.forEach(function(c){this.add(c)},this);else if(f.$$$isSourceNode$$$||"string"===typeof f)f&&this.children.push(f);else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got "+f);return this};e.prototype.prepend=function(f){if(Array.isArray(f))for(var c=f.length-1;0<=c;c--)this.prepend(f[c]);
+else if(f.$$$isSourceNode$$$||"string"===typeof f)this.children.unshift(f);else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got "+f);return this};e.prototype.walk=function(f){for(var c,l=0,q=this.children.length;l<q;l++)c=this.children[l],c.$$$isSourceNode$$$?c.walk(f):""!==c&&f(c,{source:this.source,line:this.line,column:this.column,name:this.name})};e.prototype.join=function(f){var c,l=this.children.length;if(0<l){var q=[];for(c=0;c<l-1;c++)q.push(this.children[c]),
+q.push(f);q.push(this.children[c]);this.children=q}return this};e.prototype.replaceRight=function(f,c){var l=this.children[this.children.length-1];l.$$$isSourceNode$$$?l.replaceRight(f,c):"string"===typeof l?this.children[this.children.length-1]=l.replace(f,c):this.children.push("".replace(f,c));return this};e.prototype.setSourceContent=function(f,c){this.sourceContents[t.toSetString(f)]=c};e.prototype.walkSourceContents=function(f){for(var c=0,l=this.children.length;c<l;c++)this.children[c].$$$isSourceNode$$$&&
+this.children[c].walkSourceContents(f);var q=Object.keys(this.sourceContents);c=0;for(l=q.length;c<l;c++)f(t.fromSetString(q[c]),this.sourceContents[q[c]])};e.prototype.toString=function(){var f="";this.walk(function(c){f+=c});return f};e.prototype.toStringWithSourceMap=function(f){var c="",l=1,q=0,r=new p(f),k=!1,u=null,d=null,g=null,n=null;this.walk(function(v,z){c+=v;null!==z.source&&null!==z.line&&null!==z.column?(u===z.source&&d===z.line&&g===z.column&&n===z.name||r.addMapping({source:z.source,
+original:{line:z.line,column:z.column},generated:{line:l,column:q},name:z.name}),u=z.source,d=z.line,g=z.column,n=z.name,k=!0):k&&(r.addMapping({generated:{line:l,column:q}}),u=null,k=!1);for(var G=0,D=v.length;G<D;G++)10===v.charCodeAt(G)?(l++,q=0,G+1===D?(u=null,k=!1):k&&r.addMapping({source:z.source,original:{line:z.line,column:z.column},generated:{line:l,column:q},name:z.name})):q++});this.walkSourceContents(function(v,z){r.setSourceContent(v,z)});return{code:c,map:r}};A.SourceNode=e},{"./source-map-generator":17,
+"./util":19}],19:[function(C,J,A){function e(d){return(d=d.match(k))?{scheme:d[1],auth:d[2],host:d[3],port:d[4],path:d[5]}:null}function p(d){var g="";d.scheme&&(g+=d.scheme+":");g+="//";d.auth&&(g+=d.auth+"@");d.host&&(g+=d.host);d.port&&(g+=":"+d.port);d.path&&(g+=d.path);return g}function t(d){var g=d,n=e(d);if(n){if(!n.path)return d;g=n.path}d=A.isAbsolute(g);g=g.split(/\/+/);for(var v,z=0,G=g.length-1;0<=G;G--)v=g[G],"."===v?g.splice(G,1):".."===v?z++:0<z&&(""===v?(g.splice(G+1,z),z=0):(g.splice(G,
+2),z--));g=g.join("/");""===g&&(g=d?"/":".");return n?(n.path=g,p(n)):g}function m(d,g){""===d&&(d=".");""===g&&(g=".");var n=e(g),v=e(d);v&&(d=v.path||"/");if(n&&!n.scheme)return v&&(n.scheme=v.scheme),p(n);if(n||g.match(u))return g;if(v&&!v.host&&!v.path)return v.host=g,p(v);n="/"===g.charAt(0)?g:t(d.replace(/\/+$/,"")+"/"+g);return v?(v.path=n,p(v)):n}function f(d){return d}function c(d){return q(d)?"$"+d:d}function l(d){return q(d)?d.slice(1):d}function q(d){if(!d)return!1;var g=d.length;if(9>
+g||95!==d.charCodeAt(g-1)||95!==d.charCodeAt(g-2)||111!==d.charCodeAt(g-3)||116!==d.charCodeAt(g-4)||111!==d.charCodeAt(g-5)||114!==d.charCodeAt(g-6)||112!==d.charCodeAt(g-7)||95!==d.charCodeAt(g-8)||95!==d.charCodeAt(g-9))return!1;for(g-=10;0<=g;g--)if(36!==d.charCodeAt(g))return!1;return!0}function r(d,g){return d===g?0:null===d?1:null===g?-1:d>g?1:-1}A.getArg=function(d,g,n){if(g in d)return d[g];if(3===arguments.length)return n;throw Error('"'+g+'" is a required argument.');};var k=/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/,
+u=/^data:.+,.+$/;A.urlParse=e;A.urlGenerate=p;A.normalize=t;A.join=m;A.isAbsolute=function(d){return"/"===d.charAt(0)||k.test(d)};A.relative=function(d,g){""===d&&(d=".");d=d.replace(/\/$/,"");for(var n=0;0!==g.indexOf(d+"/");){var v=d.lastIndexOf("/");if(0>v)return g;d=d.slice(0,v);if(d.match(/^([^\/]+:\/)?\/*$/))return g;++n}return Array(n+1).join("../")+g.substr(d.length+1)};C=!("__proto__"in Object.create(null));A.toSetString=C?f:c;A.fromSetString=C?f:l;A.compareByOriginalPositions=function(d,
+g,n){var v=r(d.source,g.source);if(0!==v)return v;v=d.originalLine-g.originalLine;if(0!==v)return v;v=d.originalColumn-g.originalColumn;if(0!==v||n)return v;v=d.generatedColumn-g.generatedColumn;if(0!==v)return v;v=d.generatedLine-g.generatedLine;return 0!==v?v:r(d.name,g.name)};A.compareByGeneratedPositionsDeflated=function(d,g,n){var v=d.generatedLine-g.generatedLine;if(0!==v)return v;v=d.generatedColumn-g.generatedColumn;if(0!==v||n)return v;v=r(d.source,g.source);if(0!==v)return v;v=d.originalLine-
+g.originalLine;if(0!==v)return v;v=d.originalColumn-g.originalColumn;return 0!==v?v:r(d.name,g.name)};A.compareByGeneratedPositionsInflated=function(d,g){var n=d.generatedLine-g.generatedLine;if(0!==n)return n;n=d.generatedColumn-g.generatedColumn;if(0!==n)return n;n=r(d.source,g.source);if(0!==n)return n;n=d.originalLine-g.originalLine;if(0!==n)return n;n=d.originalColumn-g.originalColumn;return 0!==n?n:r(d.name,g.name)};A.parseSourceMapInput=function(d){return JSON.parse(d.replace(/^\)]}'[^\n]*\n/,
+""))};A.computeSourceURL=function(d,g,n){g=g||"";d&&("/"!==d[d.length-1]&&"/"!==g[0]&&(d+="/"),g=d+g);if(n){d=e(n);if(!d)throw Error("sourceMapURL could not be parsed");d.path&&(n=d.path.lastIndexOf("/"),0<=n&&(d.path=d.path.substring(0,n+1)));g=m(p(d),g)}return t(g)}},{}],20:[function(C,J,A){A.SourceMapGenerator=C("./lib/source-map-generator").SourceMapGenerator;A.SourceMapConsumer=C("./lib/source-map-consumer").SourceMapConsumer;A.SourceNode=C("./lib/source-node").SourceNode},{"./lib/source-map-consumer":16,
+"./lib/source-map-generator":17,"./lib/source-node":18}],21:[function(C,J,A){(function(e){function p(){return"browser"===a?!0:"node"===a?!1:"undefined"!==typeof window&&"function"===typeof XMLHttpRequest&&!(window.require&&window.module&&window.process&&"renderer"===window.process.type)}function t(x){return function(B){for(var F=0;F<x.length;F++){var E=x[F](B);if(E)return E}return null}}function m(x,B){if(!x)return B;var F=n.dirname(x),E=/^\w+:\/\/[^\/]*/.exec(F);E=E?E[0]:"";var H=F.slice(E.length);
+return E&&/^\/\w:/.test(H)?(E+="/",E+n.resolve(F.slice(E.length),B).replace(/\\/g,"/")):E+n.resolve(F.slice(E.length),B)}function f(x){var B=h[x.source];if(!B){var F=N(x.source);F?(B=h[x.source]={url:F.url,map:new g(F.map)},B.map.sourcesContent&&B.map.sources.forEach(function(E,H){var M=B.map.sourcesContent[H];if(M){var S=m(B.url,E);b[S]=M}})):B=h[x.source]={url:null,map:null}}return B&&B.map&&"function"===typeof B.map.originalPositionFor&&(F=B.map.originalPositionFor(x),null!==F.source)?(F.source=
+m(B.url,F.source),F):x}function c(x){var B=/^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(x);return B?(x=f({source:B[2],line:+B[3],column:B[4]-1}),"eval at "+B[1]+" ("+x.source+":"+x.line+":"+(x.column+1)+")"):(B=/^eval at ([^(]+) \((.+)\)$/.exec(x))?"eval at "+B[1]+" ("+c(B[2])+")":x}function l(){var x="";if(this.isNative())x="native";else{var B=this.getScriptNameOrSourceURL();!B&&this.isEval()&&(x=this.getEvalOrigin(),x+=", ");x=B?x+B:x+"<anonymous>";B=this.getLineNumber();null!=B&&(x+=":"+B,(B=
+this.getColumnNumber())&&(x+=":"+B))}B="";var F=this.getFunctionName(),E=!0,H=this.isConstructor();if(this.isToplevel()||H)H?B+="new "+(F||"<anonymous>"):F?B+=F:(B+=x,E=!1);else{H=this.getTypeName();"[object Object]"===H&&(H="null");var M=this.getMethodName();F?(H&&0!=F.indexOf(H)&&(B+=H+"."),B+=F,M&&F.indexOf("."+M)!=F.length-M.length-1&&(B+=" [as "+M+"]")):B+=H+"."+(M||"<anonymous>")}E&&(B+=" ("+x+")");return B}function q(x){var B={};Object.getOwnPropertyNames(Object.getPrototypeOf(x)).forEach(function(F){B[F]=
+/^(?:is|get)/.test(F)?function(){return x[F].call(x)}:x[F]});B.toString=l;return B}function r(x,B){void 0===B&&(B={nextPosition:null,curPosition:null});if(x.isNative())return B.curPosition=null,x;var F=x.getFileName()||x.getScriptNameOrSourceURL();if(F){var E=x.getLineNumber(),H=x.getColumnNumber()-1,M=/^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/,S=M.test;var V="object"===typeof e&&null!==e?e.version:"";M=S.call(M,V)?0:62;1===E&&H>M&&!p()&&!x.isEval()&&(H-=M);var O=
+f({source:F,line:E,column:H});B.curPosition=O;x=q(x);var T=x.getFunctionName;x.getFunctionName=function(){return null==B.nextPosition?T():B.nextPosition.name||T()};x.getFileName=function(){return O.source};x.getLineNumber=function(){return O.line};x.getColumnNumber=function(){return O.column+1};x.getScriptNameOrSourceURL=function(){return O.source};return x}var Q=x.isEval()&&x.getEvalOrigin();Q&&(Q=c(Q),x=q(x),x.getEvalOrigin=function(){return Q});return x}function k(x,B){L&&(b={},h={});for(var F=
+(x.name||"Error")+": "+(x.message||""),E={nextPosition:null,curPosition:null},H=[],M=B.length-1;0<=M;M--)H.push("\n    at "+r(B[M],E)),E.nextPosition=E.curPosition;E.curPosition=E.nextPosition=null;return F+H.reverse().join("")}function u(x){var B=/\n    at [^(]+ \((.*):(\d+):(\d+)\)/.exec(x.stack);if(B){x=B[1];var F=+B[2];B=+B[3];var E=b[x];if(!E&&v&&v.existsSync(x))try{E=v.readFileSync(x,"utf8")}catch(H){E=""}if(E&&(E=E.split(/(?:\r\n|\r|\n)/)[F-1]))return x+":"+F+"\n"+E+"\n"+Array(B).join(" ")+
+"^"}return null}function d(){var x=e.emit;e.emit=function(B){if("uncaughtException"===B){var F=arguments[1]&&arguments[1].stack,E=0<this.listeners(B).length;if(F&&!E){F=arguments[1];E=u(F);var H="object"===typeof e&&null!==e?e.stderr:void 0;H&&H._handle&&H._handle.setBlocking&&H._handle.setBlocking(!0);E&&(console.error(),console.error(E));console.error(F.stack);"object"===typeof e&&null!==e&&"function"===typeof e.exit&&e.exit(1);return}}return x.apply(this,arguments)}}var g=C("source-map").SourceMapConsumer,
+n=C("path");try{var v=C("fs");v.existsSync&&v.readFileSync||(v=null)}catch(x){}var z=C("buffer-from"),G=!1,D=!1,L=!1,a="auto",b={},h={},w=/^data:application\/json[^,]+base64,/,y=[],I=[],K=t(y);y.push(function(x){x=x.trim();/^file:/.test(x)&&(x=x.replace(/file:\/\/\/(\w:)?/,function(E,H){return H?"":"/"}));if(x in b)return b[x];var B="";try{if(v)v.existsSync(x)&&(B=v.readFileSync(x,"utf8"));else{var F=new XMLHttpRequest;F.open("GET",x,!1);F.send(null);4===F.readyState&&200===F.status&&(B=F.responseText)}}catch(E){}return b[x]=
+B});var N=t(I);I.push(function(x){a:{if(p())try{var B=new XMLHttpRequest;B.open("GET",x,!1);B.send(null);var F=B.getResponseHeader("SourceMap")||B.getResponseHeader("X-SourceMap");if(F){var E=F;break a}}catch(M){}E=K(x);B=/(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;for(var H;F=B.exec(E);)H=F;E=H?H[1]:null}if(!E)return null;w.test(E)?(H=E.slice(E.indexOf(",")+1),H=z(H,"base64").toString(),E=x):(E=m(x,E),H=K(E));return H?{url:E,
+map:H}:null});var P=y.slice(0),W=I.slice(0);A.wrapCallSite=r;A.getErrorSource=u;A.mapSourcePosition=f;A.retrieveSourceMap=N;A.install=function(x){x=x||{};if(x.environment&&(a=x.environment,-1===["node","browser","auto"].indexOf(a)))throw Error("environment "+a+" was unknown. Available options are {auto, browser, node}");x.retrieveFile&&(x.overrideRetrieveFile&&(y.length=0),y.unshift(x.retrieveFile));x.retrieveSourceMap&&(x.overrideRetrieveSourceMap&&(I.length=0),I.unshift(x.retrieveSourceMap));if(x.hookRequire&&
+!p()){var B=J.require("module"),F=B.prototype._compile;F.__sourceMapSupport||(B.prototype._compile=function(E,H){b[H]=E;h[H]=void 0;return F.call(this,E,H)},B.prototype._compile.__sourceMapSupport=!0)}L||(L="emptyCacheBetweenOperations"in x?x.emptyCacheBetweenOperations:!1);G||(G=!0,Error.prepareStackTrace=k);if(!D){x="handleUncaughtExceptions"in x?x.handleUncaughtExceptions:!0;try{!1===J.require("worker_threads").isMainThread&&(x=!1)}catch(E){}x&&"object"===typeof e&&null!==e&&"function"===typeof e.on&&
+(D=!0,d())}};A.resetRetrieveHandlers=function(){y.length=0;I.length=0;y=P.slice(0);I=W.slice(0);N=t(I);K=t(y)}}).call(this,C("g5I+bs"))},{"buffer-from":4,fs:3,"g5I+bs":9,path:8,"source-map":20}]},{},[1]);return R});

hardhat/node_modules/@cspotcode/source-map-support/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@cspotcode/source-map-support",
+  "description": "Fixes stack traces for files with source maps",
+  "version": "0.8.1",
+  "main": "./source-map-support.js",
+  "types": "./source-map-support.d.ts",
+  "scripts": {
+    "build": "node build.js",
+    "serve-tests": "http-server -p 1336",
+    "test": "mocha"
+  },
+  "files": [
+    "/register.d.ts",
+    "/register.js",
+    "/register-hook-require.d.ts",
+    "/register-hook-require.js",
+    "/source-map-support.d.ts",
+    "/source-map-support.js",
+    "/browser-source-map-support.js"
+  ],
+  "dependencies": {
+    "@jridgewell/trace-mapping": "0.3.9"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.182",
+    "browserify": "^4.2.3",
+    "coffeescript": "^1.12.7",
+    "http-server": "^0.11.1",
+    "lodash": "^4.17.21",
+    "mocha": "^3.5.3",
+    "semver": "^7.3.7",
+    "source-map": "0.6.1",
+    "webpack": "^1.15.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cspotcode/node-source-map-support"
+  },
+  "bugs": {
+    "url": "https://github.com/cspotcode/node-source-map-support/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=12"
+  },
+  "volta": {
+    "node": "16.11.0",
+    "npm": "7.24.2"
+  }
+}

hardhat/node_modules/@cspotcode/source-map-support/register-hook-require.d.ts

@@ -0,0 +1,7 @@
+// tslint:disable:no-useless-files
+
+// For following usage:
+//    import '@cspotcode/source-map-support/register-hook-require'
+// Instead of:
+//    import sourceMapSupport from '@cspotcode/source-map-support'
+//    sourceMapSupport.install({hookRequire: true})

hardhat/node_modules/@cspotcode/source-map-support/register-hook-require.js

@@ -0,0 +1,3 @@
+require('./').install({
+    hookRequire: true
+});

hardhat/node_modules/@cspotcode/source-map-support/register.d.ts

@@ -0,0 +1,7 @@
+// tslint:disable:no-useless-files
+
+// For following usage:
+//    import '@cspotcode/source-map-support/register'
+// Instead of:
+//    import sourceMapSupport from '@cspotcode/source-map-support'
+//    sourceMapSupport.install()

hardhat/node_modules/@cspotcode/source-map-support/register.js

@@ -0,0 +1 @@
+require('./').install();

hardhat/node_modules/@cspotcode/source-map-support/source-map-support.d.ts

@@ -0,0 +1,76 @@
+// Type definitions for source-map-support 0.5
+// Project: https://github.com/evanw/node-source-map-support
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+//                 Jason Cheatham <https://github.com/jason0x43>
+//                 Alcedo Nathaniel De Guzman Jr <https://github.com/natealcedo>
+//                 Griffin Yourick <https://github.com/tough-griff>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export interface RawSourceMap {
+    version: 3;
+    sources: string[];
+    names: string[];
+    sourceRoot?: string;
+    sourcesContent?: string[];
+    mappings: string;
+    file: string;
+}
+
+/**
+ * Output of retrieveSourceMap().
+ * From source-map-support:
+ *   The map field may be either a string or the parsed JSON object (i.e.,
+ *   it must be a valid argument to the SourceMapConsumer constructor).
+ */
+export interface UrlAndMap {
+    url: string;
+    map: string | RawSourceMap;
+}
+
+/**
+ * Options to install().
+ */
+export interface Options {
+    handleUncaughtExceptions?: boolean | undefined;
+    hookRequire?: boolean | undefined;
+    emptyCacheBetweenOperations?: boolean | undefined;
+    environment?: 'auto' | 'browser' | 'node' | undefined;
+    overrideRetrieveFile?: boolean | undefined;
+    overrideRetrieveSourceMap?: boolean | undefined;
+    retrieveFile?(path: string): string;
+    retrieveSourceMap?(source: string): UrlAndMap | null;
+    /**
+     * Set false to disable redirection of require / import `source-map-support` to `@cspotcode/source-map-support`
+     */
+    redirectConflictingLibrary?: boolean;
+    /**
+     * Callback will be called every time we redirect due to `redirectConflictingLibrary`
+     * This allows consumers to log helpful warnings if they choose.
+     * @param parent NodeJS.Module which made the require() or require.resolve() call
+     * @param options options object internally passed to node's `_resolveFilename` hook
+     */
+    onConflictingLibraryRedirect?: (request: string, parent: any, isMain: boolean, options: any, redirectedRequest: string) => void;
+}
+
+export interface Position {
+    source: string;
+    line: number;
+    column: number;
+}
+
+export function wrapCallSite(frame: any /* StackFrame */): any /* StackFrame */;
+export function getErrorSource(error: Error): string | null;
+export function mapSourcePosition(position: Position): Position;
+export function retrieveSourceMap(source: string): UrlAndMap | null;
+export function resetRetrieveHandlers(): void;
+
+/**
+ * Install SourceMap support.
+ * @param options Can be used to e.g. disable uncaughtException handler.
+ */
+export function install(options?: Options): void;
+
+/**
+ * Uninstall SourceMap support.
+ */
+export function uninstall(): void;

hardhat/node_modules/@cspotcode/source-map-support/source-map-support.js

@@ -0,0 +1,938 @@
+const { TraceMap, originalPositionFor, AnyMap } = require('@jridgewell/trace-mapping');
+var path = require('path');
+const { fileURLToPath, pathToFileURL } = require('url');
+var util = require('util');
+
+var fs;
+try {
+  fs = require('fs');
+  if (!fs.existsSync || !fs.readFileSync) {
+    // fs doesn't have all methods we need
+    fs = null;
+  }
+} catch (err) {
+  /* nop */
+}
+
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param {NodeModule} mod
+ * @param {string} request
+ */
+function dynamicRequire(mod, request) {
+  return mod.require(request);
+}
+
+/**
+ * @typedef {{
+ *   enabled: boolean;
+ *   originalValue: any;
+ *   installedValue: any;
+ * }} HookState
+ * Used for installing and uninstalling hooks
+ */
+
+// Increment this if the format of sharedData changes in a breaking way.
+var sharedDataVersion = 1;
+
+/**
+ * @template T
+ * @param {T} defaults
+ * @returns {T}
+ */
+function initializeSharedData(defaults) {
+  var sharedDataKey = 'source-map-support/sharedData';
+  if (typeof Symbol !== 'undefined') {
+    sharedDataKey = Symbol.for(sharedDataKey);
+  }
+  var sharedData = this[sharedDataKey];
+  if (!sharedData) {
+    sharedData = { version: sharedDataVersion };
+    if (Object.defineProperty) {
+      Object.defineProperty(this, sharedDataKey, { value: sharedData });
+    } else {
+      this[sharedDataKey] = sharedData;
+    }
+  }
+  if (sharedDataVersion !== sharedData.version) {
+    throw new Error("Multiple incompatible instances of source-map-support were loaded");
+  }
+  for (var key in defaults) {
+    if (!(key in sharedData)) {
+      sharedData[key] = defaults[key];
+    }
+  }
+  return sharedData;
+}
+
+// If multiple instances of source-map-support are loaded into the same
+// context, they shouldn't overwrite each other.  By storing handlers, caches,
+// and other state on a shared object, different instances of
+// source-map-support can work together in a limited way. This does require
+// that future versions of source-map-support continue to support the fields on
+// this object. If this internal contract ever needs to be broken, increment
+// sharedDataVersion. (This version number is not the same as any of the
+// package's version numbers, which should reflect the *external* API of
+// source-map-support.)
+var sharedData = initializeSharedData({
+
+  // Only install once if called multiple times
+  // Remember how the environment looked before installation so we can restore if able
+  /** @type {HookState} */
+  errorPrepareStackTraceHook: undefined,
+  /** @type {HookState} */
+  processEmitHook: undefined,
+  /** @type {HookState} */
+  moduleResolveFilenameHook: undefined,
+
+  /** @type {Array<(request: string, parent: any, isMain: boolean, options: any, redirectedRequest: string) => void>} */
+  onConflictingLibraryRedirectArr: [],
+
+  // If true, the caches are reset before a stack trace formatting operation
+  emptyCacheBetweenOperations: false,
+
+  // Maps a file path to a string containing the file contents
+  fileContentsCache: Object.create(null),
+
+  // Maps a file path to a source map for that file
+  /** @type {Record<string, {url: string, map: TraceMap}} */
+  sourceMapCache: Object.create(null),
+
+  // Priority list of retrieve handlers
+  retrieveFileHandlers: [],
+  retrieveMapHandlers: [],
+
+  // Priority list of internally-implemented handlers.
+  // When resetting state, we must keep these.
+  internalRetrieveFileHandlers: [],
+  internalRetrieveMapHandlers: [],
+
+});
+
+// Supports {browser, node, auto}
+var environment = "auto";
+
+// Regex for detecting source maps
+var reSourceMap = /^data:application\/json[^,]+base64,/;
+
+function isInBrowser() {
+  if (environment === "browser")
+    return true;
+  if (environment === "node")
+    return false;
+  return ((typeof window !== 'undefined') && (typeof XMLHttpRequest === 'function') && !(window.require && window.module && window.process && window.process.type === "renderer"));
+}
+
+function hasGlobalProcessEventEmitter() {
+  return ((typeof process === 'object') && (process !== null) && (typeof process.on === 'function'));
+}
+
+function tryFileURLToPath(v) {
+  if(isFileUrl(v)) {
+    return fileURLToPath(v);
+  }
+  return v;
+}
+
+// TODO un-copy these from resolve-uri; see if they can be exported from that lib
+function isFileUrl(input) {
+  return input.startsWith('file:');
+}
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+function isSchemeRelativeUrl(input) {
+  return input.startsWith('//');
+}
+
+// #region Caches
+/** @param {string} pathOrFileUrl */
+function getCacheKey(pathOrFileUrl) {
+  if(pathOrFileUrl.startsWith('node:')) return pathOrFileUrl;
+  if(isFileUrl(pathOrFileUrl)) {
+    // Must normalize spaces to %20, stuff like that
+    return new URL(pathOrFileUrl).toString();
+  } else {
+    try {
+      return pathToFileURL(pathOrFileUrl).toString();
+    } catch {
+      return pathOrFileUrl;
+    }
+  }
+}
+function getFileContentsCache(key) {
+  return sharedData.fileContentsCache[getCacheKey(key)];
+}
+function hasFileContentsCacheFromKey(key) {
+  return Object.prototype.hasOwnProperty.call(sharedData.fileContentsCache, key);
+}
+function getFileContentsCacheFromKey(key) {
+  return sharedData.fileContentsCache[key];
+}
+function setFileContentsCache(key, value) {
+  return sharedData.fileContentsCache[getCacheKey(key)] = value;
+}
+function getSourceMapCache(key) {
+  return sharedData.sourceMapCache[getCacheKey(key)];
+}
+function setSourceMapCache(key, value) {
+  return sharedData.sourceMapCache[getCacheKey(key)] = value;
+}
+function clearCaches() {
+  sharedData.fileContentsCache = Object.create(null);
+  sharedData.sourceMapCache = Object.create(null);
+}
+// #endregion Caches
+
+function handlerExec(list, internalList) {
+  return function(arg) {
+    for (var i = 0; i < list.length; i++) {
+      var ret = list[i](arg);
+      if (ret) {
+        return ret;
+      }
+    }
+    for (var i = 0; i < internalList.length; i++) {
+      var ret = internalList[i](arg);
+      if (ret) {
+        return ret;
+      }
+    }
+    return null;
+  };
+}
+
+var retrieveFile = handlerExec(sharedData.retrieveFileHandlers, sharedData.internalRetrieveFileHandlers);
+
+sharedData.internalRetrieveFileHandlers.push(function(path) {
+  // Trim the path to make sure there is no extra whitespace.
+  path = path.trim();
+  if (/^file:/.test(path)) {
+    // existsSync/readFileSync can't handle file protocol, but once stripped, it works
+    path = path.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+      return drive ?
+        '' : // file:///C:/dir/file -> C:/dir/file
+        '/'; // file:///root-dir/file -> /root-dir/file
+    });
+  }
+  const key = getCacheKey(path);
+  if(hasFileContentsCacheFromKey(key)) {
+    return getFileContentsCacheFromKey(key);
+  }
+
+  var contents = '';
+  try {
+    if (!fs) {
+      // Use SJAX if we are in the browser
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', path, /** async */ false);
+      xhr.send(null);
+      if (xhr.readyState === 4 && xhr.status === 200) {
+        contents = xhr.responseText;
+      }
+    } else if (fs.existsSync(path)) {
+      // Otherwise, use the filesystem
+      contents = fs.readFileSync(path, 'utf8');
+    }
+  } catch (er) {
+    /* ignore any errors */
+  }
+
+  return setFileContentsCache(path, contents);
+});
+
+// Support URLs relative to a directory, but be careful about a protocol prefix
+// in case we are in the browser (i.e. directories may start with "http://" or "file:///")
+function supportRelativeURL(file, url) {
+  if(!file) return url;
+  // given that this happens within error formatting codepath, probably best to
+  // fallback instead of throwing if anything goes wrong
+  try {
+    // if should output a URL
+    if(isAbsoluteUrl(file) || isSchemeRelativeUrl(file)) {
+        if(isAbsoluteUrl(url) || isSchemeRelativeUrl(url)) {
+            return new URL(url, file).toString();
+        }
+        if(path.isAbsolute(url)) {
+            return new URL(pathToFileURL(url), file).toString();
+        }
+        // url is relative path or URL
+        return new URL(url.replace(/\\/g, '/'), file).toString();
+    }
+    // if should output a path (unless URL is something like https://)
+    if(path.isAbsolute(file)) {
+        if(isFileUrl(url)) {
+            return fileURLToPath(url);
+        }
+        if(isSchemeRelativeUrl(url)) {
+            return fileURLToPath(new URL(url, 'file://'));
+        }
+        if(isAbsoluteUrl(url)) {
+            // url is a non-file URL
+            // Go with the URL
+            return url;
+        }
+        if(path.isAbsolute(url)) {
+            // Normalize at all?  decodeURI or normalize slashes?
+            return path.normalize(url);
+        }
+        // url is relative path or URL
+        return path.join(file, '..', decodeURI(url));
+    }
+    // If we get here, file is relative.
+    // Shouldn't happen since node identifies modules with absolute paths or URLs.
+    // But we can take a stab at returning something meaningful anyway.
+    if(isAbsoluteUrl(url) || isSchemeRelativeUrl(url)) {
+        return url;
+    }
+    return path.join(file, '..', url);
+  } catch(e) {
+      return url;
+  }
+}
+
+// Return pathOrUrl in the same style as matchStyleOf: either a file URL or a native path
+function matchStyleOfPathOrUrl(matchStyleOf, pathOrUrl) {
+  try {
+    if(isAbsoluteUrl(matchStyleOf) || isSchemeRelativeUrl(matchStyleOf)) {
+      if(isAbsoluteUrl(pathOrUrl) || isSchemeRelativeUrl(pathOrUrl)) return pathOrUrl;
+      if(path.isAbsolute(pathOrUrl)) return pathToFileURL(pathOrUrl).toString();
+    } else if(path.isAbsolute(matchStyleOf)) {
+      if(isAbsoluteUrl(pathOrUrl) || isSchemeRelativeUrl(pathOrUrl)) {
+        return fileURLToPath(new URL(pathOrUrl, 'file://'));
+      }
+    }
+    return pathOrUrl;
+  } catch(e) {
+    return pathOrUrl;
+  }
+}
+
+function retrieveSourceMapURL(source) {
+  var fileData;
+
+  if (isInBrowser()) {
+     try {
+       var xhr = new XMLHttpRequest();
+       xhr.open('GET', source, false);
+       xhr.send(null);
+       fileData = xhr.readyState === 4 ? xhr.responseText : null;
+
+       // Support providing a sourceMappingURL via the SourceMap header
+       var sourceMapHeader = xhr.getResponseHeader("SourceMap") ||
+                             xhr.getResponseHeader("X-SourceMap");
+       if (sourceMapHeader) {
+         return sourceMapHeader;
+       }
+     } catch (e) {
+     }
+  }
+
+  // Get the URL of the source map
+  fileData = retrieveFile(tryFileURLToPath(source));
+  var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
+  // Keep executing the search to find the *last* sourceMappingURL to avoid
+  // picking up sourceMappingURLs from comments, strings, etc.
+  var lastMatch, match;
+  while (match = re.exec(fileData)) lastMatch = match;
+  if (!lastMatch) return null;
+  return lastMatch[1];
+};
+
+// Can be overridden by the retrieveSourceMap option to install. Takes a
+// generated source filename; returns a {map, optional url} object, or null if
+// there is no source map.  The map field may be either a string or the parsed
+// JSON object (ie, it must be a valid argument to the SourceMapConsumer
+// constructor).
+/** @type {(source: string) => import('./source-map-support').UrlAndMap | null} */
+var retrieveSourceMap = handlerExec(sharedData.retrieveMapHandlers, sharedData.internalRetrieveMapHandlers);
+sharedData.internalRetrieveMapHandlers.push(function(source) {
+  var sourceMappingURL = retrieveSourceMapURL(source);
+  if (!sourceMappingURL) return null;
+
+  // Read the contents of the source map
+  var sourceMapData;
+  if (reSourceMap.test(sourceMappingURL)) {
+    // Support source map URL as a data url
+    var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
+    sourceMapData = Buffer.from(rawData, "base64").toString();
+    sourceMappingURL = source;
+  } else {
+    // Support source map URLs relative to the source URL
+    sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
+    sourceMapData = retrieveFile(tryFileURLToPath(sourceMappingURL));
+  }
+
+  if (!sourceMapData) {
+    return null;
+  }
+
+  return {
+    url: sourceMappingURL,
+    map: sourceMapData
+  };
+});
+
+function mapSourcePosition(position) {
+  var sourceMap = getSourceMapCache(position.source);
+  if (!sourceMap) {
+    // Call the (overrideable) retrieveSourceMap function to get the source map.
+    var urlAndMap = retrieveSourceMap(position.source);
+    if (urlAndMap) {
+      sourceMap = setSourceMapCache(position.source, {
+        url: urlAndMap.url,
+        map: new AnyMap(urlAndMap.map, urlAndMap.url)
+      });
+
+      // Overwrite trace-mapping's resolutions, because they do not handle
+      // Windows paths the way we want.
+      // TODO Remove now that windows path support was added to resolve-uri and thus trace-mapping?
+      sourceMap.map.resolvedSources = sourceMap.map.sources.map(s => supportRelativeURL(sourceMap.url, s));
+
+      // Load all sources stored inline with the source map into the file cache
+      // to pretend like they are already loaded. They may not exist on disk.
+      if (sourceMap.map.sourcesContent) {
+        sourceMap.map.resolvedSources.forEach(function(resolvedSource, i) {
+          var contents = sourceMap.map.sourcesContent[i];
+          if (contents) {
+            setFileContentsCache(resolvedSource, contents);
+          }
+        });
+      }
+    } else {
+      sourceMap = setSourceMapCache(position.source, {
+        url: null,
+        map: null
+      });
+    }
+  }
+
+  // Resolve the source URL relative to the URL of the source map
+  if (sourceMap && sourceMap.map) {
+    var originalPosition = originalPositionFor(sourceMap.map, position);
+
+    // Only return the original position if a matching line was found. If no
+    // matching line is found then we return position instead, which will cause
+    // the stack trace to print the path and line for the compiled file. It is
+    // better to give a precise location in the compiled file than a vague
+    // location in the original file.
+    if (originalPosition.source !== null) {
+      // originalPosition.source has *already* been resolved against sourceMap.url
+      // so is *already* as absolute as possible.
+      // However, we want to ensure we output in same format as input: URL or native path
+      originalPosition.source = matchStyleOfPathOrUrl(
+        position.source, originalPosition.source);
+      return originalPosition;
+    }
+  }
+
+  return position;
+}
+
+// Parses code generated by FormatEvalOrigin(), a function inside V8:
+// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
+function mapEvalOrigin(origin) {
+  // Most eval() calls are in this format
+  var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+  if (match) {
+    var position = mapSourcePosition({
+      source: match[2],
+      line: +match[3],
+      column: match[4] - 1
+    });
+    return 'eval at ' + match[1] + ' (' + position.source + ':' +
+      position.line + ':' + (position.column + 1) + ')';
+  }
+
+  // Parse nested eval() calls using recursion
+  match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+  if (match) {
+    return 'eval at ' + match[1] + ' (' + mapEvalOrigin(match[2]) + ')';
+  }
+
+  // Make sure we still return useful information if we didn't find anything
+  return origin;
+}
+
+// This is copied almost verbatim from the V8 source code at
+// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
+// Update 2022-04-29:
+//    https://github.com/v8/v8/blob/98f6f100c5ab8e390e51422747c4ef644d5ac6f2/src/builtins/builtins-callsite.cc#L175-L179
+//    https://github.com/v8/v8/blob/98f6f100c5ab8e390e51422747c4ef644d5ac6f2/src/objects/call-site-info.cc#L795-L804
+//    https://github.com/v8/v8/blob/98f6f100c5ab8e390e51422747c4ef644d5ac6f2/src/objects/call-site-info.cc#L717-L750
+// The implementation of wrapCallSite() used to just forward to the actual source
+// code of CallSite.prototype.toString but unfortunately a new release of V8
+// did something to the prototype chain and broke the shim. The only fix I
+// could find was copy/paste.
+function CallSiteToString() {
+  var fileName;
+  var fileLocation = "";
+  if (this.isNative()) {
+    fileLocation = "native";
+  } else {
+    fileName = this.getScriptNameOrSourceURL();
+    if (!fileName && this.isEval()) {
+      fileLocation = this.getEvalOrigin();
+      fileLocation += ", ";  // Expecting source position to follow.
+    }
+
+    if (fileName) {
+      fileLocation += fileName;
+    } else {
+      // Source code does not originate from a file and is not native, but we
+      // can still get the source position inside the source string, e.g. in
+      // an eval string.
+      fileLocation += "<anonymous>";
+    }
+    var lineNumber = this.getLineNumber();
+    if (lineNumber != null) {
+      fileLocation += ":" + lineNumber;
+      var columnNumber = this.getColumnNumber();
+      if (columnNumber) {
+        fileLocation += ":" + columnNumber;
+      }
+    }
+  }
+
+  var line = "";
+  var isAsync = this.isAsync ? this.isAsync() : false;
+  if(isAsync) {
+    line += 'async ';
+    var isPromiseAll = this.isPromiseAll ? this.isPromiseAll() : false;
+    var isPromiseAny = this.isPromiseAny ? this.isPromiseAny() : false;
+    if(isPromiseAny || isPromiseAll) {
+      line += isPromiseAll ? 'Promise.all (index ' : 'Promise.any (index ';
+      var promiseIndex = this.getPromiseIndex();
+      line += promiseIndex + ')';
+    }
+  }
+  var functionName = this.getFunctionName();
+  var addSuffix = true;
+  var isConstructor = this.isConstructor();
+  var isMethodCall = !(this.isToplevel() || isConstructor);
+  if (isMethodCall) {
+    var typeName = this.getTypeName();
+    // Fixes shim to be backward compatable with Node v0 to v4
+    if (typeName === "[object Object]") {
+      typeName = "null";
+    }
+    var methodName = this.getMethodName();
+    if (functionName) {
+      if (typeName && functionName.indexOf(typeName) != 0) {
+        line += typeName + ".";
+      }
+      line += functionName;
+      if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
+        line += " [as " + methodName + "]";
+      }
+    } else {
+      line += typeName + "." + (methodName || "<anonymous>");
+    }
+  } else if (isConstructor) {
+    line += "new " + (functionName || "<anonymous>");
+  } else if (functionName) {
+    line += functionName;
+  } else {
+    line += fileLocation;
+    addSuffix = false;
+  }
+  if (addSuffix) {
+    line += " (" + fileLocation + ")";
+  }
+  return line;
+}
+
+function cloneCallSite(frame) {
+  var object = {};
+  Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
+    object[name] = /^(?:is|get)/.test(name) ? function() { return frame[name].call(frame); } : frame[name];
+  });
+  object.toString = CallSiteToString;
+  return object;
+}
+
+function wrapCallSite(frame, state) {
+  // provides interface backward compatibility
+  if (state === undefined) {
+    state = { nextPosition: null, curPosition: null }
+  }
+  if(frame.isNative()) {
+    state.curPosition = null;
+    return frame;
+  }
+
+  // Most call sites will return the source file from getFileName(), but code
+  // passed to eval() ending in "//# sourceURL=..." will return the source file
+  // from getScriptNameOrSourceURL() instead
+  var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+  if (source) {
+    // v8 does not expose its internal isWasm, etc methods, so we do this instead.
+    if(source.startsWith('wasm://')) {
+      state.curPosition = null;
+      return frame;
+    }
+
+    var line = frame.getLineNumber();
+    var column = frame.getColumnNumber() - 1;
+
+    // Fix position in Node where some (internal) code is prepended.
+    // See https://github.com/evanw/node-source-map-support/issues/36
+    // Header removed in node at ^10.16 || >=11.11.0
+    // v11 is not an LTS candidate, we can just test the one version with it.
+    // Test node versions for: 10.16-19, 10.20+, 12-19, 20-99, 100+, or 11.11
+    var noHeader = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/;
+    var headerLength = noHeader.test(process.version) ? 0 : 62;
+    if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
+      column -= headerLength;
+    }
+
+    var position = mapSourcePosition({
+      source: source,
+      line: line,
+      column: column
+    });
+    state.curPosition = position;
+    frame = cloneCallSite(frame);
+    var originalFunctionName = frame.getFunctionName;
+    frame.getFunctionName = function() {
+      if (state.nextPosition == null) {
+        return originalFunctionName();
+      }
+      return state.nextPosition.name || originalFunctionName();
+    };
+    frame.getFileName = function() { return position.source; };
+    frame.getLineNumber = function() { return position.line; };
+    frame.getColumnNumber = function() { return position.column + 1; };
+    frame.getScriptNameOrSourceURL = function() { return position.source; };
+    return frame;
+  }
+
+  // Code called using eval() needs special handling
+  var origin = frame.isEval() && frame.getEvalOrigin();
+  if (origin) {
+    origin = mapEvalOrigin(origin);
+    frame = cloneCallSite(frame);
+    frame.getEvalOrigin = function() { return origin; };
+    return frame;
+  }
+
+  // If we get here then we were unable to change the source position
+  return frame;
+}
+
+var kIsNodeError = undefined;
+try {
+  // Get a deliberate ERR_INVALID_ARG_TYPE
+  // TODO is there a better way to reliably get an instance of NodeError?
+  path.resolve(123);
+} catch(e) {
+  const symbols = Object.getOwnPropertySymbols(e);
+  const symbol = symbols.find(function (s) {return s.toString().indexOf('kIsNodeError') >= 0});
+  if(symbol) kIsNodeError = symbol;
+}
+
+const ErrorPrototypeToString = (err) =>Error.prototype.toString.call(err);
+
+/** @param {HookState} hookState */
+function createPrepareStackTrace(hookState) {
+  return prepareStackTrace;
+
+  // This function is part of the V8 stack trace API, for more info see:
+  // https://v8.dev/docs/stack-trace-api
+  function prepareStackTrace(error, stack) {
+    if(!hookState.enabled) return hookState.originalValue.apply(this, arguments);
+
+    if (sharedData.emptyCacheBetweenOperations) {
+      clearCaches();
+    }
+
+    // node gives its own errors special treatment.  Mimic that behavior
+    // https://github.com/nodejs/node/blob/3cbaabc4622df1b4009b9d026a1a970bdbae6e89/lib/internal/errors.js#L118-L128
+    // https://github.com/nodejs/node/pull/39182
+    var errorString;
+    if (kIsNodeError) {
+      if(kIsNodeError in error) {
+        errorString = `${error.name} [${error.code}]: ${error.message}`;
+      } else {
+        errorString = ErrorPrototypeToString(error);
+      }
+    } else {
+      var name = error.name || 'Error';
+      var message = error.message || '';
+      errorString = message ? name + ": " + message : name;
+    }
+
+    var state = { nextPosition: null, curPosition: null };
+    var processedStack = [];
+    for (var i = stack.length - 1; i >= 0; i--) {
+      processedStack.push('\n    at ' + wrapCallSite(stack[i], state));
+      state.nextPosition = state.curPosition;
+    }
+    state.curPosition = state.nextPosition = null;
+    return errorString + processedStack.reverse().join('');
+  }
+}
+
+// Generate position and snippet of original source with pointer
+function getErrorSource(error) {
+  var match = /\n    at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
+  if (match) {
+    var source = match[1];
+    var line = +match[2];
+    var column = +match[3];
+
+    // Support the inline sourceContents inside the source map
+    var contents = getFileContentsCache(source);
+
+    const sourceAsPath = tryFileURLToPath(source);
+
+    // Support files on disk
+    if (!contents && fs && fs.existsSync(sourceAsPath)) {
+      try {
+        contents = fs.readFileSync(sourceAsPath, 'utf8');
+      } catch (er) {
+        contents = '';
+      }
+    }
+
+    // Format the line from the original source code like node does
+    if (contents) {
+      var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
+      if (code) {
+        return source + ':' + line + '\n' + code + '\n' +
+          new Array(column).join(' ') + '^';
+      }
+    }
+  }
+  return null;
+}
+
+function printFatalErrorUponExit (error) {
+  var source = getErrorSource(error);
+
+  // Ensure error is printed synchronously and not truncated
+  if (process.stderr._handle && process.stderr._handle.setBlocking) {
+    process.stderr._handle.setBlocking(true);
+  }
+
+  if (source) {
+    console.error(source);
+  }
+
+  // Matches node's behavior for colorized output
+  console.error(
+    util.inspect(error, {
+      customInspect: false,
+      colors: process.stderr.isTTY
+    })
+  );
+}
+
+function shimEmitUncaughtException () {
+  const originalValue = process.emit;
+  var hook = sharedData.processEmitHook = {
+    enabled: true,
+    originalValue,
+    installedValue: undefined
+  };
+  var isTerminatingDueToFatalException = false;
+  var fatalException;
+
+  process.emit = sharedData.processEmitHook.installedValue = function (type) {
+    const hadListeners = originalValue.apply(this, arguments);
+    if(hook.enabled) {
+      if (type === 'uncaughtException' && !hadListeners) {
+        isTerminatingDueToFatalException = true;
+        fatalException = arguments[1];
+        process.exit(1);
+      }
+      if (type === 'exit' && isTerminatingDueToFatalException) {
+        printFatalErrorUponExit(fatalException);
+      }
+    }
+    return hadListeners;
+  };
+}
+
+var originalRetrieveFileHandlers = sharedData.retrieveFileHandlers.slice(0);
+var originalRetrieveMapHandlers = sharedData.retrieveMapHandlers.slice(0);
+
+exports.wrapCallSite = wrapCallSite;
+exports.getErrorSource = getErrorSource;
+exports.mapSourcePosition = mapSourcePosition;
+exports.retrieveSourceMap = retrieveSourceMap;
+
+exports.install = function(options) {
+  options = options || {};
+
+  if (options.environment) {
+    environment = options.environment;
+    if (["node", "browser", "auto"].indexOf(environment) === -1) {
+      throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}")
+    }
+  }
+
+  // Use dynamicRequire to avoid including in browser bundles
+  var Module = dynamicRequire(module, 'module');
+
+  // Redirect subsequent imports of "source-map-support"
+  // to this package
+  const {redirectConflictingLibrary = true, onConflictingLibraryRedirect} = options;
+  if(redirectConflictingLibrary) {
+    if (!sharedData.moduleResolveFilenameHook) {
+      const originalValue = Module._resolveFilename;
+      const moduleResolveFilenameHook = sharedData.moduleResolveFilenameHook = {
+        enabled: true,
+        originalValue,
+        installedValue: undefined,
+      }
+      Module._resolveFilename = sharedData.moduleResolveFilenameHook.installedValue = function (request, parent, isMain, options) {
+        if (moduleResolveFilenameHook.enabled) {
+          // Match all source-map-support entrypoints: source-map-support, source-map-support/register
+          let requestRedirect;
+          if (request === 'source-map-support') {
+            requestRedirect = './';
+          } else if (request === 'source-map-support/register') {
+            requestRedirect = './register';
+          }
+
+          if (requestRedirect !== undefined) {
+              const newRequest = require.resolve(requestRedirect);
+              for (const cb of sharedData.onConflictingLibraryRedirectArr) {
+                cb(request, parent, isMain, options, newRequest);
+              }
+              request = newRequest;
+          }
+        }
+        
+        return originalValue.call(this, request, parent, isMain, options);
+      }
+    } 
+    if (onConflictingLibraryRedirect) {
+      sharedData.onConflictingLibraryRedirectArr.push(onConflictingLibraryRedirect);
+    }
+  }
+
+  // Allow sources to be found by methods other than reading the files
+  // directly from disk.
+  if (options.retrieveFile) {
+    if (options.overrideRetrieveFile) {
+      sharedData.retrieveFileHandlers.length = 0;
+    }
+
+    sharedData.retrieveFileHandlers.unshift(options.retrieveFile);
+  }
+
+  // Allow source maps to be found by methods other than reading the files
+  // directly from disk.
+  if (options.retrieveSourceMap) {
+    if (options.overrideRetrieveSourceMap) {
+      sharedData.retrieveMapHandlers.length = 0;
+    }
+
+    sharedData.retrieveMapHandlers.unshift(options.retrieveSourceMap);
+  }
+
+  // Support runtime transpilers that include inline source maps
+  if (options.hookRequire && !isInBrowser()) {
+    var $compile = Module.prototype._compile;
+
+    if (!$compile.__sourceMapSupport) {
+      Module.prototype._compile = function(content, filename) {
+        setFileContentsCache(filename, content);
+        setSourceMapCache(filename, undefined);
+        return $compile.call(this, content, filename);
+      };
+
+      Module.prototype._compile.__sourceMapSupport = true;
+    }
+  }
+
+  // Configure options
+  if (!sharedData.emptyCacheBetweenOperations) {
+    sharedData.emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
+      options.emptyCacheBetweenOperations : false;
+  }
+
+
+  // Install the error reformatter
+  if (!sharedData.errorPrepareStackTraceHook) {
+    const originalValue = Error.prepareStackTrace;
+    sharedData.errorPrepareStackTraceHook = {
+      enabled: true,
+      originalValue,
+      installedValue: undefined
+    };
+    Error.prepareStackTrace = sharedData.errorPrepareStackTraceHook.installedValue = createPrepareStackTrace(sharedData.errorPrepareStackTraceHook);
+  }
+
+  if (!sharedData.processEmitHook) {
+    var installHandler = 'handleUncaughtExceptions' in options ?
+      options.handleUncaughtExceptions : true;
+
+    // Do not override 'uncaughtException' with our own handler in Node.js
+    // Worker threads. Workers pass the error to the main thread as an event,
+    // rather than printing something to stderr and exiting.
+    try {
+      // We need to use `dynamicRequire` because `require` on it's own will be optimized by WebPack/Browserify.
+      var worker_threads = dynamicRequire(module, 'worker_threads');
+      if (worker_threads.isMainThread === false) {
+        installHandler = false;
+      }
+    } catch(e) {}
+
+    // Provide the option to not install the uncaught exception handler. This is
+    // to support other uncaught exception handlers (in test frameworks, for
+    // example). If this handler is not installed and there are no other uncaught
+    // exception handlers, uncaught exceptions will be caught by node's built-in
+    // exception handler and the process will still be terminated. However, the
+    // generated JavaScript code will be shown above the stack trace instead of
+    // the original source code.
+    if (installHandler && hasGlobalProcessEventEmitter()) {
+      shimEmitUncaughtException();
+    }
+  }
+};
+
+exports.uninstall = function() {
+  if(sharedData.processEmitHook) {
+    // Disable behavior
+    sharedData.processEmitHook.enabled = false;
+    // If possible, remove our hook function.  May not be possible if subsequent third-party hooks have wrapped around us.
+    if(process.emit === sharedData.processEmitHook.installedValue) {
+      process.emit = sharedData.processEmitHook.originalValue;
+    }
+    sharedData.processEmitHook = undefined;
+  }
+  if(sharedData.errorPrepareStackTraceHook) {
+    // Disable behavior
+    sharedData.errorPrepareStackTraceHook.enabled = false;
+    // If possible or necessary, remove our hook function.
+    // In vanilla environments, prepareStackTrace is `undefined`.
+    // We cannot delegate to `undefined` the way we can to a function w/`.apply()`; our only option is to remove the function.
+    // If we are the *first* hook installed, and another was installed on top of us, we have no choice but to remove both.
+    if(Error.prepareStackTrace === sharedData.errorPrepareStackTraceHook.installedValue || typeof sharedData.errorPrepareStackTraceHook.originalValue !== 'function') {
+      Error.prepareStackTrace = sharedData.errorPrepareStackTraceHook.originalValue;
+    }
+    sharedData.errorPrepareStackTraceHook = undefined;
+  }
+  if (sharedData.moduleResolveFilenameHook) {
+    // Disable behavior
+    sharedData.moduleResolveFilenameHook.enabled = false;
+    // If possible, remove our hook function.  May not be possible if subsequent third-party hooks have wrapped around us.
+    var Module = dynamicRequire(module, 'module');
+    if(Module._resolveFilename === sharedData.moduleResolveFilenameHook.installedValue) {
+      Module._resolveFilename = sharedData.moduleResolveFilenameHook.originalValue;
+    }
+    sharedData.moduleResolveFilenameHook = undefined;
+  }
+  sharedData.onConflictingLibraryRedirectArr.length = 0;
+}
+
+exports.resetRetrieveHandlers = function() {
+  sharedData.retrieveFileHandlers.length = 0;
+  sharedData.retrieveMapHandlers.length = 0;
+}

hardhat/node_modules/@ethereumjs/rlp/LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

hardhat/node_modules/@ethereumjs/rlp/README.md

@@ -0,0 +1,90 @@
+# @ethereumjs/rlp
+
+[![NPM Package][rlp-npm-badge]][rlp-npm-link]
+[![GitHub Issues][rlp-issues-badge]][rlp-issues-link]
+[![Actions Status][rlp-actions-badge]][rlp-actions-link]
+[![Code Coverage][rlp-coverage-badge]][rlp-coverage-link]
+[![Discord][discord-badge]][discord-link]
+
+| [Recursive Length Prefix](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp) encoding for Node.js and the browser. |
+| ----------------------------------------------------------------------------------------------------------------------------------------- |
+
+## Installation
+
+To obtain the latest version, simply require the project using `npm`:
+
+```shell
+npm install @ethereumjs/rlp
+```
+
+Install with `-g` if you want to use the CLI.
+
+## Usage
+
+```ts
+// ./examples/simple.ts
+
+import assert from 'assert'
+import { RLP } from '@ethereumjs/rlp'
+
+const nestedList = [[], [[]], [[], [[]]]]
+const encoded = RLP.encode(nestedList)
+const decoded = RLP.decode(encoded)
+assert.deepStrictEqual(decoded, nestedList, 'decoded output does not match original')
+console.log('assert.deepStrictEqual would have thrown if the decoded output did not match')
+```
+
+## Browser
+
+With the breaking release round in Summer 2023 we have added hybrid ESM/CJS builds for all our libraries (see section below) and have eliminated many of the caveats which had previously prevented a frictionless browser usage.
+
+It is now easily possible to run a browser build of one of the EthereumJS libraries within a modern browser using the provided ESM build. For a setup example see [./examples/browser.html](./examples/browser.html).
+
+## API
+
+`RLP.encode(plain)` - RLP encodes an `Array`, `Uint8Array` or `String` and returns a `Uint8Array`.
+
+`RLP.decode(encoded, [stream=false])` - Decodes an RLP encoded `Uint8Array`, `Array` or `String` and returns a `Uint8Array` or `NestedUint8Array`. If `stream` is enabled, it will just decode the first rlp sequence in the Uint8Array. By default, it would throw an error if there are more bytes in Uint8Array than used by the rlp sequence.
+
+### Buffer -> Uint8Array
+
+With the breaking releases from Summer 2023 we have removed all Node.js specific `Buffer` usages from our libraries and replace these with [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) representations, which are available both in Node.js and the browser (`Buffer` is a subclass of `Uint8Array`).
+
+We have converted existing Buffer conversion methods to Uint8Array conversion methods in the [@ethereumjs/util](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/util) `bytes` module, see the respective README section for guidance.
+
+### BigInt Support
+
+Starting with v4 the usage of [BN.js](https://github.com/indutny/bn.js/) for big numbers has been removed from the library and replaced with the usage of the native JS [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) data type (introduced in `ES2020`).
+
+Please note that number-related API signatures have changed along with this version update and the minimal build target has been updated to `ES2020`.
+
+## CLI
+
+`rlp encode <JSON string>`\
+`rlp decode <0x-prefixed hex string>`
+
+### Examples
+
+- `rlp encode '5'` -> `0x05`
+- `rlp encode '[5]'` -> `0xc105`
+- `rlp encode '["cat", "dog"]'` -> `0xc88363617483646f67`
+- `rlp decode 0xc88363617483646f67` -> `["cat","dog"]`
+
+## EthereumJS
+
+See our organizational [documentation](https://ethereumjs.readthedocs.io) for an introduction to `EthereumJS` as well as information on current standards and best practices. If you want to join for work or carry out improvements on the libraries, please review our [contribution guidelines](https://ethereumjs.readthedocs.io/en/latest/contributing.html) first.
+
+## License
+
+[MPL-2.0](<https://tldrlegal.com/license/mozilla-public-license-2.0-(mpl-2)>)
+
+[discord-badge]: https://img.shields.io/static/v1?logo=discord&label=discord&message=Join&color=blue
+[discord-link]: https://discord.gg/TNwARpR
+[rlp-npm-badge]: https://img.shields.io/npm/v/@ethereumjs/rlp.svg
+[rlp-npm-link]: https://www.npmjs.com/package/@ethereumjs/rlp
+[rlp-issues-badge]: https://img.shields.io/github/issues/ethereumjs/ethereumjs-monorepo/package:%20rlp?label=issues
+[rlp-issues-link]: https://github.com/ethereumjs/ethereumjs-monorepo/issues?q=is%3Aopen+is%3Aissue+label%3A"package%3A+rlp"
+[rlp-actions-badge]: https://github.com/ethereumjs/ethereumjs-monorepo/workflows/rlp/badge.svg
+[rlp-actions-link]: https://github.com/ethereumjs/ethereumjs-monorepo/actions?query=workflow%3A%22rlp%22
+[rlp-coverage-badge]: https://codecov.io/gh/ethereumjs/ethereumjs-monorepo/branch/master/graph/badge.svg?flag=rlp
+[rlp-coverage-link]: https://codecov.io/gh/ethereumjs/ethereumjs-monorepo/tree/master/packages/rlp

hardhat/node_modules/@ethereumjs/rlp/bin/rlp.cjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+const RLP = require('../dist/cjs/index.js')
+const method = process.argv[2]
+const strInput = process.argv[3]
+
+const { bytesToHex } = RLP.utils
+
+if (typeof strInput !== 'string') {
+  return console.error(`Expected JSON string input, received type: ${typeof strInput}`)
+}
+
+if (method === 'encode') {
+  // Parse JSON
+  let json
+  try {
+    json = JSON.parse(strInput)
+  } catch (error) {
+    const errorMsg = error.message ? error.message : error
+    return console.error(`Error could not parse JSON: ${errorMsg}`)
+  }
+
+  // Encode RLP
+  try {
+    const encoded = RLP.encode(json)
+    console.log('0x' + bytesToHex(encoded))
+  } catch (error) {
+    const errorMsg = error.message ? error.message : error
+    console.error(`Error encoding RLP: ${errorMsg}`)
+  }
+} else if (method === 'decode') {
+  // Decode
+  try {
+    const decoded = RLP.decode(strInput)
+    const json = JSON.stringify(arrToJSON(decoded))
+    console.log(json)
+  } catch (error) {
+    const errorMsg = error.message ? error.message : error
+    console.error(`Error decoding RLP: ${errorMsg}`)
+  }
+} else {
+  console.error('Unsupported method')
+}
+
+/**
+ * Uint8Array or Array<Uint8Array> to JSON
+ */
+function arrToJSON(ba) {
+  if (ba instanceof Uint8Array) {
+    return bytesToHex(ba)
+  } else if (ba instanceof Array) {
+    const arr = []
+    for (let i = 0; i < ba.length; i++) {
+      arr.push(arrToJSON(ba[i]))
+    }
+    return arr
+  }
+}

hardhat/node_modules/@ethereumjs/rlp/dist/cjs/index.d.ts

@@ -0,0 +1,39 @@
+export declare type Input = string | number | bigint | Uint8Array | Array<Input> | null | undefined;
+export declare type NestedUint8Array = Array<Uint8Array | NestedUint8Array>;
+export interface Decoded {
+    data: Uint8Array | NestedUint8Array;
+    remainder: Uint8Array;
+}
+/**
+ * RLP Encoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * This function takes in data, converts it to Uint8Array if not,
+ * and adds a length for recursion.
+ * @param input Will be converted to Uint8Array
+ * @returns Uint8Array of encoded data
+ **/
+export declare function encode(input: Input): Uint8Array;
+/**
+ * RLP Decoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * @param input Will be converted to Uint8Array
+ * @param stream Is the input a stream (false by default)
+ * @returns decoded Array of Uint8Arrays containing the original message
+ **/
+export declare function decode(input: Input, stream?: false): Uint8Array | NestedUint8Array;
+export declare function decode(input: Input, stream?: true): Decoded;
+declare function bytesToHex(uint8a: Uint8Array): string;
+declare function hexToBytes(hex: string): Uint8Array;
+/** Concatenates two Uint8Arrays into one. */
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+declare function utf8ToBytes(utf: string): Uint8Array;
+export declare const utils: {
+    bytesToHex: typeof bytesToHex;
+    concatBytes: typeof concatBytes;
+    hexToBytes: typeof hexToBytes;
+    utf8ToBytes: typeof utf8ToBytes;
+};
+export declare const RLP: {
+    encode: typeof encode;
+    decode: typeof decode;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

hardhat/node_modules/@ethereumjs/rlp/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;AAE3F,oBAAY,gBAAgB,GAAG,KAAK,CAAC,UAAU,GAAG,gBAAgB,CAAC,CAAA;AAEnE,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAAA;IACnC,SAAS,EAAE,UAAU,CAAA;CACtB;AAED;;;;;;IAMI;AACJ,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAgB/C;AAqCD;;;;;IAKI;AACJ,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,UAAU,GAAG,gBAAgB,CAAA;AACnF,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,IAAI,GAAG,OAAO,CAAA;AAiH5D,iBAAS,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAO9C;AASD,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAW3C;AAED,6CAA6C;AAC7C,iBAAS,WAAW,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAUxD;AAOD,iBAAS,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAE5C;AAoDD,eAAO,MAAM,KAAK;;;;;CAKjB,CAAA;AAED,eAAO,MAAM,GAAG;;;CAAqB,CAAA"}

hardhat/node_modules/@ethereumjs/rlp/dist/cjs/index.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RLP = exports.utils = exports.decode = exports.encode = void 0;
+/**
+ * RLP Encoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * This function takes in data, converts it to Uint8Array if not,
+ * and adds a length for recursion.
+ * @param input Will be converted to Uint8Array
+ * @returns Uint8Array of encoded data
+ **/
+function encode(input) {
+    if (Array.isArray(input)) {
+        const output = [];
+        let outputLength = 0;
+        for (let i = 0; i < input.length; i++) {
+            const encoded = encode(input[i]);
+            output.push(encoded);
+            outputLength += encoded.length;
+        }
+        return concatBytes(encodeLength(outputLength, 192), ...output);
+    }
+    const inputBuf = toBytes(input);
+    if (inputBuf.length === 1 && inputBuf[0] < 128) {
+        return inputBuf;
+    }
+    return concatBytes(encodeLength(inputBuf.length, 128), inputBuf);
+}
+exports.encode = encode;
+/**
+ * Slices a Uint8Array, throws if the slice goes out-of-bounds of the Uint8Array.
+ * E.g. `safeSlice(hexToBytes('aa'), 1, 2)` will throw.
+ * @param input
+ * @param start
+ * @param end
+ */
+function safeSlice(input, start, end) {
+    if (end > input.length) {
+        throw new Error('invalid RLP (safeSlice): end slice of Uint8Array out-of-bounds');
+    }
+    return input.slice(start, end);
+}
+/**
+ * Parse integers. Check if there is no leading zeros
+ * @param v The value to parse
+ */
+function decodeLength(v) {
+    if (v[0] === 0) {
+        throw new Error('invalid RLP: extra zeros');
+    }
+    return parseHexByte(bytesToHex(v));
+}
+function encodeLength(len, offset) {
+    if (len < 56) {
+        return Uint8Array.from([len + offset]);
+    }
+    const hexLength = numberToHex(len);
+    const lLength = hexLength.length / 2;
+    const firstByte = numberToHex(offset + 55 + lLength);
+    return Uint8Array.from(hexToBytes(firstByte + hexLength));
+}
+function decode(input, stream = false) {
+    if (typeof input === 'undefined' || input === null || input.length === 0) {
+        return Uint8Array.from([]);
+    }
+    const inputBytes = toBytes(input);
+    const decoded = _decode(inputBytes);
+    if (stream) {
+        return {
+            data: decoded.data,
+            remainder: decoded.remainder.slice(),
+        };
+    }
+    if (decoded.remainder.length !== 0) {
+        throw new Error('invalid RLP: remainder must be zero');
+    }
+    return decoded.data;
+}
+exports.decode = decode;
+/** Decode an input with RLP */
+function _decode(input) {
+    let length, llength, data, innerRemainder, d;
+    const decoded = [];
+    const firstByte = input[0];
+    if (firstByte <= 0x7f) {
+        // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.
+        return {
+            data: input.slice(0, 1),
+            remainder: input.subarray(1),
+        };
+    }
+    else if (firstByte <= 0xb7) {
+        // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string
+        // The range of the first byte is [0x80, 0xb7]
+        length = firstByte - 0x7f;
+        // set 0x80 null to 0
+        if (firstByte === 0x80) {
+            data = Uint8Array.from([]);
+        }
+        else {
+            data = safeSlice(input, 1, length);
+        }
+        if (length === 2 && data[0] < 0x80) {
+            throw new Error('invalid RLP encoding: invalid prefix, single byte < 0x80 are not prefixed');
+        }
+        return {
+            data,
+            remainder: input.subarray(length),
+        };
+    }
+    else if (firstByte <= 0xbf) {
+        // string is greater than 55 bytes long. A single byte with the value (0xb7 plus the length of the length),
+        // followed by the length, followed by the string
+        llength = firstByte - 0xb6;
+        if (input.length - 1 < llength) {
+            throw new Error('invalid RLP: not enough bytes for string length');
+        }
+        length = decodeLength(safeSlice(input, 1, llength));
+        if (length <= 55) {
+            throw new Error('invalid RLP: expected string length to be greater than 55');
+        }
+        data = safeSlice(input, llength, length + llength);
+        return {
+            data,
+            remainder: input.subarray(length + llength),
+        };
+    }
+    else if (firstByte <= 0xf7) {
+        // a list between 0-55 bytes long
+        length = firstByte - 0xbf;
+        innerRemainder = safeSlice(input, 1, length);
+        while (innerRemainder.length) {
+            d = _decode(innerRemainder);
+            decoded.push(d.data);
+            innerRemainder = d.remainder;
+        }
+        return {
+            data: decoded,
+            remainder: input.subarray(length),
+        };
+    }
+    else {
+        // a list over 55 bytes long
+        llength = firstByte - 0xf6;
+        length = decodeLength(safeSlice(input, 1, llength));
+        if (length < 56) {
+            throw new Error('invalid RLP: encoded list too short');
+        }
+        const totalLength = llength + length;
+        if (totalLength > input.length) {
+            throw new Error('invalid RLP: total length is larger than the data');
+        }
+        innerRemainder = safeSlice(input, llength, totalLength);
+        while (innerRemainder.length) {
+            d = _decode(innerRemainder);
+            decoded.push(d.data);
+            innerRemainder = d.remainder;
+        }
+        return {
+            data: decoded,
+            remainder: input.subarray(totalLength),
+        };
+    }
+}
+const cachedHexes = Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));
+function bytesToHex(uint8a) {
+    // Pre-caching chars with `cachedHexes` speeds this up 6x
+    let hex = '';
+    for (let i = 0; i < uint8a.length; i++) {
+        hex += cachedHexes[uint8a[i]];
+    }
+    return hex;
+}
+function parseHexByte(hexByte) {
+    const byte = Number.parseInt(hexByte, 16);
+    if (Number.isNaN(byte))
+        throw new Error('Invalid byte sequence');
+    return byte;
+}
+// Caching slows it down 2-3x
+function hexToBytes(hex) {
+    if (typeof hex !== 'string') {
+        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
+    }
+    if (hex.length % 2)
+        throw new Error('hexToBytes: received invalid unpadded hex');
+    const array = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < array.length; i++) {
+        const j = i * 2;
+        array[i] = parseHexByte(hex.slice(j, j + 2));
+    }
+    return array;
+}
+/** Concatenates two Uint8Arrays into one. */
+function concatBytes(...arrays) {
+    if (arrays.length === 1)
+        return arrays[0];
+    const length = arrays.reduce((a, arr) => a + arr.length, 0);
+    const result = new Uint8Array(length);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const arr = arrays[i];
+        result.set(arr, pad);
+        pad += arr.length;
+    }
+    return result;
+}
+function utf8ToBytes(utf) {
+    return new TextEncoder().encode(utf);
+}
+/** Transform an integer into its hexadecimal value */
+function numberToHex(integer) {
+    if (integer < 0) {
+        throw new Error('Invalid integer as argument, must be unsigned!');
+    }
+    const hex = integer.toString(16);
+    return hex.length % 2 ? `0${hex}` : hex;
+}
+/** Pad a string to be even */
+function padToEven(a) {
+    return a.length % 2 ? `0${a}` : a;
+}
+/** Check if a string is prefixed by 0x */
+function isHexPrefixed(str) {
+    return str.length >= 2 && str[0] === '0' && str[1] === 'x';
+}
+/** Removes 0x from a given String */
+function stripHexPrefix(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return isHexPrefixed(str) ? str.slice(2) : str;
+}
+/** Transform anything into a Uint8Array */
+function toBytes(v) {
+    if (v instanceof Uint8Array) {
+        return v;
+    }
+    if (typeof v === 'string') {
+        if (isHexPrefixed(v)) {
+            return hexToBytes(padToEven(stripHexPrefix(v)));
+        }
+        return utf8ToBytes(v);
+    }
+    if (typeof v === 'number' || typeof v === 'bigint') {
+        if (!v) {
+            return Uint8Array.from([]);
+        }
+        return hexToBytes(numberToHex(v));
+    }
+    if (v === null || v === undefined) {
+        return Uint8Array.from([]);
+    }
+    throw new Error('toBytes: received unsupported type ' + typeof v);
+}
+exports.utils = {
+    bytesToHex,
+    concatBytes,
+    hexToBytes,
+    utf8ToBytes,
+};
+exports.RLP = { encode, decode };
+//# sourceMappingURL=index.js.map

hardhat/node_modules/@ethereumjs/rlp/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

hardhat/node_modules/@ethereumjs/rlp/dist/esm/index.d.ts

@@ -0,0 +1,39 @@
+export declare type Input = string | number | bigint | Uint8Array | Array<Input> | null | undefined;
+export declare type NestedUint8Array = Array<Uint8Array | NestedUint8Array>;
+export interface Decoded {
+    data: Uint8Array | NestedUint8Array;
+    remainder: Uint8Array;
+}
+/**
+ * RLP Encoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * This function takes in data, converts it to Uint8Array if not,
+ * and adds a length for recursion.
+ * @param input Will be converted to Uint8Array
+ * @returns Uint8Array of encoded data
+ **/
+export declare function encode(input: Input): Uint8Array;
+/**
+ * RLP Decoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * @param input Will be converted to Uint8Array
+ * @param stream Is the input a stream (false by default)
+ * @returns decoded Array of Uint8Arrays containing the original message
+ **/
+export declare function decode(input: Input, stream?: false): Uint8Array | NestedUint8Array;
+export declare function decode(input: Input, stream?: true): Decoded;
+declare function bytesToHex(uint8a: Uint8Array): string;
+declare function hexToBytes(hex: string): Uint8Array;
+/** Concatenates two Uint8Arrays into one. */
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+declare function utf8ToBytes(utf: string): Uint8Array;
+export declare const utils: {
+    bytesToHex: typeof bytesToHex;
+    concatBytes: typeof concatBytes;
+    hexToBytes: typeof hexToBytes;
+    utf8ToBytes: typeof utf8ToBytes;
+};
+export declare const RLP: {
+    encode: typeof encode;
+    decode: typeof decode;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

hardhat/node_modules/@ethereumjs/rlp/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;AAE3F,oBAAY,gBAAgB,GAAG,KAAK,CAAC,UAAU,GAAG,gBAAgB,CAAC,CAAA;AAEnE,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAAA;IACnC,SAAS,EAAE,UAAU,CAAA;CACtB;AAED;;;;;;IAMI;AACJ,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAgB/C;AAqCD;;;;;IAKI;AACJ,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,UAAU,GAAG,gBAAgB,CAAA;AACnF,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,IAAI,GAAG,OAAO,CAAA;AAiH5D,iBAAS,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAO9C;AASD,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAW3C;AAED,6CAA6C;AAC7C,iBAAS,WAAW,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAUxD;AAOD,iBAAS,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAE5C;AAoDD,eAAO,MAAM,KAAK;;;;;CAKjB,CAAA;AAED,eAAO,MAAM,GAAG;;;CAAqB,CAAA"}

hardhat/node_modules/@ethereumjs/rlp/dist/esm/index.js

@@ -0,0 +1,256 @@
+/**
+ * RLP Encoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * This function takes in data, converts it to Uint8Array if not,
+ * and adds a length for recursion.
+ * @param input Will be converted to Uint8Array
+ * @returns Uint8Array of encoded data
+ **/
+export function encode(input) {
+    if (Array.isArray(input)) {
+        const output = [];
+        let outputLength = 0;
+        for (let i = 0; i < input.length; i++) {
+            const encoded = encode(input[i]);
+            output.push(encoded);
+            outputLength += encoded.length;
+        }
+        return concatBytes(encodeLength(outputLength, 192), ...output);
+    }
+    const inputBuf = toBytes(input);
+    if (inputBuf.length === 1 && inputBuf[0] < 128) {
+        return inputBuf;
+    }
+    return concatBytes(encodeLength(inputBuf.length, 128), inputBuf);
+}
+/**
+ * Slices a Uint8Array, throws if the slice goes out-of-bounds of the Uint8Array.
+ * E.g. `safeSlice(hexToBytes('aa'), 1, 2)` will throw.
+ * @param input
+ * @param start
+ * @param end
+ */
+function safeSlice(input, start, end) {
+    if (end > input.length) {
+        throw new Error('invalid RLP (safeSlice): end slice of Uint8Array out-of-bounds');
+    }
+    return input.slice(start, end);
+}
+/**
+ * Parse integers. Check if there is no leading zeros
+ * @param v The value to parse
+ */
+function decodeLength(v) {
+    if (v[0] === 0) {
+        throw new Error('invalid RLP: extra zeros');
+    }
+    return parseHexByte(bytesToHex(v));
+}
+function encodeLength(len, offset) {
+    if (len < 56) {
+        return Uint8Array.from([len + offset]);
+    }
+    const hexLength = numberToHex(len);
+    const lLength = hexLength.length / 2;
+    const firstByte = numberToHex(offset + 55 + lLength);
+    return Uint8Array.from(hexToBytes(firstByte + hexLength));
+}
+export function decode(input, stream = false) {
+    if (typeof input === 'undefined' || input === null || input.length === 0) {
+        return Uint8Array.from([]);
+    }
+    const inputBytes = toBytes(input);
+    const decoded = _decode(inputBytes);
+    if (stream) {
+        return {
+            data: decoded.data,
+            remainder: decoded.remainder.slice(),
+        };
+    }
+    if (decoded.remainder.length !== 0) {
+        throw new Error('invalid RLP: remainder must be zero');
+    }
+    return decoded.data;
+}
+/** Decode an input with RLP */
+function _decode(input) {
+    let length, llength, data, innerRemainder, d;
+    const decoded = [];
+    const firstByte = input[0];
+    if (firstByte <= 0x7f) {
+        // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.
+        return {
+            data: input.slice(0, 1),
+            remainder: input.subarray(1),
+        };
+    }
+    else if (firstByte <= 0xb7) {
+        // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string
+        // The range of the first byte is [0x80, 0xb7]
+        length = firstByte - 0x7f;
+        // set 0x80 null to 0
+        if (firstByte === 0x80) {
+            data = Uint8Array.from([]);
+        }
+        else {
+            data = safeSlice(input, 1, length);
+        }
+        if (length === 2 && data[0] < 0x80) {
+            throw new Error('invalid RLP encoding: invalid prefix, single byte < 0x80 are not prefixed');
+        }
+        return {
+            data,
+            remainder: input.subarray(length),
+        };
+    }
+    else if (firstByte <= 0xbf) {
+        // string is greater than 55 bytes long. A single byte with the value (0xb7 plus the length of the length),
+        // followed by the length, followed by the string
+        llength = firstByte - 0xb6;
+        if (input.length - 1 < llength) {
+            throw new Error('invalid RLP: not enough bytes for string length');
+        }
+        length = decodeLength(safeSlice(input, 1, llength));
+        if (length <= 55) {
+            throw new Error('invalid RLP: expected string length to be greater than 55');
+        }
+        data = safeSlice(input, llength, length + llength);
+        return {
+            data,
+            remainder: input.subarray(length + llength),
+        };
+    }
+    else if (firstByte <= 0xf7) {
+        // a list between 0-55 bytes long
+        length = firstByte - 0xbf;
+        innerRemainder = safeSlice(input, 1, length);
+        while (innerRemainder.length) {
+            d = _decode(innerRemainder);
+            decoded.push(d.data);
+            innerRemainder = d.remainder;
+        }
+        return {
+            data: decoded,
+            remainder: input.subarray(length),
+        };
+    }
+    else {
+        // a list over 55 bytes long
+        llength = firstByte - 0xf6;
+        length = decodeLength(safeSlice(input, 1, llength));
+        if (length < 56) {
+            throw new Error('invalid RLP: encoded list too short');
+        }
+        const totalLength = llength + length;
+        if (totalLength > input.length) {
+            throw new Error('invalid RLP: total length is larger than the data');
+        }
+        innerRemainder = safeSlice(input, llength, totalLength);
+        while (innerRemainder.length) {
+            d = _decode(innerRemainder);
+            decoded.push(d.data);
+            innerRemainder = d.remainder;
+        }
+        return {
+            data: decoded,
+            remainder: input.subarray(totalLength),
+        };
+    }
+}
+const cachedHexes = Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));
+function bytesToHex(uint8a) {
+    // Pre-caching chars with `cachedHexes` speeds this up 6x
+    let hex = '';
+    for (let i = 0; i < uint8a.length; i++) {
+        hex += cachedHexes[uint8a[i]];
+    }
+    return hex;
+}
+function parseHexByte(hexByte) {
+    const byte = Number.parseInt(hexByte, 16);
+    if (Number.isNaN(byte))
+        throw new Error('Invalid byte sequence');
+    return byte;
+}
+// Caching slows it down 2-3x
+function hexToBytes(hex) {
+    if (typeof hex !== 'string') {
+        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
+    }
+    if (hex.length % 2)
+        throw new Error('hexToBytes: received invalid unpadded hex');
+    const array = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < array.length; i++) {
+        const j = i * 2;
+        array[i] = parseHexByte(hex.slice(j, j + 2));
+    }
+    return array;
+}
+/** Concatenates two Uint8Arrays into one. */
+function concatBytes(...arrays) {
+    if (arrays.length === 1)
+        return arrays[0];
+    const length = arrays.reduce((a, arr) => a + arr.length, 0);
+    const result = new Uint8Array(length);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const arr = arrays[i];
+        result.set(arr, pad);
+        pad += arr.length;
+    }
+    return result;
+}
+function utf8ToBytes(utf) {
+    return new TextEncoder().encode(utf);
+}
+/** Transform an integer into its hexadecimal value */
+function numberToHex(integer) {
+    if (integer < 0) {
+        throw new Error('Invalid integer as argument, must be unsigned!');
+    }
+    const hex = integer.toString(16);
+    return hex.length % 2 ? `0${hex}` : hex;
+}
+/** Pad a string to be even */
+function padToEven(a) {
+    return a.length % 2 ? `0${a}` : a;
+}
+/** Check if a string is prefixed by 0x */
+function isHexPrefixed(str) {
+    return str.length >= 2 && str[0] === '0' && str[1] === 'x';
+}
+/** Removes 0x from a given String */
+function stripHexPrefix(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return isHexPrefixed(str) ? str.slice(2) : str;
+}
+/** Transform anything into a Uint8Array */
+function toBytes(v) {
+    if (v instanceof Uint8Array) {
+        return v;
+    }
+    if (typeof v === 'string') {
+        if (isHexPrefixed(v)) {
+            return hexToBytes(padToEven(stripHexPrefix(v)));
+        }
+        return utf8ToBytes(v);
+    }
+    if (typeof v === 'number' || typeof v === 'bigint') {
+        if (!v) {
+            return Uint8Array.from([]);
+        }
+        return hexToBytes(numberToHex(v));
+    }
+    if (v === null || v === undefined) {
+        return Uint8Array.from([]);
+    }
+    throw new Error('toBytes: received unsupported type ' + typeof v);
+}
+export const utils = {
+    bytesToHex,
+    concatBytes,
+    hexToBytes,
+    utf8ToBytes,
+};
+export const RLP = { encode, decode };
+//# sourceMappingURL=index.js.map

hardhat/node_modules/@ethereumjs/rlp/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

hardhat/node_modules/@ethereumjs/rlp/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@ethereumjs/rlp",
+  "version": "5.0.2",
+  "description": "Recursive Length Prefix Encoding Module",
+  "keywords": [
+    "rlp",
+    "ethereum"
+  ],
+  "homepage": "https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/rlp#readme",
+  "bugs": {
+    "url": "https://github.com/ethereumjs/ethereumjs-monorepo/issues?q=is%3Aissue+label%3A%22package%3A+rlp%22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ethereumjs/ethereumjs-monorepo.git"
+  },
+  "license": "MPL-2.0",
+  "author": {
+    "name": "martin becze",
+    "email": "mjbecze@gmail.com"
+  },
+  "contributors": [
+    "Alex Beregszaszi <alex@rtfs.hu>",
+    "Holger Drewes <Holger.Drewes@gmail.com>",
+    "Paul Miller <pkg@paulmillr.com>"
+  ],
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "bin": {
+    "rlp": "bin/rlp.cjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "benchmarks": "node ./benchmarks/index.js",
+    "build": "../../config/cli/ts-build.sh node",
+    "build:benchmarks": "npm run build && tsc -p tsconfig.benchmarks.json",
+    "clean": "../../config/cli/clean-package.sh",
+    "coverage": "c8 --all --reporter=lcov --reporter=text npm run test:node",
+    "examples": "tsx ../../scripts/examples-runner.ts -- rlp",
+    "examples:build": "npx embedme README.md",
+    "lint": "../../config/cli/lint.sh",
+    "lint:diff": "../../config/cli/lint-diff.sh",
+    "lint:fix": "../../config/cli/lint-fix.sh",
+    "prepublishOnly": "../../config/cli/prepublish.sh",
+    "test": "npm run test:node && npm run test:browser",
+    "test:browser": "npx vitest run --browser.name=chrome --browser.headless -c=vitest.config.browser.ts",
+    "test:node": "npx vitest run",
+    "tsc": "../../config/cli/ts-compile.sh"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "benchmark": "^2.1.4"
+  }
+}

hardhat/node_modules/@ethereumjs/rlp/src/index.ts

@@ -0,0 +1,298 @@
+export type Input = string | number | bigint | Uint8Array | Array<Input> | null | undefined
+
+export type NestedUint8Array = Array<Uint8Array | NestedUint8Array>
+
+export interface Decoded {
+  data: Uint8Array | NestedUint8Array
+  remainder: Uint8Array
+}
+
+/**
+ * RLP Encoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * This function takes in data, converts it to Uint8Array if not,
+ * and adds a length for recursion.
+ * @param input Will be converted to Uint8Array
+ * @returns Uint8Array of encoded data
+ **/
+export function encode(input: Input): Uint8Array {
+  if (Array.isArray(input)) {
+    const output: Uint8Array[] = []
+    let outputLength = 0
+    for (let i = 0; i < input.length; i++) {
+      const encoded = encode(input[i])
+      output.push(encoded)
+      outputLength += encoded.length
+    }
+    return concatBytes(encodeLength(outputLength, 192), ...output)
+  }
+  const inputBuf = toBytes(input)
+  if (inputBuf.length === 1 && inputBuf[0] < 128) {
+    return inputBuf
+  }
+  return concatBytes(encodeLength(inputBuf.length, 128), inputBuf)
+}
+
+/**
+ * Slices a Uint8Array, throws if the slice goes out-of-bounds of the Uint8Array.
+ * E.g. `safeSlice(hexToBytes('aa'), 1, 2)` will throw.
+ * @param input
+ * @param start
+ * @param end
+ */
+function safeSlice(input: Uint8Array, start: number, end: number) {
+  if (end > input.length) {
+    throw new Error('invalid RLP (safeSlice): end slice of Uint8Array out-of-bounds')
+  }
+  return input.slice(start, end)
+}
+
+/**
+ * Parse integers. Check if there is no leading zeros
+ * @param v The value to parse
+ */
+function decodeLength(v: Uint8Array): number {
+  if (v[0] === 0) {
+    throw new Error('invalid RLP: extra zeros')
+  }
+  return parseHexByte(bytesToHex(v))
+}
+
+function encodeLength(len: number, offset: number): Uint8Array {
+  if (len < 56) {
+    return Uint8Array.from([len + offset])
+  }
+  const hexLength = numberToHex(len)
+  const lLength = hexLength.length / 2
+  const firstByte = numberToHex(offset + 55 + lLength)
+  return Uint8Array.from(hexToBytes(firstByte + hexLength))
+}
+
+/**
+ * RLP Decoding based on https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+ * @param input Will be converted to Uint8Array
+ * @param stream Is the input a stream (false by default)
+ * @returns decoded Array of Uint8Arrays containing the original message
+ **/
+export function decode(input: Input, stream?: false): Uint8Array | NestedUint8Array
+export function decode(input: Input, stream?: true): Decoded
+export function decode(input: Input, stream = false): Uint8Array | NestedUint8Array | Decoded {
+  if (typeof input === 'undefined' || input === null || (input as any).length === 0) {
+    return Uint8Array.from([])
+  }
+
+  const inputBytes = toBytes(input)
+  const decoded = _decode(inputBytes)
+
+  if (stream) {
+    return {
+      data: decoded.data,
+      remainder: decoded.remainder.slice(),
+    }
+  }
+  if (decoded.remainder.length !== 0) {
+    throw new Error('invalid RLP: remainder must be zero')
+  }
+
+  return decoded.data
+}
+
+/** Decode an input with RLP */
+function _decode(input: Uint8Array): Decoded {
+  let length: number, llength: number, data: Uint8Array, innerRemainder: Uint8Array, d: Decoded
+  const decoded = []
+  const firstByte = input[0]
+
+  if (firstByte <= 0x7f) {
+    // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.
+    return {
+      data: input.slice(0, 1),
+      remainder: input.subarray(1),
+    }
+  } else if (firstByte <= 0xb7) {
+    // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string
+    // The range of the first byte is [0x80, 0xb7]
+    length = firstByte - 0x7f
+
+    // set 0x80 null to 0
+    if (firstByte === 0x80) {
+      data = Uint8Array.from([])
+    } else {
+      data = safeSlice(input, 1, length)
+    }
+
+    if (length === 2 && data[0] < 0x80) {
+      throw new Error('invalid RLP encoding: invalid prefix, single byte < 0x80 are not prefixed')
+    }
+
+    return {
+      data,
+      remainder: input.subarray(length),
+    }
+  } else if (firstByte <= 0xbf) {
+    // string is greater than 55 bytes long. A single byte with the value (0xb7 plus the length of the length),
+    // followed by the length, followed by the string
+    llength = firstByte - 0xb6
+    if (input.length - 1 < llength) {
+      throw new Error('invalid RLP: not enough bytes for string length')
+    }
+    length = decodeLength(safeSlice(input, 1, llength))
+    if (length <= 55) {
+      throw new Error('invalid RLP: expected string length to be greater than 55')
+    }
+    data = safeSlice(input, llength, length + llength)
+
+    return {
+      data,
+      remainder: input.subarray(length + llength),
+    }
+  } else if (firstByte <= 0xf7) {
+    // a list between 0-55 bytes long
+    length = firstByte - 0xbf
+    innerRemainder = safeSlice(input, 1, length)
+    while (innerRemainder.length) {
+      d = _decode(innerRemainder)
+      decoded.push(d.data)
+      innerRemainder = d.remainder
+    }
+
+    return {
+      data: decoded,
+      remainder: input.subarray(length),
+    }
+  } else {
+    // a list over 55 bytes long
+    llength = firstByte - 0xf6
+    length = decodeLength(safeSlice(input, 1, llength))
+    if (length < 56) {
+      throw new Error('invalid RLP: encoded list too short')
+    }
+    const totalLength = llength + length
+    if (totalLength > input.length) {
+      throw new Error('invalid RLP: total length is larger than the data')
+    }
+
+    innerRemainder = safeSlice(input, llength, totalLength)
+
+    while (innerRemainder.length) {
+      d = _decode(innerRemainder)
+      decoded.push(d.data)
+      innerRemainder = d.remainder
+    }
+
+    return {
+      data: decoded,
+      remainder: input.subarray(totalLength),
+    }
+  }
+}
+
+const cachedHexes = Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'))
+function bytesToHex(uint8a: Uint8Array): string {
+  // Pre-caching chars with `cachedHexes` speeds this up 6x
+  let hex = ''
+  for (let i = 0; i < uint8a.length; i++) {
+    hex += cachedHexes[uint8a[i]]
+  }
+  return hex
+}
+
+function parseHexByte(hexByte: string): number {
+  const byte = Number.parseInt(hexByte, 16)
+  if (Number.isNaN(byte)) throw new Error('Invalid byte sequence')
+  return byte
+}
+
+// Caching slows it down 2-3x
+function hexToBytes(hex: string): Uint8Array {
+  if (typeof hex !== 'string') {
+    throw new TypeError('hexToBytes: expected string, got ' + typeof hex)
+  }
+  if (hex.length % 2) throw new Error('hexToBytes: received invalid unpadded hex')
+  const array = new Uint8Array(hex.length / 2)
+  for (let i = 0; i < array.length; i++) {
+    const j = i * 2
+    array[i] = parseHexByte(hex.slice(j, j + 2))
+  }
+  return array
+}
+
+/** Concatenates two Uint8Arrays into one. */
+function concatBytes(...arrays: Uint8Array[]): Uint8Array {
+  if (arrays.length === 1) return arrays[0]
+  const length = arrays.reduce((a, arr) => a + arr.length, 0)
+  const result = new Uint8Array(length)
+  for (let i = 0, pad = 0; i < arrays.length; i++) {
+    const arr = arrays[i]
+    result.set(arr, pad)
+    pad += arr.length
+  }
+  return result
+}
+
+// Global symbols in both browsers and Node.js since v11
+// See https://github.com/microsoft/TypeScript/issues/31535
+declare const TextEncoder: any
+declare const TextDecoder: any
+
+function utf8ToBytes(utf: string): Uint8Array {
+  return new TextEncoder().encode(utf)
+}
+
+/** Transform an integer into its hexadecimal value */
+function numberToHex(integer: number | bigint): string {
+  if (integer < 0) {
+    throw new Error('Invalid integer as argument, must be unsigned!')
+  }
+  const hex = integer.toString(16)
+  return hex.length % 2 ? `0${hex}` : hex
+}
+
+/** Pad a string to be even */
+function padToEven(a: string): string {
+  return a.length % 2 ? `0${a}` : a
+}
+
+/** Check if a string is prefixed by 0x */
+function isHexPrefixed(str: string): boolean {
+  return str.length >= 2 && str[0] === '0' && str[1] === 'x'
+}
+
+/** Removes 0x from a given String */
+function stripHexPrefix(str: string): string {
+  if (typeof str !== 'string') {
+    return str
+  }
+  return isHexPrefixed(str) ? str.slice(2) : str
+}
+
+/** Transform anything into a Uint8Array */
+function toBytes(v: Input): Uint8Array {
+  if (v instanceof Uint8Array) {
+    return v
+  }
+  if (typeof v === 'string') {
+    if (isHexPrefixed(v)) {
+      return hexToBytes(padToEven(stripHexPrefix(v)))
+    }
+    return utf8ToBytes(v)
+  }
+  if (typeof v === 'number' || typeof v === 'bigint') {
+    if (!v) {
+      return Uint8Array.from([])
+    }
+    return hexToBytes(numberToHex(v))
+  }
+  if (v === null || v === undefined) {
+    return Uint8Array.from([])
+  }
+  throw new Error('toBytes: received unsupported type ' + typeof v)
+}
+
+export const utils = {
+  bytesToHex,
+  concatBytes,
+  hexToBytes,
+  utf8ToBytes,
+}
+
+export const RLP = { encode, decode }

hardhat/node_modules/@ethereumjs/util/LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

hardhat/node_modules/@ethereumjs/util/README.md

@@ -0,0 +1,316 @@
+# @ethereumjs/util
+
+[![NPM Package][util-npm-badge]][util-npm-link]
+[![GitHub Issues][util-issues-badge]][util-issues-link]
+[![Actions Status][util-actions-badge]][util-actions-link]
+[![Code Coverage][util-coverage-badge]][util-coverage-link]
+[![Discord][discord-badge]][discord-link]
+
+| A collection of utility functions for Ethereum. |
+| ----------------------------------------------- |
+
+## Installation
+
+To obtain the latest version, simply require the project using `npm`:
+
+```shell
+npm install @ethereumjs/util
+```
+
+## Usage
+
+This package contains the following modules providing respective helper methods, classes and commonly re-used constants.
+
+All helpers are re-exported from the root level and deep imports are not necessary. So an import can be done like this:
+
+```ts
+import { hexToBytes, isValidChecksumAddress } from '@ethereumjs/util'
+```
+
+### Module: [account](src/account.ts)
+
+Class representing an `Account` and providing private/public key and address-related functionality (creation, validation, conversion).
+
+```ts
+// ./examples/account.ts
+
+import { Account } from '@ethereumjs/util'
+
+const account = Account.fromAccountData({
+  nonce: '0x02',
+  balance: '0x0384',
+  storageRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
+  codeHash: '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
+})
+console.log(`Account with nonce=${account.nonce} and balance=${account.balance} created`)
+```
+
+For Verkle or other contexts it can be useful to create partial accounts not containing all the account parameters. This is supported starting with v9.1.0:
+
+```ts
+// ./examples/accountPartial.ts
+
+import { Account } from '@ethereumjs/util'
+
+const account = Account.fromPartialAccountData({
+  nonce: '0x02',
+  balance: '0x0384',
+})
+console.log(`Partial account with nonce=${account.nonce} and balance=${account.balance} created`)
+```
+
+### Module: [address](src/address.ts)
+
+Class representing an Ethereum `Address` with instantiation helpers and validation methods.
+
+```ts
+// ./examples/address.ts
+
+import { Address } from '@ethereumjs/util'
+
+const address = Address.fromString('0x2f015c60e0be116b1f0cd534704db9c92118fb6a')
+console.log(`Ethereum address ${address.toString()} created`)
+```
+
+### Module: [blobs](src/blobs.ts)
+
+Module providing helpers for 4844 blobs and versioned hashes.
+
+```ts
+// ./examples/blobs.ts
+
+import { bytesToHex, computeVersionedHash, getBlobs } from '@ethereumjs/util'
+
+const blobs = getBlobs('test input')
+
+console.log('Created the following blobs:')
+console.log(blobs)
+
+const commitment = new Uint8Array([1, 2, 3])
+const blobCommitmentVersion = 0x01
+const versionedHash = computeVersionedHash(commitment, blobCommitmentVersion)
+
+console.log(`Versioned hash ${bytesToHex(versionedHash)} computed`)
+```
+
+### Module: [bytes](src/bytes.ts)
+
+Byte-related helper and conversion functions.
+
+```ts
+// ./examples/bytes.ts
+
+import { bytesToBigInt } from '@ethereumjs/util'
+
+const bytesValue = new Uint8Array([97])
+const bigIntValue = bytesToBigInt(bytesValue)
+
+console.log(`Converted value: ${bigIntValue}`)
+```
+
+### Module: [constants](src/constants.ts)
+
+Exposed constants (e.g. `KECCAK256_NULL_S` for string representation of Keccak-256 hash of null)
+
+```ts
+// ./examples/constants.ts
+
+import { BIGINT_2EXP96, KECCAK256_NULL_S } from '@ethereumjs/util'
+
+console.log(`The keccak-256 hash of null: ${KECCAK256_NULL_S}`)
+console.log(`BigInt constants (performance), e.g. BIGINT_2EXP96: ${BIGINT_2EXP96}`)
+```
+
+### Module: [db](src/db.ts)
+
+DB interface for database abstraction (Blockchain, Trie), see e.g. [@ethereumjs/trie recipes](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/trie/recipes/level.ts)) for usage.
+
+### Module: [genesis](src/genesis.ts)
+
+Genesis related interfaces and helpers.
+
+### Module: [internal](src/internal.ts)
+
+Internalized simple helper methods like `isHexString`. Note that methods from this module might get deprecated in the future.
+
+### Module: [kzg](src/kzg.ts)
+
+KZG interface (used for 4844 blob txs), see [@ethereumjs/tx](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/tx/README.md#kzg-setup) README for main usage instructions.
+
+### Module: [mapDB](src/mapDB.ts)
+
+Simple map DB implementation using the `DB` interface (see above).
+
+### Module: [requests](src/requests.ts)
+
+Module with various type and an abstract base class for [EIP-7685](https://eips.ethereum.org/EIPS/eip-7685) general purpose execution layer requests to the CL (Prague hardfork) as well as concrete implementations for the currently supported request types:
+
+- [EIP-6110](https://eips.ethereum.org/EIPS/eip-6110): `DepositRequest` (Prague Harfork)
+- [EIP-7002](https://eips.ethereum.org/EIPS/eip-7002): `WithdrawawlRequest` (Prague Hardfork)
+- [EIP-7251](https://eips.ethereum.org/EIPS/eip-7251): `ConsolidationRequest` (Prague Hardfork)
+
+These request types are mainly used within the [@ethereumjs/block](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/block) library where applied usage instructions are provided in the README.
+
+### Module: [signature](src/signature.ts)
+
+Functionality for signing, signature validation, conversion, recovery.
+
+```ts
+// ./examples/signature.ts
+
+import { bytesToHex, ecrecover, hexToBytes } from '@ethereumjs/util'
+
+const chainId = BigInt(3) // Ropsten
+
+const echash = hexToBytes('0x82ff40c0a986c6a5cfad4ddf4c3aa6996f1a7837f9c398e17e5de5cbd5a12b28')
+const r = hexToBytes('0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9')
+const s = hexToBytes('0x129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66')
+const v = BigInt(41)
+
+const pubkey = ecrecover(echash, v, r, s, chainId)
+
+console.log(`Recovered public key ${bytesToHex(pubkey)} from valid signature values`)
+```
+
+### Module: [types](src/types.ts)
+
+Various TypeScript types. Direct usage is not recommended, type structure might change in the future.
+
+### Module: [withdrawal](src/withdrawal.ts)
+
+Class representing an `EIP-4895` `Withdrawal` with different constructors as well as conversion and output helpers.
+
+```ts
+// ./examples/withdrawal.ts
+
+import { Withdrawal } from '@ethereumjs/util'
+
+const withdrawal = Withdrawal.fromWithdrawalData({
+  index: 0n,
+  validatorIndex: 65535n,
+  address: '0x0000000000000000000000000000000000000000',
+  amount: 0n,
+})
+
+console.log('Withdrawal object created:')
+console.log(withdrawal.toJSON())
+```
+
+## Browser
+
+With the breaking release round in Summer 2023 we have added hybrid ESM/CJS builds for all our libraries (see section below) and have eliminated many of the caveats which had previously prevented a frictionless browser usage.
+
+It is now easily possible to run a browser build of one of the EthereumJS libraries within a modern browser using the provided ESM build. For a setup example see [./examples/browser.html](./examples/browser.html).
+
+## API
+
+### Documentation
+
+Read the [API docs](docs/).
+
+### Upgrade Helpers in bytes-Module
+
+Depending on the extend of `Buffer` usage within your own libraries and other planning considerations, there are the two upgrade options to do the switch to `Uint8Array` yourself or keep `Buffer` and do transitions for input and output values.
+
+We have updated the `@ethereumjs/util` `bytes` module with helpers for the most common conversions:
+
+```ts
+Buffer.alloc(97) // Allocate a Buffer with length 97
+new Uint8Array(97) // Allocate a Uint8Array with length 97
+
+Buffer.from('342770c0', 'hex') // Convert a hex string to a Buffer
+hexToBytes('0x342770c0') // Convert a prefixed hex string to a Uint8Array, Util.hexToBytes()
+
+`0x${myBuffer.toString('hex')}` // Convert a Buffer to a prefixed hex string
+bytesToHex(myUint8Array) // Convert a Uint8Array to a prefixed hex string
+
+intToBuffer(9) // Convert an integer to a Buffer, old (removed)
+intToBytes(9) // Convert an integer to a Uint8Array, Util.intToBytes()
+bytesToInt(myUint8Array) // Convert a Uint8Array to an integer, Util.bytesToInt()
+
+bigIntToBytes(myBigInt) // Convert a BigInt to a Uint8Array, Util.bigIntToBytes()
+bytesToBigInt(myUint8Array) // Convert a Uint8Array to a BigInt, Util.bytesToInt()
+
+utf8ToBytes(myUtf8String) // Converts a UTF-8 string to a Uint8Array, Util.utf8ToBytes()
+bytesToUtf8(myUint8Array) // Converts a Uint8Array to a UTF-8 string, Util.bytesToUtf8()
+
+toBuffer(v: ToBufferInputTypes) // Converts various byte compatible types to Buffer, old (removed)
+toBytes(v: ToBytesInputTypes) // Converts various byte compatible types to Uint8Array, Util.toBytes()
+```
+
+Helper methods can be imported like this:
+
+```ts
+import { hexToBytes } from '@ethereumjs/util'
+```
+
+### Hybrid CJS/ESM Builds
+
+With the breaking releases from Summer 2023 we have started to ship our libraries with both CommonJS (`cjs` folder) and ESM builds (`esm` folder), see `package.json` for the detailed setup.
+
+If you use an ES6-style `import` in your code files from the ESM build will be used:
+
+```ts
+import { EthereumJSClass } from '@ethereumjs/[PACKAGE_NAME]'
+```
+
+If you use Node.js specific `require`, the CJS build will be used:
+
+```ts
+const { EthereumJSClass } = require('@ethereumjs/[PACKAGE_NAME]')
+```
+
+Using ESM will give you additional advantages over CJS beyond browser usage like static code analysis / Tree Shaking which CJS can not provide.
+
+### Buffer -> Uint8Array
+
+With the breaking releases from Summer 2023 we have removed all Node.js specific `Buffer` usages from our libraries and replace these with [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) representations, which are available both in Node.js and the browser (`Buffer` is a subclass of `Uint8Array`).
+
+We have converted existing Buffer conversion methods to Uint8Array conversion methods in the [@ethereumjs/util](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/util) `bytes` module, see the respective README section for guidance.
+
+### BigInt Support
+
+Starting with Util v8 the usage of [BN.js](https://github.com/indutny/bn.js/) for big numbers has been removed from the library and replaced with the usage of the native JS [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) data type (introduced in `ES2020`).
+
+Please note that number-related API signatures have changed along with this version update and the minimal build target has been updated to `ES2020`.
+
+### ethjs-util methods
+
+The following methods are available by an internalized version of the [ethjs-util](https://github.com/ethjs/ethjs-util) package (`MIT` license), see [internal.ts](src/internal.ts). The original package is not maintained any more and the original functionality will be replaced by own implementations over time (starting with the `v7.1.3` release, October 2021).
+
+- arrayContainsArray
+- getBinarySize
+- stripHexPrefix
+- isHexString
+- isHexString
+- padToEven
+- fromAscii
+- fromUtf8
+- toUtf8
+- toAscii
+- getKeys
+
+They can be imported by name:
+
+```ts
+import { stripHexPrefix } from '@ethereumjs/util'
+```
+
+## EthereumJS
+
+See our organizational [documentation](https://ethereumjs.readthedocs.io) for an introduction to `EthereumJS` as well as information on current standards and best practices. If you want to join for work or carry out improvements on the libraries, please review our [contribution guidelines](https://ethereumjs.readthedocs.io/en/latest/contributing.html) first.
+
+## License
+
+[MPL-2.0](<https://tldrlegal.com/license/mozilla-public-license-2.0-(mpl-2)>)
+
+[util-npm-badge]: https://img.shields.io/npm/v/@ethereumjs/util.svg
+[util-npm-link]: https://www.npmjs.org/package/@ethereumjs/util
+[util-issues-badge]: https://img.shields.io/github/issues/ethereumjs/ethereumjs-monorepo/package:%20util?label=issues
+[util-issues-link]: https://github.com/ethereumjs/ethereumjs-monorepo/issues?q=is%3Aopen+is%3Aissue+label%3A"package%3A+util"
+[util-actions-badge]: https://github.com/ethereumjs/ethereumjs-monorepo/workflows/Util/badge.svg
+[util-actions-link]: https://github.com/ethereumjs/ethereumjs-monorepo/actions?query=workflow%3A%22Util%22
+[util-coverage-badge]: https://codecov.io/gh/ethereumjs/ethereumjs-monorepo/branch/master/graph/badge.svg?flag=util
+[util-coverage-link]: https://codecov.io/gh/ethereumjs/ethereumjs-monorepo/tree/master/packages/util
+[discord-badge]: https://img.shields.io/static/v1?logo=discord&label=discord&message=Join&color=blue
+[discord-link]: https://discord.gg/TNwARpR

hardhat/node_modules/@ethereumjs/util/dist/cjs/account.d.ts

@@ -0,0 +1,163 @@
+import type { BigIntLike, BytesLike, PrefixedHexString } from './types.js';
+export interface AccountData {
+    nonce?: BigIntLike;
+    balance?: BigIntLike;
+    storageRoot?: BytesLike;
+    codeHash?: BytesLike;
+}
+export interface PartialAccountData {
+    nonce?: BigIntLike | null;
+    balance?: BigIntLike | null;
+    storageRoot?: BytesLike | null;
+    codeHash?: BytesLike | null;
+    codeSize?: BigIntLike | null;
+    version?: BigIntLike | null;
+}
+export declare type AccountBodyBytes = [Uint8Array, Uint8Array, Uint8Array, Uint8Array];
+/**
+ * Account class to load and maintain the  basic account objects.
+ * Supports partial loading and access required for verkle with null
+ * as the placeholder.
+ *
+ * Note: passing undefined in constructor is different from null
+ * While undefined leads to default assignment, null is retained
+ * to track the information not available/loaded because of partial
+ * witness access
+ */
+export declare class Account {
+    _nonce: bigint | null;
+    _balance: bigint | null;
+    _storageRoot: Uint8Array | null;
+    _codeHash: Uint8Array | null;
+    _codeSize: number | null;
+    _version: number | null;
+    get version(): number;
+    set version(_version: number);
+    get nonce(): bigint;
+    set nonce(_nonce: bigint);
+    get balance(): bigint;
+    set balance(_balance: bigint);
+    get storageRoot(): Uint8Array;
+    set storageRoot(_storageRoot: Uint8Array);
+    get codeHash(): Uint8Array;
+    set codeHash(_codeHash: Uint8Array);
+    get codeSize(): number;
+    set codeSize(_codeSize: number);
+    static fromAccountData(accountData: AccountData): Account;
+    static fromPartialAccountData(partialAccountData: PartialAccountData): Account;
+    static fromRlpSerializedAccount(serialized: Uint8Array): Account;
+    static fromRlpSerializedPartialAccount(serialized: Uint8Array): Account;
+    static fromValuesArray(values: Uint8Array[]): Account;
+    /**
+     * This constructor assigns and validates the values.
+     * Use the static factory methods to assist in creating an Account from varying data types.
+     * undefined get assigned with the defaults present, but null args are retained as is
+     */
+    constructor(nonce?: bigint | null, balance?: bigint | null, storageRoot?: Uint8Array | null, codeHash?: Uint8Array | null, codeSize?: number | null, version?: number | null);
+    private _validate;
+    /**
+     * Returns an array of Uint8Arrays of the raw bytes for the account, in order.
+     */
+    raw(): Uint8Array[];
+    /**
+     * Returns the RLP serialization of the account as a `Uint8Array`.
+     */
+    serialize(): Uint8Array;
+    serializeWithPartialInfo(): Uint8Array;
+    /**
+     * Returns a `Boolean` determining if the account is a contract.
+     */
+    isContract(): boolean;
+    /**
+     * Returns a `Boolean` determining if the account is empty complying to the definition of
+     * account emptiness in [EIP-161](https://eips.ethereum.org/EIPS/eip-161):
+     * "An account is considered empty when it has no code and zero nonce and zero balance."
+     */
+    isEmpty(): boolean;
+}
+/**
+ * Checks if the address is a valid. Accepts checksummed addresses too.
+ */
+export declare const isValidAddress: (hexAddress: string) => hexAddress is `0x${string}`;
+/**
+ * Returns a checksummed address.
+ *
+ * If an eip1191ChainId is provided, the chainId will be included in the checksum calculation. This
+ * has the effect of checksummed addresses for one chain having invalid checksums for others.
+ * For more details see [EIP-1191](https://eips.ethereum.org/EIPS/eip-1191).
+ *
+ * WARNING: Checksums with and without the chainId will differ and the EIP-1191 checksum is not
+ * backwards compatible to the original widely adopted checksum format standard introduced in
+ * [EIP-55](https://eips.ethereum.org/EIPS/eip-55), so this will break in existing applications.
+ * Usage of this EIP is therefore discouraged unless you have a very targeted use case.
+ */
+export declare const toChecksumAddress: (hexAddress: string, eip1191ChainId?: BigIntLike) => PrefixedHexString;
+/**
+ * Checks if the address is a valid checksummed address.
+ *
+ * See toChecksumAddress' documentation for details about the eip1191ChainId parameter.
+ */
+export declare const isValidChecksumAddress: (hexAddress: string, eip1191ChainId?: BigIntLike) => boolean;
+/**
+ * Generates an address of a newly created contract.
+ * @param from The address which is creating this new address
+ * @param nonce The nonce of the from account
+ */
+export declare const generateAddress: (from: Uint8Array, nonce: Uint8Array) => Uint8Array;
+/**
+ * Generates an address for a contract created using CREATE2.
+ * @param from The address which is creating this new address
+ * @param salt A salt
+ * @param initCode The init code of the contract being created
+ */
+export declare const generateAddress2: (from: Uint8Array, salt: Uint8Array, initCode: Uint8Array) => Uint8Array;
+/**
+ * Checks if the private key satisfies the rules of the curve secp256k1.
+ */
+export declare const isValidPrivate: (privateKey: Uint8Array) => boolean;
+/**
+ * Checks if the public key satisfies the rules of the curve secp256k1
+ * and the requirements of Ethereum.
+ * @param publicKey The two points of an uncompressed key, unless sanitize is enabled
+ * @param sanitize Accept public keys in other formats
+ */
+export declare const isValidPublic: (publicKey: Uint8Array, sanitize?: boolean) => boolean;
+/**
+ * Returns the ethereum address of a given public key.
+ * Accepts "Ethereum public keys" and SEC1 encoded keys.
+ * @param pubKey The two points of an uncompressed key, unless sanitize is enabled
+ * @param sanitize Accept public keys in other formats
+ */
+export declare const pubToAddress: (pubKey: Uint8Array, sanitize?: boolean) => Uint8Array;
+export declare const publicToAddress: (pubKey: Uint8Array, sanitize?: boolean) => Uint8Array;
+/**
+ * Returns the ethereum public key of a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+export declare const privateToPublic: (privateKey: Uint8Array) => Uint8Array;
+/**
+ * Returns the ethereum address of a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+export declare const privateToAddress: (privateKey: Uint8Array) => Uint8Array;
+/**
+ * Converts a public key to the Ethereum format.
+ */
+export declare const importPublic: (publicKey: Uint8Array) => Uint8Array;
+/**
+ * Returns the zero address.
+ */
+export declare const zeroAddress: () => string;
+/**
+ * Checks if a given address is the zero address.
+ */
+export declare const isZeroAddress: (hexAddress: string) => boolean;
+export declare function accountBodyFromSlim(body: AccountBodyBytes): Uint8Array[];
+export declare function accountBodyToSlim(body: AccountBodyBytes): Uint8Array[];
+/**
+ * Converts a slim account (per snap protocol spec) to the RLP encoded version of the account
+ * @param body Array of 4 Uint8Array-like items to represent the account
+ * @returns RLP encoded version of the account
+ */
+export declare function accountBodyToRLP(body: AccountBodyBytes, couldBeSlim?: boolean): Uint8Array;
+//# sourceMappingURL=account.d.ts.map

hardhat/node_modules/@ethereumjs/util/dist/cjs/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/account.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAE1E,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,OAAO,CAAC,EAAE,UAAU,CAAA;IACpB,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IACzB,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IAC9B,QAAQ,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IAC3B,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CAC5B;AAED,oBAAY,gBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAA;AAE/E;;;;;;;;;GASG;AACH,qBAAa,OAAO;IAClB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAO;IAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAO;IAC9B,YAAY,EAAE,UAAU,GAAG,IAAI,CAAO;IACtC,SAAS,EAAE,UAAU,GAAG,IAAI,CAAO;IAEnC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAO;IAC/B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAO;IAE9B,IAAI,OAAO,IAOW,MAAM,CAD3B;IACD,IAAI,OAAO,CAAC,QAAQ,EAAE,MAAM,EAE3B;IAED,IAAI,KAAK,IAOS,MAAM,CADvB;IACD,IAAI,KAAK,CAAC,MAAM,EAAE,MAAM,EAEvB;IAED,IAAI,OAAO,IAOW,MAAM,CAD3B;IACD,IAAI,OAAO,CAAC,QAAQ,EAAE,MAAM,EAE3B;IAED,IAAI,WAAW,IAOe,UAAU,CADvC;IACD,IAAI,WAAW,CAAC,YAAY,EAAE,UAAU,EAEvC;IAED,IAAI,QAAQ,IAOY,UAAU,CADjC;IACD,IAAI,QAAQ,CAAC,SAAS,EAAE,UAAU,EAEjC;IAED,IAAI,QAAQ,IAOY,MAAM,CAD7B;IACD,IAAI,QAAQ,CAAC,SAAS,EAAE,MAAM,EAE7B;IAED,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,WAAW;IAc/C,MAAM,CAAC,sBAAsB,CAAC,kBAAkB,EAAE,kBAAkB;WAwBtD,wBAAwB,CAAC,UAAU,EAAE,UAAU;WAU/C,+BAA+B,CAAC,UAAU,EAAE,UAAU;WAwFtD,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE;IAMlD;;;;OAIG;gBAED,KAAK,GAAE,MAAM,GAAG,IAAe,EAC/B,OAAO,GAAE,MAAM,GAAG,IAAe,EACjC,WAAW,GAAE,UAAU,GAAG,IAAoB,EAC9C,QAAQ,GAAE,UAAU,GAAG,IAAqB,EAC5C,QAAQ,GAAE,MAAM,GAAG,IAAW,EAC9B,OAAO,GAAE,MAAM,GAAG,IAAQ;IAgB5B,OAAO,CAAC,SAAS;IAkBjB;;OAEG;IACH,GAAG,IAAI,UAAU,EAAE;IASnB;;OAEG;IACH,SAAS,IAAI,UAAU;IAIvB,wBAAwB,IAAI,UAAU;IA4CtC;;OAEG;IACH,UAAU,IAAI,OAAO;IAUrB;;;;OAIG;IACH,OAAO,IAAI,OAAO;CAgBnB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,eAAyB,MAAM,gCAQzD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,eAChB,MAAM,mBACD,UAAU,KAC1B,iBAuBF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,eACrB,MAAM,mBACD,UAAU,KAC1B,OAEF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,SAAmB,UAAU,SAAS,UAAU,KAAG,UAY9E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,SACrB,UAAU,QACV,UAAU,YACN,UAAU,KACnB,UAeF,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,eAAyB,UAAU,KAAG,OAEhE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,cAAwB,UAAU,aAAY,OAAO,KAAW,OAuBzF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,WAAqB,UAAU,aAAY,OAAO,KAAW,UAUrF,CAAA;AACD,eAAO,MAAM,eAAe,WAXkB,UAAU,aAAY,OAAO,KAAW,UAW3C,CAAA;AAE3C;;;GAGG;AACH,eAAO,MAAM,eAAe,eAAyB,UAAU,KAAG,UAIjE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,eAAyB,UAAU,KAAG,UAElE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,cAAwB,UAAU,KAAG,UAM7D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,QAAgB,MAIvC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,eAAyB,MAAM,KAAG,OAS3D,CAAA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,gBAQzD;AAGD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,gBAQvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,EAAE,WAAW,UAAO,cAG1E"}

hardhat/node_modules/@ethereumjs/util/dist/cjs/account.js

@@ -0,0 +1,564 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountBodyToRLP = exports.accountBodyToSlim = exports.accountBodyFromSlim = exports.isZeroAddress = exports.zeroAddress = exports.importPublic = exports.privateToAddress = exports.privateToPublic = exports.publicToAddress = exports.pubToAddress = exports.isValidPublic = exports.isValidPrivate = exports.generateAddress2 = exports.generateAddress = exports.isValidChecksumAddress = exports.toChecksumAddress = exports.isValidAddress = exports.Account = void 0;
+const rlp_1 = require("@ethereumjs/rlp");
+const keccak_js_1 = require("ethereum-cryptography/keccak.js");
+const secp256k1_js_1 = require("ethereum-cryptography/secp256k1.js");
+const bytes_js_1 = require("./bytes.js");
+const constants_js_1 = require("./constants.js");
+const helpers_js_1 = require("./helpers.js");
+const internal_js_1 = require("./internal.js");
+/**
+ * Account class to load and maintain the  basic account objects.
+ * Supports partial loading and access required for verkle with null
+ * as the placeholder.
+ *
+ * Note: passing undefined in constructor is different from null
+ * While undefined leads to default assignment, null is retained
+ * to track the information not available/loaded because of partial
+ * witness access
+ */
+class Account {
+    /**
+     * This constructor assigns and validates the values.
+     * Use the static factory methods to assist in creating an Account from varying data types.
+     * undefined get assigned with the defaults present, but null args are retained as is
+     */
+    constructor(nonce = constants_js_1.BIGINT_0, balance = constants_js_1.BIGINT_0, storageRoot = constants_js_1.KECCAK256_RLP, codeHash = constants_js_1.KECCAK256_NULL, codeSize = null, version = 0) {
+        this._nonce = null;
+        this._balance = null;
+        this._storageRoot = null;
+        this._codeHash = null;
+        // codeSize and version is separately stored in VKT
+        this._codeSize = null;
+        this._version = null;
+        this._nonce = nonce;
+        this._balance = balance;
+        this._storageRoot = storageRoot;
+        this._codeHash = codeHash;
+        if (codeSize === null && codeHash !== null && !this.isContract()) {
+            codeSize = 0;
+        }
+        this._codeSize = codeSize;
+        this._version = version;
+        this._validate();
+    }
+    get version() {
+        if (this._version !== null) {
+            return this._version;
+        }
+        else {
+            throw Error(`version=${this._version} not loaded`);
+        }
+    }
+    set version(_version) {
+        this._version = _version;
+    }
+    get nonce() {
+        if (this._nonce !== null) {
+            return this._nonce;
+        }
+        else {
+            throw Error(`nonce=${this._nonce} not loaded`);
+        }
+    }
+    set nonce(_nonce) {
+        this._nonce = _nonce;
+    }
+    get balance() {
+        if (this._balance !== null) {
+            return this._balance;
+        }
+        else {
+            throw Error(`balance=${this._balance} not loaded`);
+        }
+    }
+    set balance(_balance) {
+        this._balance = _balance;
+    }
+    get storageRoot() {
+        if (this._storageRoot !== null) {
+            return this._storageRoot;
+        }
+        else {
+            throw Error(`storageRoot=${this._storageRoot} not loaded`);
+        }
+    }
+    set storageRoot(_storageRoot) {
+        this._storageRoot = _storageRoot;
+    }
+    get codeHash() {
+        if (this._codeHash !== null) {
+            return this._codeHash;
+        }
+        else {
+            throw Error(`codeHash=${this._codeHash} not loaded`);
+        }
+    }
+    set codeHash(_codeHash) {
+        this._codeHash = _codeHash;
+    }
+    get codeSize() {
+        if (this._codeSize !== null) {
+            return this._codeSize;
+        }
+        else {
+            throw Error(`codeHash=${this._codeSize} not loaded`);
+        }
+    }
+    set codeSize(_codeSize) {
+        this._codeSize = _codeSize;
+    }
+    static fromAccountData(accountData) {
+        const { nonce, balance, storageRoot, codeHash } = accountData;
+        if (nonce === null || balance === null || storageRoot === null || codeHash === null) {
+            throw Error(`Partial fields not supported in fromAccountData`);
+        }
+        return new Account(nonce !== undefined ? (0, bytes_js_1.bytesToBigInt)((0, bytes_js_1.toBytes)(nonce)) : undefined, balance !== undefined ? (0, bytes_js_1.bytesToBigInt)((0, bytes_js_1.toBytes)(balance)) : undefined, storageRoot !== undefined ? (0, bytes_js_1.toBytes)(storageRoot) : undefined, codeHash !== undefined ? (0, bytes_js_1.toBytes)(codeHash) : undefined);
+    }
+    static fromPartialAccountData(partialAccountData) {
+        const { nonce, balance, storageRoot, codeHash, codeSize, version } = partialAccountData;
+        if (nonce === null &&
+            balance === null &&
+            storageRoot === null &&
+            codeHash === null &&
+            codeSize === null &&
+            version === null) {
+            throw Error(`All partial fields null`);
+        }
+        return new Account(nonce !== undefined && nonce !== null ? (0, bytes_js_1.bytesToBigInt)((0, bytes_js_1.toBytes)(nonce)) : nonce, balance !== undefined && balance !== null ? (0, bytes_js_1.bytesToBigInt)((0, bytes_js_1.toBytes)(balance)) : balance, storageRoot !== undefined && storageRoot !== null ? (0, bytes_js_1.toBytes)(storageRoot) : storageRoot, codeHash !== undefined && codeHash !== null ? (0, bytes_js_1.toBytes)(codeHash) : codeHash, codeSize !== undefined && codeSize !== null ? (0, bytes_js_1.bytesToInt)((0, bytes_js_1.toBytes)(codeSize)) : codeSize, version !== undefined && version !== null ? (0, bytes_js_1.bytesToInt)((0, bytes_js_1.toBytes)(version)) : version);
+    }
+    static fromRlpSerializedAccount(serialized) {
+        const values = rlp_1.RLP.decode(serialized);
+        if (!Array.isArray(values)) {
+            throw new Error('Invalid serialized account input. Must be array');
+        }
+        return this.fromValuesArray(values);
+    }
+    static fromRlpSerializedPartialAccount(serialized) {
+        const values = rlp_1.RLP.decode(serialized);
+        if (!Array.isArray(values)) {
+            throw new Error('Invalid serialized account input. Must be array');
+        }
+        let nonce = null;
+        if (!Array.isArray(values[0])) {
+            throw new Error('Invalid partial nonce encoding. Must be array');
+        }
+        else {
+            const isNotNullIndicator = (0, bytes_js_1.bytesToInt)(values[0][0]);
+            if (isNotNullIndicator !== 0 && isNotNullIndicator !== 1) {
+                throw new Error(`Invalid isNullIndicator=${isNotNullIndicator} for nonce`);
+            }
+            if (isNotNullIndicator === 1) {
+                nonce = (0, bytes_js_1.bytesToBigInt)(values[0][1]);
+            }
+        }
+        let balance = null;
+        if (!Array.isArray(values[1])) {
+            throw new Error('Invalid partial balance encoding. Must be array');
+        }
+        else {
+            const isNotNullIndicator = (0, bytes_js_1.bytesToInt)(values[1][0]);
+            if (isNotNullIndicator !== 0 && isNotNullIndicator !== 1) {
+                throw new Error(`Invalid isNullIndicator=${isNotNullIndicator} for balance`);
+            }
+            if (isNotNullIndicator === 1) {
+                balance = (0, bytes_js_1.bytesToBigInt)(values[1][1]);
+            }
+        }
+        let storageRoot = null;
+        if (!Array.isArray(values[2])) {
+            throw new Error('Invalid partial storageRoot encoding. Must be array');
+        }
+        else {
+            const isNotNullIndicator = (0, bytes_js_1.bytesToInt)(values[2][0]);
+            if (isNotNullIndicator !== 0 && isNotNullIndicator !== 1) {
+                throw new Error(`Invalid isNullIndicator=${isNotNullIndicator} for storageRoot`);
+            }
+            if (isNotNullIndicator === 1) {
+                storageRoot = values[2][1];
+            }
+        }
+        let codeHash = null;
+        if (!Array.isArray(values[3])) {
+            throw new Error('Invalid partial codeHash encoding. Must be array');
+        }
+        else {
+            const isNotNullIndicator = (0, bytes_js_1.bytesToInt)(values[3][0]);
+            if (isNotNullIndicator !== 0 && isNotNullIndicator !== 1) {
+                throw new Error(`Invalid isNullIndicator=${isNotNullIndicator} for codeHash`);
+            }
+            if (isNotNullIndicator === 1) {
+                codeHash = values[3][1];
+            }
+        }
+        let codeSize = null;
+        if (!Array.isArray(values[4])) {
+            throw new Error('Invalid partial codeSize encoding. Must be array');
+        }
+        else {
+            const isNotNullIndicator = (0, bytes_js_1.bytesToInt)(values[4][0]);
+            if (isNotNullIndicator !== 0 && isNotNullIndicator !== 1) {
+                throw new Error(`Invalid isNullIndicator=${isNotNullIndicator} for codeSize`);
+            }
+            if (isNotNullIndicator === 1) {
+                codeSize = (0, bytes_js_1.bytesToInt)(values[4][1]);
+            }
+        }
+        let version = null;
+        if (!Array.isArray(values[5])) {
+            throw new Error('Invalid partial version encoding. Must be array');
+        }
+        else {
+            const isNotNullIndicator = (0, bytes_js_1.bytesToInt)(values[5][0]);
+            if (isNotNullIndicator !== 0 && isNotNullIndicator !== 1) {
+                throw new Error(`Invalid isNullIndicator=${isNotNullIndicator} for version`);
+            }
+            if (isNotNullIndicator === 1) {
+                version = (0, bytes_js_1.bytesToInt)(values[5][1]);
+            }
+        }
+        return this.fromPartialAccountData({ balance, nonce, storageRoot, codeHash, codeSize, version });
+    }
+    static fromValuesArray(values) {
+        const [nonce, balance, storageRoot, codeHash] = values;
+        return new Account((0, bytes_js_1.bytesToBigInt)(nonce), (0, bytes_js_1.bytesToBigInt)(balance), storageRoot, codeHash);
+    }
+    _validate() {
+        if (this._nonce !== null && this._nonce < constants_js_1.BIGINT_0) {
+            throw new Error('nonce must be greater than zero');
+        }
+        if (this._balance !== null && this._balance < constants_js_1.BIGINT_0) {
+            throw new Error('balance must be greater than zero');
+        }
+        if (this._storageRoot !== null && this._storageRoot.length !== 32) {
+            throw new Error('storageRoot must have a length of 32');
+        }
+        if (this._codeHash !== null && this._codeHash.length !== 32) {
+            throw new Error('codeHash must have a length of 32');
+        }
+        if (this._codeSize !== null && this._codeSize < constants_js_1.BIGINT_0) {
+            throw new Error('codeSize must be greater than zero');
+        }
+    }
+    /**
+     * Returns an array of Uint8Arrays of the raw bytes for the account, in order.
+     */
+    raw() {
+        return [
+            (0, bytes_js_1.bigIntToUnpaddedBytes)(this.nonce),
+            (0, bytes_js_1.bigIntToUnpaddedBytes)(this.balance),
+            this.storageRoot,
+            this.codeHash,
+        ];
+    }
+    /**
+     * Returns the RLP serialization of the account as a `Uint8Array`.
+     */
+    serialize() {
+        return rlp_1.RLP.encode(this.raw());
+    }
+    serializeWithPartialInfo() {
+        const partialData = [];
+        const zeroEncoded = (0, bytes_js_1.intToUnpaddedBytes)(0);
+        const oneEncoded = (0, bytes_js_1.intToUnpaddedBytes)(1);
+        if (this._nonce !== null) {
+            partialData.push([oneEncoded, (0, bytes_js_1.bigIntToUnpaddedBytes)(this._nonce)]);
+        }
+        else {
+            partialData.push([zeroEncoded]);
+        }
+        if (this._balance !== null) {
+            partialData.push([oneEncoded, (0, bytes_js_1.bigIntToUnpaddedBytes)(this._balance)]);
+        }
+        else {
+            partialData.push([zeroEncoded]);
+        }
+        if (this._storageRoot !== null) {
+            partialData.push([oneEncoded, this._storageRoot]);
+        }
+        else {
+            partialData.push([zeroEncoded]);
+        }
+        if (this._codeHash !== null) {
+            partialData.push([oneEncoded, this._codeHash]);
+        }
+        else {
+            partialData.push([zeroEncoded]);
+        }
+        if (this._codeSize !== null) {
+            partialData.push([oneEncoded, (0, bytes_js_1.intToUnpaddedBytes)(this._codeSize)]);
+        }
+        else {
+            partialData.push([zeroEncoded]);
+        }
+        if (this._version !== null) {
+            partialData.push([oneEncoded, (0, bytes_js_1.intToUnpaddedBytes)(this._version)]);
+        }
+        else {
+            partialData.push([zeroEncoded]);
+        }
+        return rlp_1.RLP.encode(partialData);
+    }
+    /**
+     * Returns a `Boolean` determining if the account is a contract.
+     */
+    isContract() {
+        if (this._codeHash === null && this._codeSize === null) {
+            throw Error(`Insufficient data as codeHash=null and codeSize=null`);
+        }
+        return ((this._codeHash !== null && !(0, bytes_js_1.equalsBytes)(this._codeHash, constants_js_1.KECCAK256_NULL)) ||
+            (this._codeSize !== null && this._codeSize !== 0));
+    }
+    /**
+     * Returns a `Boolean` determining if the account is empty complying to the definition of
+     * account emptiness in [EIP-161](https://eips.ethereum.org/EIPS/eip-161):
+     * "An account is considered empty when it has no code and zero nonce and zero balance."
+     */
+    isEmpty() {
+        // helpful for determination in partial accounts
+        if ((this._balance !== null && this.balance !== constants_js_1.BIGINT_0) ||
+            (this._nonce === null && this.nonce !== constants_js_1.BIGINT_0) ||
+            (this._codeHash !== null && !(0, bytes_js_1.equalsBytes)(this.codeHash, constants_js_1.KECCAK256_NULL))) {
+            return false;
+        }
+        return (this.balance === constants_js_1.BIGINT_0 &&
+            this.nonce === constants_js_1.BIGINT_0 &&
+            (0, bytes_js_1.equalsBytes)(this.codeHash, constants_js_1.KECCAK256_NULL));
+    }
+}
+exports.Account = Account;
+/**
+ * Checks if the address is a valid. Accepts checksummed addresses too.
+ */
+const isValidAddress = function (hexAddress) {
+    try {
+        (0, helpers_js_1.assertIsString)(hexAddress);
+    }
+    catch (e) {
+        return false;
+    }
+    return /^0x[0-9a-fA-F]{40}$/.test(hexAddress);
+};
+exports.isValidAddress = isValidAddress;
+/**
+ * Returns a checksummed address.
+ *
+ * If an eip1191ChainId is provided, the chainId will be included in the checksum calculation. This
+ * has the effect of checksummed addresses for one chain having invalid checksums for others.
+ * For more details see [EIP-1191](https://eips.ethereum.org/EIPS/eip-1191).
+ *
+ * WARNING: Checksums with and without the chainId will differ and the EIP-1191 checksum is not
+ * backwards compatible to the original widely adopted checksum format standard introduced in
+ * [EIP-55](https://eips.ethereum.org/EIPS/eip-55), so this will break in existing applications.
+ * Usage of this EIP is therefore discouraged unless you have a very targeted use case.
+ */
+const toChecksumAddress = function (hexAddress, eip1191ChainId) {
+    (0, helpers_js_1.assertIsHexString)(hexAddress);
+    const address = (0, internal_js_1.stripHexPrefix)(hexAddress).toLowerCase();
+    let prefix = '';
+    if (eip1191ChainId !== undefined) {
+        const chainId = (0, bytes_js_1.bytesToBigInt)((0, bytes_js_1.toBytes)(eip1191ChainId));
+        prefix = chainId.toString() + '0x';
+    }
+    const bytes = (0, bytes_js_1.utf8ToBytes)(prefix + address);
+    const hash = (0, bytes_js_1.bytesToHex)((0, keccak_js_1.keccak256)(bytes)).slice(2);
+    let ret = '';
+    for (let i = 0; i < address.length; i++) {
+        if (parseInt(hash[i], 16) >= 8) {
+            ret += address[i].toUpperCase();
+        }
+        else {
+            ret += address[i];
+        }
+    }
+    return `0x${ret}`;
+};
+exports.toChecksumAddress = toChecksumAddress;
+/**
+ * Checks if the address is a valid checksummed address.
+ *
+ * See toChecksumAddress' documentation for details about the eip1191ChainId parameter.
+ */
+const isValidChecksumAddress = function (hexAddress, eip1191ChainId) {
+    return (0, exports.isValidAddress)(hexAddress) && (0, exports.toChecksumAddress)(hexAddress, eip1191ChainId) === hexAddress;
+};
+exports.isValidChecksumAddress = isValidChecksumAddress;
+/**
+ * Generates an address of a newly created contract.
+ * @param from The address which is creating this new address
+ * @param nonce The nonce of the from account
+ */
+const generateAddress = function (from, nonce) {
+    (0, helpers_js_1.assertIsBytes)(from);
+    (0, helpers_js_1.assertIsBytes)(nonce);
+    if ((0, bytes_js_1.bytesToBigInt)(nonce) === constants_js_1.BIGINT_0) {
+        // in RLP we want to encode null in the case of zero nonce
+        // read the RLP documentation for an answer if you dare
+        return (0, keccak_js_1.keccak256)(rlp_1.RLP.encode([from, Uint8Array.from([])])).subarray(-20);
+    }
+    // Only take the lower 160bits of the hash
+    return (0, keccak_js_1.keccak256)(rlp_1.RLP.encode([from, nonce])).subarray(-20);
+};
+exports.generateAddress = generateAddress;
+/**
+ * Generates an address for a contract created using CREATE2.
+ * @param from The address which is creating this new address
+ * @param salt A salt
+ * @param initCode The init code of the contract being created
+ */
+const generateAddress2 = function (from, salt, initCode) {
+    (0, helpers_js_1.assertIsBytes)(from);
+    (0, helpers_js_1.assertIsBytes)(salt);
+    (0, helpers_js_1.assertIsBytes)(initCode);
+    if (from.length !== 20) {
+        throw new Error('Expected from to be of length 20');
+    }
+    if (salt.length !== 32) {
+        throw new Error('Expected salt to be of length 32');
+    }
+    const address = (0, keccak_js_1.keccak256)((0, bytes_js_1.concatBytes)((0, bytes_js_1.hexToBytes)('0xff'), from, salt, (0, keccak_js_1.keccak256)(initCode)));
+    return address.subarray(-20);
+};
+exports.generateAddress2 = generateAddress2;
+/**
+ * Checks if the private key satisfies the rules of the curve secp256k1.
+ */
+const isValidPrivate = function (privateKey) {
+    return secp256k1_js_1.secp256k1.utils.isValidPrivateKey(privateKey);
+};
+exports.isValidPrivate = isValidPrivate;
+/**
+ * Checks if the public key satisfies the rules of the curve secp256k1
+ * and the requirements of Ethereum.
+ * @param publicKey The two points of an uncompressed key, unless sanitize is enabled
+ * @param sanitize Accept public keys in other formats
+ */
+const isValidPublic = function (publicKey, sanitize = false) {
+    (0, helpers_js_1.assertIsBytes)(publicKey);
+    if (publicKey.length === 64) {
+        // Convert to SEC1 for secp256k1
+        // Automatically checks whether point is on curve
+        try {
+            secp256k1_js_1.secp256k1.ProjectivePoint.fromHex((0, bytes_js_1.concatBytes)(Uint8Array.from([4]), publicKey));
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    if (!sanitize) {
+        return false;
+    }
+    try {
+        secp256k1_js_1.secp256k1.ProjectivePoint.fromHex(publicKey);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.isValidPublic = isValidPublic;
+/**
+ * Returns the ethereum address of a given public key.
+ * Accepts "Ethereum public keys" and SEC1 encoded keys.
+ * @param pubKey The two points of an uncompressed key, unless sanitize is enabled
+ * @param sanitize Accept public keys in other formats
+ */
+const pubToAddress = function (pubKey, sanitize = false) {
+    (0, helpers_js_1.assertIsBytes)(pubKey);
+    if (sanitize && pubKey.length !== 64) {
+        pubKey = secp256k1_js_1.secp256k1.ProjectivePoint.fromHex(pubKey).toRawBytes(false).slice(1);
+    }
+    if (pubKey.length !== 64) {
+        throw new Error('Expected pubKey to be of length 64');
+    }
+    // Only take the lower 160bits of the hash
+    return (0, keccak_js_1.keccak256)(pubKey).subarray(-20);
+};
+exports.pubToAddress = pubToAddress;
+exports.publicToAddress = exports.pubToAddress;
+/**
+ * Returns the ethereum public key of a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+const privateToPublic = function (privateKey) {
+    (0, helpers_js_1.assertIsBytes)(privateKey);
+    // skip the type flag and use the X, Y points
+    return secp256k1_js_1.secp256k1.ProjectivePoint.fromPrivateKey(privateKey).toRawBytes(false).slice(1);
+};
+exports.privateToPublic = privateToPublic;
+/**
+ * Returns the ethereum address of a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+const privateToAddress = function (privateKey) {
+    return (0, exports.publicToAddress)((0, exports.privateToPublic)(privateKey));
+};
+exports.privateToAddress = privateToAddress;
+/**
+ * Converts a public key to the Ethereum format.
+ */
+const importPublic = function (publicKey) {
+    (0, helpers_js_1.assertIsBytes)(publicKey);
+    if (publicKey.length !== 64) {
+        publicKey = secp256k1_js_1.secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(false).slice(1);
+    }
+    return publicKey;
+};
+exports.importPublic = importPublic;
+/**
+ * Returns the zero address.
+ */
+const zeroAddress = function () {
+    const addressLength = 20;
+    const addr = (0, bytes_js_1.zeros)(addressLength);
+    return (0, bytes_js_1.bytesToHex)(addr);
+};
+exports.zeroAddress = zeroAddress;
+/**
+ * Checks if a given address is the zero address.
+ */
+const isZeroAddress = function (hexAddress) {
+    try {
+        (0, helpers_js_1.assertIsString)(hexAddress);
+    }
+    catch (e) {
+        return false;
+    }
+    const zeroAddr = (0, exports.zeroAddress)();
+    return zeroAddr === hexAddress;
+};
+exports.isZeroAddress = isZeroAddress;
+function accountBodyFromSlim(body) {
+    const [nonce, balance, storageRoot, codeHash] = body;
+    return [
+        nonce,
+        balance,
+        storageRoot.length === 0 ? constants_js_1.KECCAK256_RLP : storageRoot,
+        codeHash.length === 0 ? constants_js_1.KECCAK256_NULL : codeHash,
+    ];
+}
+exports.accountBodyFromSlim = accountBodyFromSlim;
+const emptyUint8Arr = new Uint8Array(0);
+function accountBodyToSlim(body) {
+    const [nonce, balance, storageRoot, codeHash] = body;
+    return [
+        nonce,
+        balance,
+        (0, bytes_js_1.equalsBytes)(storageRoot, constants_js_1.KECCAK256_RLP) ? emptyUint8Arr : storageRoot,
+        (0, bytes_js_1.equalsBytes)(codeHash, constants_js_1.KECCAK256_NULL) ? emptyUint8Arr : codeHash,
+    ];
+}
+exports.accountBodyToSlim = accountBodyToSlim;
+/**
+ * Converts a slim account (per snap protocol spec) to the RLP encoded version of the account
+ * @param body Array of 4 Uint8Array-like items to represent the account
+ * @returns RLP encoded version of the account
+ */
+function accountBodyToRLP(body, couldBeSlim = true) {
+    const accountBody = couldBeSlim ? accountBodyFromSlim(body) : body;
+    return rlp_1.RLP.encode(accountBody);
+}
+exports.accountBodyToRLP = accountBodyToRLP;
+//# sourceMappingURL=account.js.map

hardhat/node_modules/@ethereumjs/util/dist/cjs/address.d.ts

@@ -0,0 +1,62 @@
+import type { PrefixedHexString } from './types.js';
+/**
+ * Handling and generating Ethereum addresses
+ */
+export declare class Address {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    /**
+     * Returns the zero address.
+     */
+    static zero(): Address;
+    /**
+     * Returns an Address object from a hex-encoded string.
+     * @param str - Hex-encoded address
+     */
+    static fromString(str: string): Address;
+    /**
+     * Returns an address for a given public key.
+     * @param pubKey The two points of an uncompressed key
+     */
+    static fromPublicKey(pubKey: Uint8Array): Address;
+    /**
+     * Returns an address for a given private key.
+     * @param privateKey A private key must be 256 bits wide
+     */
+    static fromPrivateKey(privateKey: Uint8Array): Address;
+    /**
+     * Generates an address for a newly created contract.
+     * @param from The address which is creating this new address
+     * @param nonce The nonce of the from account
+     */
+    static generate(from: Address, nonce: bigint): Address;
+    /**
+     * Generates an address for a contract created using CREATE2.
+     * @param from The address which is creating this new address
+     * @param salt A salt
+     * @param initCode The init code of the contract being created
+     */
+    static generate2(from: Address, salt: Uint8Array, initCode: Uint8Array): Address;
+    /**
+     * Is address equal to another.
+     */
+    equals(address: Address): boolean;
+    /**
+     * Is address zero.
+     */
+    isZero(): boolean;
+    /**
+     * True if address is in the address range defined
+     * by EIP-1352
+     */
+    isPrecompileOrSystemAddress(): boolean;
+    /**
+     * Returns hex encoding of address.
+     */
+    toString(): PrefixedHexString;
+    /**
+     * Returns a new Uint8Array representation of address.
+     */
+    toBytes(): Uint8Array;
+}
+//# sourceMappingURL=address.d.ts.map

hardhat/node_modules/@ethereumjs/util/dist/cjs/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/address.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;GAEG;AACH,qBAAa,OAAO;IAClB,SAAgB,KAAK,EAAE,UAAU,CAAA;gBAErB,KAAK,EAAE,UAAU;IAO7B;;OAEG;IACH,MAAM,CAAC,IAAI,IAAI,OAAO;IAItB;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOvC;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO;IAQjD;;;OAGG;IACH,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAQtD;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAOtD;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO;IAUhF;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAIjC;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;;OAGG;IACH,2BAA2B,IAAI,OAAO;IAOtC;;OAEG;IACH,QAAQ,IAAI,iBAAiB;IAI7B;;OAEG;IACH,OAAO,IAAI,UAAU;CAGtB"}

hardhat/node_modules/@ethereumjs/util/dist/cjs/address.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Address = void 0;
+const account_js_1 = require("./account.js");
+const bytes_js_1 = require("./bytes.js");
+const constants_js_1 = require("./constants.js");
+/**
+ * Handling and generating Ethereum addresses
+ */
+class Address {
+    constructor(bytes) {
+        if (bytes.length !== 20) {
+            throw new Error('Invalid address length');
+        }
+        this.bytes = bytes;
+    }
+    /**
+     * Returns the zero address.
+     */
+    static zero() {
+        return new Address((0, bytes_js_1.zeros)(20));
+    }
+    /**
+     * Returns an Address object from a hex-encoded string.
+     * @param str - Hex-encoded address
+     */
+    static fromString(str) {
+        if (!(0, account_js_1.isValidAddress)(str)) {
+            throw new Error(`Invalid address input=${str}`);
+        }
+        return new Address((0, bytes_js_1.hexToBytes)(str));
+    }
+    /**
+     * Returns an address for a given public key.
+     * @param pubKey The two points of an uncompressed key
+     */
+    static fromPublicKey(pubKey) {
+        if (!(pubKey instanceof Uint8Array)) {
+            throw new Error('Public key should be Uint8Array');
+        }
+        const bytes = (0, account_js_1.pubToAddress)(pubKey);
+        return new Address(bytes);
+    }
+    /**
+     * Returns an address for a given private key.
+     * @param privateKey A private key must be 256 bits wide
+     */
+    static fromPrivateKey(privateKey) {
+        if (!(privateKey instanceof Uint8Array)) {
+            throw new Error('Private key should be Uint8Array');
+        }
+        const bytes = (0, account_js_1.privateToAddress)(privateKey);
+        return new Address(bytes);
+    }
+    /**
+     * Generates an address for a newly created contract.
+     * @param from The address which is creating this new address
+     * @param nonce The nonce of the from account
+     */
+    static generate(from, nonce) {
+        if (typeof nonce !== 'bigint') {
+            throw new Error('Expected nonce to be a bigint');
+        }
+        return new Address((0, account_js_1.generateAddress)(from.bytes, (0, bytes_js_1.bigIntToBytes)(nonce)));
+    }
+    /**
+     * Generates an address for a contract created using CREATE2.
+     * @param from The address which is creating this new address
+     * @param salt A salt
+     * @param initCode The init code of the contract being created
+     */
+    static generate2(from, salt, initCode) {
+        if (!(salt instanceof Uint8Array)) {
+            throw new Error('Expected salt to be a Uint8Array');
+        }
+        if (!(initCode instanceof Uint8Array)) {
+            throw new Error('Expected initCode to be a Uint8Array');
+        }
+        return new Address((0, account_js_1.generateAddress2)(from.bytes, salt, initCode));
+    }
+    /**
+     * Is address equal to another.
+     */
+    equals(address) {
+        return (0, bytes_js_1.equalsBytes)(this.bytes, address.bytes);
+    }
+    /**
+     * Is address zero.
+     */
+    isZero() {
+        return this.equals(Address.zero());
+    }
+    /**
+     * True if address is in the address range defined
+     * by EIP-1352
+     */
+    isPrecompileOrSystemAddress() {
+        const address = (0, bytes_js_1.bytesToBigInt)(this.bytes);
+        const rangeMin = constants_js_1.BIGINT_0;
+        const rangeMax = BigInt('0xffff');
+        return address >= rangeMin && address <= rangeMax;
+    }
+    /**
+     * Returns hex encoding of address.
+     */
+    toString() {
+        return (0, bytes_js_1.bytesToHex)(this.bytes);
+    }
+    /**
+     * Returns a new Uint8Array representation of address.
+     */
+    toBytes() {
+        return new Uint8Array(this.bytes);
+    }
+}
+exports.Address = Address;
+//# sourceMappingURL=address.js.map

hardhat/node_modules/@ethereumjs/util/dist/cjs/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../src/address.ts"],"names":[],"mappings":";;;AAAA,6CAMqB;AACrB,yCAOmB;AACnB,iDAAyC;AAIzC;;GAEG;AACH,MAAa,OAAO;IAGlB,YAAY,KAAiB;QAC3B,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;SAC1C;QACD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAI;QACT,OAAO,IAAI,OAAO,CAAC,IAAA,gBAAK,EAAC,EAAE,CAAC,CAAC,CAAA;IAC/B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAW;QAC3B,IAAI,CAAC,IAAA,2BAAc,EAAC,GAAG,CAAC,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,EAAE,CAAC,CAAA;SAChD;QACD,OAAO,IAAI,OAAO,CAAC,IAAA,qBAAU,EAAC,GAAG,CAAC,CAAC,CAAA;IACrC,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAC,MAAkB;QACrC,IAAI,CAAC,CAAC,MAAM,YAAY,UAAU,CAAC,EAAE;YACnC,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;SACnD;QACD,MAAM,KAAK,GAAG,IAAA,yBAAY,EAAC,MAAM,CAAC,CAAA;QAClC,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,cAAc,CAAC,UAAsB;QAC1C,IAAI,CAAC,CAAC,UAAU,YAAY,UAAU,CAAC,EAAE;YACvC,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;SACpD;QACD,MAAM,KAAK,GAAG,IAAA,6BAAgB,EAAC,UAAU,CAAC,CAAA;QAC1C,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAa,EAAE,KAAa;QAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAA;SACjD;QACD,OAAO,IAAI,OAAO,CAAC,IAAA,4BAAe,EAAC,IAAI,CAAC,KAAK,EAAE,IAAA,wBAAa,EAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,IAAa,EAAE,IAAgB,EAAE,QAAoB;QACpE,IAAI,CAAC,CAAC,IAAI,YAAY,UAAU,CAAC,EAAE;YACjC,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;SACpD;QACD,IAAI,CAAC,CAAC,QAAQ,YAAY,UAAU,CAAC,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAA;SACxD;QACD,OAAO,IAAI,OAAO,CAAC,IAAA,6BAAgB,EAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAA;IAClE,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAgB;QACrB,OAAO,IAAA,sBAAW,EAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;IAC/C,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAA;IACpC,CAAC;IAED;;;OAGG;IACH,2BAA2B;QACzB,MAAM,OAAO,GAAG,IAAA,wBAAa,EAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACzC,MAAM,QAAQ,GAAG,uBAAQ,CAAA;QACzB,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;QACjC,OAAO,OAAO,IAAI,QAAQ,IAAI,OAAO,IAAI,QAAQ,CAAA;IACnD,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAA,qBAAU,EAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC/B,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AAtHD,0BAsHC"}

hardhat/node_modules/@ethereumjs/util/dist/cjs/asyncEventEmitter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Ported to Typescript from original implementation below:
+ * https://github.com/ahultgren/async-eventemitter -- MIT licensed
+ *
+ * Type Definitions based on work by: patarapolw <https://github.com/patarapolw> -- MIT licensed
+ * that was contributed to Definitely Typed below:
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async-eventemitter
+ */
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+declare type AsyncListener<T, R> = ((data: T, callback?: (result?: R) => void) => Promise<R>) | ((data: T, callback?: (result?: R) => void) => void);
+export interface EventMap {
+    [event: string]: AsyncListener<any, any>;
+}
+export declare class AsyncEventEmitter<T extends EventMap> extends EventEmitter {
+    emit<E extends keyof T>(event: E & string, ...args: Parameters<T[E]>): boolean;
+    once<E extends keyof T>(event: E & string, listener: T[E]): this;
+    first<E extends keyof T>(event: E & string, listener: T[E]): this;
+    before<E extends keyof T>(event: E & string, target: T[E], listener: T[E]): this;
+    after<E extends keyof T>(event: E & string, target: T[E], listener: T[E]): this;
+    private beforeOrAfter;
+    on<E extends keyof T>(event: E & string, listener: T[E]): this;
+    addListener<E extends keyof T>(event: E & string, listener: T[E]): this;
+    prependListener<E extends keyof T>(event: E & string, listener: T[E]): this;
+    prependOnceListener<E extends keyof T>(event: E & string, listener: T[E]): this;
+    removeAllListeners(event?: keyof T & string): this;
+    removeListener<E extends keyof T>(event: E & string, listener: T[E]): this;
+    eventNames(): Array<keyof T & string>;
+    listeners<E extends keyof T>(event: E & string): Array<T[E]>;
+    listenerCount(event: keyof T & string): number;
+    getMaxListeners(): number;
+    setMaxListeners(maxListeners: number): this;
+}
+export {};
+//# sourceMappingURL=asyncEventEmitter.d.ts.map

hardhat/node_modules/@ethereumjs/util/dist/cjs/asyncEventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncEventEmitter.d.ts","sourceRoot":"","sources":["../../src/asyncEventEmitter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AACrC,aAAK,aAAa,CAAC,CAAC,EAAE,CAAC,IACnB,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAC1D,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC,CAAA;AACxD,MAAM,WAAW,QAAQ;IACvB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CACzC;AAiCD,qBAAa,iBAAiB,CAAC,CAAC,SAAS,QAAQ,CAAE,SAAQ,YAAY;IACrE,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IA6BpE,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IA0BhE,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAkBjE,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAIhF,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI/E,OAAO,CAAC,aAAa;IAsCrB,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI9D,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAIvE,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI3E,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI/E,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI;IAIlD,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI1E,UAAU,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IAIrC,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAI5D,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM;IAI9C,eAAe,IAAI,MAAM;IAIzB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;CAG5C"}

hardhat/node_modules/@ethereumjs/util/dist/cjs/asyncEventEmitter.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Ported to Typescript from original implementation below:
+ * https://github.com/ahultgren/async-eventemitter -- MIT licensed
+ *
+ * Type Definitions based on work by: patarapolw <https://github.com/patarapolw> -- MIT licensed
+ * that was contributed to Definitely Typed below:
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async-eventemitter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncEventEmitter = void 0;
+const events_1 = require("events");
+async function runInSeries(context, tasks, data) {
+    let error;
+    for await (const task of tasks) {
+        try {
+            if (task.length < 2) {
+                //sync
+                task.call(context, data);
+            }
+            else {
+                await new Promise((resolve, reject) => {
+                    task.call(context, data, (error) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        }
+        catch (e) {
+            error = e;
+        }
+    }
+    if (error) {
+        throw error;
+    }
+}
+class AsyncEventEmitter extends events_1.EventEmitter {
+    emit(event, ...args) {
+        let [data, callback] = args;
+        const self = this;
+        let listeners = self._events[event] ?? [];
+        // Optional data argument
+        if (callback === undefined && typeof data === 'function') {
+            callback = data;
+            data = undefined;
+        }
+        // Special treatment of internal newListener and removeListener events
+        if (event === 'newListener' || event === 'removeListener') {
+            data = {
+                event: data,
+                fn: callback,
+            };
+            callback = undefined;
+        }
+        // A single listener is just a function not an array...
+        listeners = Array.isArray(listeners) ? listeners : [listeners];
+        runInSeries(self, listeners.slice(), data).then(callback).catch(callback);
+        return self.listenerCount(event) > 0;
+    }
+    once(event, listener) {
+        const self = this;
+        let g;
+        if (typeof listener !== 'function') {
+            throw new TypeError('listener must be a function');
+        }
+        // Hack to support set arity
+        if (listener.length >= 2) {
+            g = function (e, next) {
+                self.removeListener(event, g);
+                void listener(e, next);
+            };
+        }
+        else {
+            g = function (e) {
+                self.removeListener(event, g);
+                void listener(e, g);
+            };
+        }
+        self.on(event, g);
+        return self;
+    }
+    first(event, listener) {
+        let listeners = this._events[event] ?? [];
+        // Contract
+        if (typeof listener !== 'function') {
+            throw new TypeError('listener must be a function');
+        }
+        // Listeners are not always an array
+        if (!Array.isArray(listeners)) {
+            ;
+            this._events[event] = listeners = [listeners];
+        }
+        listeners.unshift(listener);
+        return this;
+    }
+    before(event, target, listener) {
+        return this.beforeOrAfter(event, target, listener);
+    }
+    after(event, target, listener) {
+        return this.beforeOrAfter(event, target, listener, 'after');
+    }
+    beforeOrAfter(event, target, listener, beforeOrAfter) {
+        let listeners = this._events[event] ?? [];
+        let i;
+        let index;
+        const add = beforeOrAfter === 'after' ? 1 : 0;
+        // Contract
+        if (typeof listener !== 'function') {
+            throw new TypeError('listener must be a function');
+        }
+        if (typeof target !== 'function') {
+            throw new TypeError('target must be a function');
+        }
+        // Listeners are not always an array
+        if (!Array.isArray(listeners)) {
+            ;
+            this._events[event] = listeners = [listeners];
+        }
+        index = listeners.length;
+        for (i = listeners.length; i--;) {
+            if (listeners[i] === target) {
+                index = i + add;
+                break;
+            }
+        }
+        listeners.splice(index, 0, listener);
+        return this;
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    addListener(event, listener) {
+        return super.addListener(event, listener);
+    }
+    prependListener(event, listener) {
+        return super.prependListener(event, listener);
+    }
+    prependOnceListener(event, listener) {
+        return super.prependOnceListener(event, listener);
+    }
+    removeAllListeners(event) {
+        return super.removeAllListeners(event);
+    }
+    removeListener(event, listener) {
+        return super.removeListener(event, listener);
+    }
+    eventNames() {
+        return super.eventNames();
+    }
+    listeners(event) {
+        return super.listeners(event);
+    }
+    listenerCount(event) {
+        return super.listenerCount(event);
+    }
+    getMaxListeners() {
+        return super.getMaxListeners();
+    }
+    setMaxListeners(maxListeners) {
+        return super.setMaxListeners(maxListeners);
+    }
+}
+exports.AsyncEventEmitter = AsyncEventEmitter;
+//# sourceMappingURL=asyncEventEmitter.js.map