diff --git a/docs/assets/ganache-logo-dark.svg b/docs/assets/img/ganache-logo-dark.svg similarity index 100% rename from docs/assets/ganache-logo-dark.svg rename to docs/assets/img/ganache-logo-dark.svg diff --git a/docs/assets/truffle-logo-dark.svg b/docs/assets/img/truffle-logo-dark.svg similarity index 100% rename from docs/assets/truffle-logo-dark.svg rename to docs/assets/img/truffle-logo-dark.svg diff --git a/docs/assets/js/ganache/ganache.min.js b/docs/assets/js/ganache/ganache.min.js new file mode 100644 index 0000000000..35f9b87d6b --- /dev/null +++ b/docs/assets/js/ganache/ganache.min.js @@ -0,0 +1,173178 @@ +/*! For license information please see ganache.min.js.LICENSE.txt */ +!(function webpackUniversalModuleDefinition(e, t) { + "object" == typeof exports && "object" == typeof module + ? (module.exports = t()) + : "function" == typeof define && define.amd + ? define([], t) + : "object" == typeof exports + ? (exports.Ganache = t()) + : (e.Ganache = t()); +})(self, function () { + return (() => { + var __webpack_modules__ = { + 63894: function (e, t, r) { + "use strict"; + var a = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + n = + (this && this.__exportStar) || + function (e, t) { + for (var r in e) + "default" === r || + Object.prototype.hasOwnProperty.call(t, r) || + a(t, e, r); + }; + Object.defineProperty(t, "__esModule", { value: !0 }), n(r(70276), t); + }, + 44955: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s, + u, + b = r(98188).Buffer, + l = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + h = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + p = + (this && this.__decorate) || + function (e, t, r, a) { + var n, + o = arguments.length, + c = + o < 3 + ? t + : null === a + ? (a = Object.getOwnPropertyDescriptor(t, r)) + : a; + if ( + "object" == typeof Reflect && + "function" == typeof Reflect.decorate + ) + c = Reflect.decorate(e, t, r, a); + else + for (var d = e.length - 1; d >= 0; d--) + (n = e[d]) && + (c = (o < 3 ? n(c) : o > 3 ? n(t, r, c) : n(t, r)) || c); + return o > 3 && c && Object.defineProperty(t, r, c), c; + }, + x = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + l(t, e, r); + return h(t, e), t; + }, + m = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + y = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + g = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const v = r(57898), + w = r(85761), + _ = r(42731), + k = r(52426), + B = g(r(40325)), + N = g(r(1169)), + P = r(95768), + O = g(r(68246)), + I = g(r(9436)), + L = g(r(64845)), + C = r(65205), + D = r(52426), + j = g(r(61054)), + U = g(r(16943)), + z = x(r(4388)), + W = r(77690), + H = r(25925), + q = r(475), + { version: V } = { version: "3.0.0-internal.11" }, + { keccak: G } = D.utils, + { RPCQUANTITY_ZERO: Y } = D.utils, + J = `Ganache/v${V}/EthereumJS TestRPC/v${V}/ethereum-js`, + X = k.Data.from("0x3f"), + Q = { + eth: "1.0", + net: "1.0", + rpc: "1.0", + web3: "1.0", + evm: "1.0", + personal: "1.0" + }, + $ = new Set([1, 3, 4, 5, 42]); + function assertExceptionalTransactions(e) { + let t, + r = null; + const a = {}; + if ( + (e.forEach(e => { + e.execException && + (r + ? ((r = P.VM_EXCEPTIONS), + t.push( + `${k.Data.from(e.hash(), 32).toString()}: ${ + e.execException + }\n` + ), + (a[e.execException.data.hash] = e.execException.data)) + : ((r = P.VM_EXCEPTION), + (t = [e.execException.message]), + (a[e.execException.data.hash] = e.execException.data))); + }), + r) + ) { + const e = new Error(r + t.join("\n")); + throw ((e.data = a), e); + } + } + class EthereumApi { + constructor(e, t, r) { + var b; + a.set(this, ((b = 0), () => k.Quantity.from(++b))), + n.set(this, void 0), + o.set(this, new Map()), + c.set(this, new Map()), + d.set(this, void 0), + s.set(this, void 0), + u.set(this, void 0), + m(this, s, e); + const { chain: l } = e, + { initialAccounts: h } = m(this, u, t), + p = (function parseCoinbaseAddress(e, t) { + switch (typeof e) { + case "object": + return e; + case "number": + const r = t[e]; + if (r) return r.address; + throw new Error("invalid coinbase address index: " + e); + case "string": + return O.default.from(e); + default: + throw new Error( + "coinbase address must be string or number, received: " + + e + ); + } + })(e.miner.coinbase, h), + x = m( + this, + n, + (function createCommon(e, t, r) { + return j.default.forCustomChain( + $.has(e) ? e : 1, + { + name: "ganache", + networkId: t, + chainId: e, + comment: "Local test network" + }, + r + ); + })(l.chainId, l.networkId, l.hardfork) + ), + y = m(this, d, new B.default(e, x, h, p)); + y.on("start", () => r.emit("connect")), + r.on("disconnect", y.stop.bind(y)); + } + async db_putString(e, t, r) { + return !1; + } + async db_getString(e, t) { + return ""; + } + async db_putHex(e, t, r) { + return !1; + } + async db_getHex(e, t) { + return "0x00"; + } + async bzz_hive() { + return []; + } + async bzz_info() { + return []; + } + async evm_mine(e) { + const t = await y(this, d).mine(-1, e, !0); + return ( + y(this, s).chain.vmErrorsOnRPCResponse && + assertExceptionalTransactions(t), + "0x0" + ); + } + async evm_setStorageAt(e, t, r, a = N.default.LATEST) { + const n = y(this, d).blocks.getRaw(a), + o = y(this, d).trie.copy(), + c = await n; + if (!c) throw new Error("header not found"); + const s = C.decode(c)[0][3]; + o.root = s; + const u = (e => + new Promise((t, r) => { + o.get(e, (e, a) => { + e ? r(e) : t(a); + }); + }))(O.default.from(e).toBuffer()), + l = k.Quantity.from(t).toBuffer(), + h = l.length; + let p; + h < 32 + ? ((p = b.allocUnsafe(32).fill(0)), l.copy(p, 32 - h)) + : (p = 32 === h ? l : l.slice(-32)); + const x = await u; + return ( + (y(this, d).trie.root = C.decode(x)[2]), + new Promise((e, t) => { + y(this, d).trie.put(p, r, r => { + if (r) return t(r); + e(void 0); + }); + }) + ); + } + async evm_setAccountNonce(e, t) { + return new Promise((r, a) => { + const n = O.default.from(e).toBuffer(), + o = y(this, d), + c = o.vm.stateManager; + c.getAccount(n, (e, d) => { + e + ? a(e) + : ((d.nonce = k.Quantity.from(t).toBuffer()), + c.putAccount(n, d, e => { + e ? a(e) : o.mine(0).then(() => r(!0), a); + })); + }); + }); + } + async evm_increaseTime(e) { + const t = + 1e3 * + ("number" == typeof e ? e : k.Quantity.from(e).toNumber()); + return Math.floor(y(this, d).increaseTime(t) / 1e3); + } + async evm_setTime(e) { + let t; + switch (typeof e) { + case "object": + t = e.getTime(); + break; + case "number": + t = e; + break; + default: + t = k.Quantity.from(e).toNumber(); + } + return Math.floor(y(this, d).setTime(t) / 1e3); + } + async evm_revert(e) { + return y(this, d).revert(k.Quantity.from(e)); + } + async evm_snapshot() { + return k.Quantity.from(y(this, d).snapshot()); + } + async evm_unlockUnknownAccount(e, t = 0) { + return y(this, u).unlockUnknownAccount(e.toLowerCase(), t); + } + async evm_lockUnknownAccount(e) { + const t = e.toLowerCase(); + if (y(this, u).knownAccounts.has(t)) + throw new Error("cannot lock known/personal account"); + return y(this, u).lockAccount(t); + } + async miner_start(e = 1) { + if (!0 === y(this, s).miner.legacyInstamine) { + const t = await y(this, d).resume(e); + null != t && + y(this, s).chain.vmErrorsOnRPCResponse && + assertExceptionalTransactions(t); + } else y(this, d).resume(e); + return !0; + } + async miner_stop() { + return y(this, d).pause(), !0; + } + async miner_setGasPrice(e) { + return (y(this, s).miner.gasPrice = k.Quantity.from(e)), !0; + } + async miner_setEtherbase(e) { + return (y(this, d).coinbase = O.default.from(e)), !0; + } + async miner_setExtra(e) { + const t = k.Data.from(e), + r = t.toBuffer().length; + if (r > 32) + throw new Error(`extra exceeds max length. ${r} > 32`); + return (y(this, s).miner.extraData = t), !0; + } + async web3_clientVersion() { + return J; + } + async web3_sha3(e) { + return k.Data.from(G(b.from(e))); + } + async net_version() { + return y(this, s).chain.networkId.toString(); + } + async net_listening() { + return !0; + } + async net_peerCount() { + return Y; + } + async eth_estimateGas(e, t = N.default.LATEST) { + const r = y(this, d), + a = r.blocks, + o = (await a.get(t)).header, + c = y(this, s), + generateVM = () => r.vm.copy(); + return new Promise((t, a) => { + const { coinbase: d } = r, + s = I.default.fromJSON(e, y(this, n), I.default.types.fake); + null == s._from && (s._from = d.toBuffer()), + 0 !== s.gasLimit.length + ? (s.gas = s.gasLimit) + : 0 !== s.gas.length + ? (s.gasLimit = s.gas) + : (s.gas = s.gasLimit = c.miner.callGasLimit.toBuffer()); + const u = { + tx: s, + block: new v.RuntimeBlock( + k.Quantity.from(o.number.toBigInt() + 1n), + o.parentHash, + o.miner, + s.gas, + o.timestamp + ), + skipBalance: !0, + skipNonce: !0 + }; + U.default(generateVM, u, (e, r) => { + if (e) return a(e); + t(k.Quantity.from(r.gasEstimate.toBuffer())); + }); + }); + } + async eth_protocolVersion() { + return X; + } + async eth_syncing() { + return !1; + } + async eth_coinbase() { + return y(this, d).coinbase; + } + async eth_getBlockByNumber(e, t = !1) { + const r = await y(this, d) + .blocks.get(e) + .catch(e => null); + return r ? r.toJSON(t) : null; + } + async eth_getBlockByHash(e, t = !1) { + const r = await y(this, d) + .blocks.getByHash(e) + .catch(e => null); + return r ? r.toJSON(t) : null; + } + async eth_getBlockTransactionCountByNumber(e) { + const t = await y(this, d).blocks.getRaw(e); + if (t) { + const e = C.decode(t); + return k.Quantity.from(e[1].length); + } + return null; + } + async eth_getBlockTransactionCountByHash(e) { + const t = await y(this, d).blocks.getNumberFromHash(e); + return t ? this.eth_getBlockTransactionCountByNumber(t) : null; + } + async eth_getCompilers() { + return []; + } + async eth_getTransactionByBlockHashAndIndex(e, t) { + const r = await this.eth_getBlockByHash(e, !0); + if (r) { + const e = r.transactions[parseInt(t, 10)]; + if (e) return e; + } + return null; + } + async eth_getTransactionByBlockNumberAndIndex(e, t) { + return (await this.eth_getBlockByNumber(e, !0)).transactions[ + parseInt(t, 10) + ]; + } + async eth_getUncleCountByBlockHash(e) { + return Y; + } + async eth_getUncleCountByBlockNumber(e) { + return Y; + } + async eth_getUncleByBlockHashAndIndex(e, t) { + return null; + } + async eth_getUncleByBlockNumberAndIndex(e, t) { + return null; + } + async eth_getWork(e) { + return []; + } + async eth_submitWork(e, t, r) { + return !1; + } + async eth_submitHashrate(e, t) { + return !1; + } + async eth_mining() { + return y(this, d).isStarted(); + } + async eth_hashrate() { + return Y; + } + async eth_gasPrice() { + return y(this, s).miner.gasPrice; + } + async eth_accounts() { + return y(this, u).addresses; + } + async eth_blockNumber() { + return y(this, d).blocks.latest.header.number; + } + async eth_chainId() { + return k.Quantity.from(y(this, s).chain.chainId); + } + async eth_getBalance(e, t = N.default.LATEST) { + return y(this, d).accounts.getBalance(O.default.from(e), t); + } + async eth_getCode(e, t = N.default.LATEST) { + const r = y(this, d), + a = r.blocks.getRaw(t), + n = r.trie.copy(), + o = await a; + if (!o) throw new Error("header not found"); + const c = C.decode(o)[0][3]; + n.root = c; + const s = (e => + new Promise((t, r) => { + n.get(e, (e, a) => { + e ? r(e) : t(a); + }); + }))(O.default.from(e).toBuffer()), + u = await s, + b = C.decode(u)[3]; + return !b || w.KECCAK256_NULL.equals(b) + ? k.Data.from("0x") + : new Promise((e, t) => { + n.getRaw(b, (r, a) => { + r ? t(r) : e(k.Data.from(a)); + }); + }); + } + async eth_getStorageAt(e, t, r = N.default.LATEST) { + const a = y(this, d).blocks.getRaw(r), + n = y(this, d).trie.copy(), + getFromTrie = e => + new Promise((t, r) => { + n.get(e, (e, a) => { + e ? r(e) : t(a); + }); + }), + o = await a; + if (!o) throw new Error("header not found"); + const c = C.decode(o)[0][3]; + n.root = c; + const s = getFromTrie(O.default.from(e).toBuffer()), + u = k.Quantity.from(t).toBuffer(), + l = u.length; + let h; + l < 32 + ? ((h = b.allocUnsafe(32).fill(0)), u.copy(h, 32 - l)) + : (h = 32 === l ? u : u.slice(-32)); + const p = await s; + n.root = C.decode(p)[2]; + const x = await getFromTrie(h); + return k.Data.from(C.decode(x)); + } + async eth_getTransactionByHash(e) { + const { transactions: t } = y(this, d), + r = k.Data.from(e).toBuffer(), + a = await t.get(r); + if (null === a) { + const e = t.transactionPool.find(r); + return e ? e.toJSON(null) : null; + } + return a.toJSON(); + } + async eth_getTransactionReceipt(e) { + const { transactions: t, transactionReceipts: r, blocks: a } = y( + this, + d + ), + n = k.Data.from(e).toBuffer(), + o = t.get(n), + c = r.get(n), + s = o.then(e => (e ? a.get(e._blockNum) : null)), + [u, b, l] = await Promise.all([o, c, s]); + return u ? b.toJSON(l, u) : null; + } + async eth_sendTransaction(e) { + let t, + r = e.from; + if ( + (r && + ((t = O.default.from(e.from)), + (r = t.toString().toLowerCase())), + null == r) + ) + throw new Error("from not found; is required"); + if (e.to && "string" != typeof e.to) + throw new Error("invalid to address"); + const a = y(this, u), + o = a.knownAccounts.has(r), + c = a.unlockedAccounts.has(r); + if (!c) { + throw new Error( + o + ? "authentication needed: password or unlock" + : "sender account not recognized" + ); + } + const l = o ? I.default.types.none : I.default.types.fake, + h = I.default.fromJSON(e, y(this, n), l); + if (0 === h.gasLimit.length) { + const t = y(this, s).miner.defaultTransactionGasLimit; + t === D.utils.RPCQUANTITY_EMPTY + ? (h.gasLimit = ( + await this.eth_estimateGas(e, "latest") + ).toBuffer()) + : (h.gasLimit = t.toBuffer()); + } + if ( + (0 === h.gasPrice.length && + (h.gasPrice = y(this, s).miner.gasPrice.toBuffer()), + 0 === h.value.length && (h.value = b.from([0])), + h.to.equals(D.utils.BUFFER_ZERO) && + (h.to = D.utils.BUFFER_EMPTY), + c) + ) { + const e = a.unlockedAccounts.get(r); + return y(this, d).queueTransaction(h, e); + } + return y(this, d).queueTransaction(h); + } + async eth_sendRawTransaction(e) { + const t = new I.default(e, y(this, n), I.default.types.signed); + return y(this, d).queueTransaction(t); + } + async eth_sign(e, t) { + const r = O.default.from(e).toString().toLowerCase(), + a = y(this, u).unlockedAccounts.get(r); + if (null == a) + throw new Error("cannot sign data; no private key"); + const n = y(this, s).chain.chainId, + o = w.hashPersonalMessage(k.Data.from(t).toBuffer()), + { v: c, r: d, s: b } = w.ecsign(o, a.toBuffer(), n); + return w.toRpcSig(c, d, b, n); + } + async eth_signTypedData(e, t) { + const r = O.default.from(e).toString().toLowerCase(), + a = y(this, u).unlockedAccounts.get(r); + if (null == a) + throw new Error("cannot sign data; no private key"); + if (!t.types) throw new Error("cannot sign data; types missing"); + if (!t.types.EIP712Domain) + throw new Error( + "cannot sign data; EIP712Domain definition missing" + ); + if (!t.domain) + throw new Error("cannot sign data; domain missing"); + if (!t.primaryType) + throw new Error("cannot sign data; primaryType missing"); + if (!t.message) + throw new Error("cannot sign data; message missing"); + return _.signTypedData_v4(a.toBuffer(), { data: t }); + } + eth_subscribe(e, t) { + const r = y(this, c); + switch (e) { + case "newHeads": { + const e = y(this, a).call(this), + t = D.PromiEvent.resolve(e), + n = y(this, d).on("block", r => { + const a = r.header, + n = { + logsBloom: a.logsBloom, + miner: a.miner, + difficulty: a.difficulty, + extraData: a.extraData, + gasLimit: a.gasLimit, + gasUsed: a.gasUsed, + hash: r.hash(), + mixHash: r.header.mixHash, + nonce: a.nonce, + number: a.number, + parentHash: a.parentHash, + receiptsRoot: a.receiptsRoot, + stateRoot: a.stateRoot, + timestamp: a.timestamp, + transactionsRoot: a.transactionsRoot, + sha3Uncles: a.sha3Uncles + }; + t.emit("message", { + type: "eth_subscription", + data: { + result: JSON.parse(JSON.stringify(n)), + subscription: e.toString() + } + }); + }); + return r.set(e.toString(), n), t; + } + case "logs": { + const e = y(this, a).call(this), + n = D.PromiEvent.resolve(e), + { addresses: o, topics: c } = t + ? q.parseFilterDetails(t) + : { addresses: [], topics: [] }, + s = y(this, d).on("blockLogs", t => { + const r = JSON.parse(JSON.stringify([...t.filter(o, c)])); + n.emit("message", { + type: "eth_subscription", + data: { result: r, subscription: e.toString() } + }); + }); + return r.set(e.toString(), s), n; + } + case "newPendingTransactions": { + const e = y(this, a).call(this), + t = D.PromiEvent.resolve(e), + n = y(this, d).on("pendingTransaction", r => { + const a = k.Data.from(r.hash(), 32).toString(); + t.emit("message", { + type: "eth_subscription", + data: { result: a, subscription: e.toString() } + }); + }); + return r.set(e.toString(), n), t; + } + case "syncing": { + const e = y(this, a).call(this), + t = D.PromiEvent.resolve(e); + return y(this, c).set(e.toString(), () => {}), t; + } + default: + throw new z.default( + `no "${e}" subscription in eth namespace`, + z.ErrorCodes.METHOD_NOT_FOUND + ); + } + } + async eth_unsubscribe(e) { + const t = y(this, c), + r = t.get(e); + return !!r && (t.delete(e), r(), !0); + } + async eth_newBlockFilter() { + const e = { + updates: [], + unsubscribe: y(this, d).on("block", t => { + e.updates.push(t.hash()); + }), + filter: null, + type: W.FilterTypes.block + }, + t = y(this, a).call(this); + return y(this, o).set(t.toString(), e), t; + } + async eth_newPendingTransactionFilter() { + const e = { + updates: [], + unsubscribe: y(this, d).on("pendingTransaction", t => { + e.updates.push(k.Data.from(t.hash(), 32)); + }), + filter: null, + type: W.FilterTypes.pendingTransaction + }, + t = y(this, a).call(this); + return y(this, o).set(t.toString(), e), t; + } + async eth_newFilter(e = {}) { + const t = y(this, d), + { addresses: r, topics: n } = q.parseFilterDetails(e), + c = { + updates: [], + unsubscribe: t.on("blockLogs", a => { + const o = a.blockNumber, + { fromBlock: d, toBlock: s } = q.parseFilterRange(e, t); + d <= o && s >= o && c.updates.push(...a.filter(r, n)); + }), + filter: e, + type: W.FilterTypes.log + }, + s = y(this, a).call(this); + return y(this, o).set(s.toString(), c), s; + } + async eth_getFilterChanges(e) { + const t = y(this, o).get(e); + if (t) { + const e = t.updates; + return (t.updates = []), e; + } + throw new Error("filter not found"); + } + async eth_uninstallFilter(e) { + const t = y(this, o).get(e); + return !!t && (t.unsubscribe(), y(this, o).delete(e)); + } + async eth_getFilterLogs(e) { + const t = y(this, o).get(e); + if (t && t.type === W.FilterTypes.log) + return this.eth_getLogs(t.filter); + throw new Error("filter not found"); + } + async eth_getLogs(e) { + const t = y(this, d); + if ("blockHash" in e) { + const { addresses: r, topics: a } = q.parseFilterDetails(e), + n = await t.blocks.getNumberFromHash(e.blockHash); + if (!n) return []; + const o = t.blockLogs, + c = await o.get(n); + return c ? [...c.filter(r, a)] : []; + } + { + const { + addresses: r, + topics: a, + fromBlock: n, + toBlockNumber: o + } = q.parseFilter(e, t), + c = t.blockLogs, + d = [c.get(n.toBuffer())], + s = n.toNumber(); + if (s !== o) + for (let e = s + 1, t = o + 1; e < t; e++) + d.push(c.get(k.Quantity.from(e).toBuffer())); + return Promise.all(d).then(e => { + const t = []; + return ( + e.forEach(e => { + e && t.push(...e.filter(r, a)); + }), + t + ); + }); + } + } + async eth_getTransactionCount(e, t = N.default.LATEST) { + return y(this, d).accounts.getNonce(O.default.from(e), t); + } + async eth_call(e, t = N.default.LATEST) { + const r = y(this, d), + a = r.blocks, + n = await a.get(t), + o = n.header, + c = y(this, s); + let u, b; + (u = + void 0 === e.gasLimit + ? void 0 !== e.gas + ? k.Quantity.from(e.gas) + : c.miner.callGasLimit + : k.Quantity.from(e.gasLimit)), + void 0 === e.data + ? void 0 === e.input && (b = k.Data.from(e.input)) + : (b = k.Data.from(e.data)); + const l = new v.RuntimeBlock( + o.number, + o.parentHash, + r.coinbase, + u.toBuffer(), + o.timestamp + ), + h = { + gas: u, + from: null == e.from ? r.coinbase : O.default.from(e.from), + to: null == e.to ? null : O.default.from(e.to), + gasPrice: k.Quantity.from( + null == e.gasPrice ? 0 : e.gasPrice + ), + value: null == e.value ? null : k.Quantity.from(e.value), + data: b, + block: l + }; + return r.simulateTransaction(h, n); + } + async debug_traceTransaction(e, t) { + return y(this, d).traceTransaction(e, t); + } + async personal_listAccounts() { + return y(this, u).addresses; + } + async personal_newAccount(e) { + if ("string" != typeof e) + throw new Error( + "missing value for required argument `passphrase`" + ); + const t = y(this, u), + r = t.createRandomAccount(y(this, s).wallet.mnemonic), + a = r.address.toString(), + n = await t.encrypt(r.privateKey, e); + return ( + t.encryptedKeyFiles.set(a, n), + t.addresses.push(a), + t.knownAccounts.add(a), + r.address + ); + } + async personal_importRawKey(e, t) { + if ("string" != typeof t) + throw new Error( + "missing value for required argument `passphrase`" + ); + const r = y(this, u), + a = L.default.createAccountFromPrivateKey(k.Data.from(e)), + n = a.address.toString(), + o = await r.encrypt(a.privateKey, t); + return ( + r.encryptedKeyFiles.set(n, o), + r.addresses.push(n), + r.knownAccounts.add(n), + a.address + ); + } + async personal_lockAccount(e) { + return y(this, u).lockAccount(e.toLowerCase()); + } + async personal_unlockAccount(e, t, r = 300) { + return y(this, u).unlockAccount(e.toLowerCase(), t, r); + } + async personal_sendTransaction(e, t) { + let r, + a = e.from; + if ( + (a && + ((r = O.default.from(e.from)), + (a = r.toString().toLowerCase())), + null == a) + ) + throw new Error("from not found; is required"); + const o = y(this, u), + c = o.encryptedKeyFiles.get(a); + if (void 0 === c) + throw new Error("no key for given address or file"); + let s; + if (null !== c) { + const r = await o.decrypt(c, t); + (s = new I.default(e, y(this, n))), s.sign(r); + } else s = new I.default(e, y(this, n), I.default.types.fake); + return y(this, d).queueTransaction(s); + } + async rpc_modules() { + return Q; + } + async shh_newIdentity() { + return "0x00"; + } + async shh_hasIdentity(e) { + return !1; + } + async shh_newGroup() { + return "0x00"; + } + async shh_addToGroup(e) { + return !1; + } + async shh_newFilter(e, t) { + return !1; + } + async shh_uninstallFilter(e) { + return !1; + } + async shh_getFilterChanges(e) { + return []; + } + async shh_getMessages(e) { + return !1; + } + async shh_post(e) { + return !1; + } + async shh_version() { + return "2"; + } + } + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()), + (s = new WeakMap()), + (u = new WeakMap()), + p( + [H.assertArgLength(3)], + EthereumApi.prototype, + "db_putString", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "db_getString", + null + ), + p([H.assertArgLength(3)], EthereumApi.prototype, "db_putHex", null), + p([H.assertArgLength(2)], EthereumApi.prototype, "db_getHex", null), + p([H.assertArgLength(0)], EthereumApi.prototype, "bzz_hive", null), + p([H.assertArgLength(0)], EthereumApi.prototype, "bzz_info", null), + p( + [H.assertArgLength(0, 1)], + EthereumApi.prototype, + "evm_mine", + null + ), + p( + [H.assertArgLength(3, 4)], + EthereumApi.prototype, + "evm_setStorageAt", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "evm_setAccountNonce", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "evm_increaseTime", + null + ), + p( + [H.assertArgLength(0, 1)], + EthereumApi.prototype, + "evm_setTime", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "evm_revert", + null + ), + p( + [H.assertArgLength(0, 1)], + EthereumApi.prototype, + "miner_start", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "miner_stop", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "miner_setGasPrice", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "miner_setEtherbase", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "miner_setExtra", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "web3_clientVersion", + null + ), + p([H.assertArgLength(1)], EthereumApi.prototype, "web3_sha3", null), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "net_version", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "net_listening", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "net_peerCount", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_estimateGas", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_protocolVersion", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_syncing", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_coinbase", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_getBlockByNumber", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_getBlockByHash", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getBlockTransactionCountByNumber", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getBlockTransactionCountByHash", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_getCompilers", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "eth_getTransactionByBlockHashAndIndex", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "eth_getTransactionByBlockNumberAndIndex", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getUncleCountByBlockHash", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getUncleCountByBlockNumber", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "eth_getUncleByBlockHashAndIndex", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "eth_getUncleByBlockNumberAndIndex", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getWork", + null + ), + p( + [H.assertArgLength(3)], + EthereumApi.prototype, + "eth_submitWork", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "eth_submitHashrate", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_mining", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_hashrate", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_gasPrice", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_accounts", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_blockNumber", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_chainId", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_getBalance", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_getCode", + null + ), + p( + [H.assertArgLength(2, 3)], + EthereumApi.prototype, + "eth_getStorageAt", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getTransactionByHash", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getTransactionReceipt", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_sendTransaction", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_sendRawTransaction", + null + ), + p([H.assertArgLength(2)], EthereumApi.prototype, "eth_sign", null), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "eth_signTypedData", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_subscribe", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_unsubscribe", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_newBlockFilter", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "eth_newPendingTransactionFilter", + null + ), + p( + [H.assertArgLength(0, 1)], + EthereumApi.prototype, + "eth_newFilter", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getFilterChanges", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_uninstallFilter", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getFilterLogs", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "eth_getLogs", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_getTransactionCount", + null + ), + p( + [H.assertArgLength(1, 2)], + EthereumApi.prototype, + "eth_call", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "personal_listAccounts", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "personal_newAccount", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "personal_importRawKey", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "personal_lockAccount", + null + ), + p( + [H.assertArgLength(2, 3)], + EthereumApi.prototype, + "personal_unlockAccount", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "personal_sendTransaction", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "rpc_modules", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "shh_newIdentity", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "shh_hasIdentity", + null + ), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "shh_newGroup", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "shh_addToGroup", + null + ), + p( + [H.assertArgLength(2)], + EthereumApi.prototype, + "shh_newFilter", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "shh_uninstallFilter", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "shh_getFilterChanges", + null + ), + p( + [H.assertArgLength(1)], + EthereumApi.prototype, + "shh_getMessages", + null + ), + p([H.assertArgLength(1)], EthereumApi.prototype, "shh_post", null), + p( + [H.assertArgLength(0)], + EthereumApi.prototype, + "shh_version", + null + ), + (t.default = EthereumApi); + }, + 40325: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s, + u, + b, + l, + h, + p, + x, + m, + y, + g, + v, + w, + _, + k, + B = r(98188).Buffer, + N = r(34155), + P = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + O = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + I = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + P(t, e, r); + return O(t, e), t; + }, + L = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + C = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + D = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.Status = void 0); + const j = r(67435), + U = I(r(98539)), + z = D(r(12623)), + W = D(r(54994)), + H = D(r(50800)), + q = D(r(81223)), + V = D(r(3078)), + G = D(r(73565)), + Y = D(r(88122)), + J = r(85761), + X = r(89539), + Q = r(52426), + $ = D(r(78207)), + et = r(52426), + tt = D(r(9436)), + rt = D(r(37719)), + at = D(r(3901)), + nt = r(65205), + it = D(r(41667)), + ot = D(r(68246)), + ct = D(r(81702)), + dt = r(37956), + st = r(57898), + ut = r(23214), + bt = D(r(63547)), + { + BUFFER_EMPTY: ht, + RPCQUANTITY_EMPTY: pt, + BUFFER_32_ZERO: xt, + BUFFER_256_ZERO: mt, + RPCQUANTITY_ZERO: yt + } = et.utils, + vt = et.utils.unref; + var wt; + !(function (e) { + (e[(e.started = 1)] = "started"), + (e[(e.starting = 2)] = "starting"), + (e[(e.stopped = 4)] = "stopped"), + (e[(e.stopping = 8)] = "stopping"), + (e[(e.paused = 16)] = "paused"); + })((wt = t.Status || (t.Status = {}))); + class Blockchain extends H.default.Typed { + constructor(e, t, r, P) { + super(), + a.set(this, wt.starting), + n.set(this, void 0), + o.set(this, void 0), + c.set(this, void 0), + d.set(this, void 0), + s.set(this, void 0), + u.set(this, void 0), + b.set(this, ({ block: e, serialized: t }) => { + const { blocks: r } = this; + return ( + (r.latest = e), + C(this, c).batch(() => { + const a = e.hash().toBuffer(), + n = e.header, + o = n.number, + c = n.number.toBuffer(), + d = V.default.create(a), + u = new Date(1e3 * n.timestamp.toNumber()).toString(), + b = []; + return ( + e.getTransactions().forEach((e, t) => { + const r = e.hash(), + n = Q.Quantity.from(t).toBuffer(), + s = [...e.raw, a, c, n, B.from([e.type]), e.from], + l = nt.encode(s); + this.transactions.set(r, l); + const p = e.getReceipt(), + x = p.serialize(!0); + this.transactionReceipts.set(r, x), + e.getLogs().forEach(d.append.bind(d, n, r)), + b.push( + C(this, h).call(this, r, p, o, u, e.execException) + ); + }), + (d.blockNumber = o), + this.blockLogs.set(c, d.serialize()), + r.putBlock(c, a, t), + C(this, s).logging.logger.log(b.join(j.EOL)), + { block: e, blockLogs: d } + ); + }) + ); + }), + l.set(this, async e => { + const t = C(this, s), + { block: r, blockLogs: a } = e; + return ( + r.getTransactions().forEach(e => { + e.finalize("confirmed", e.execException); + }), + C(this, u) && t.miner.legacyInstamine + ? await new Promise(e => { + N.nextTick(async () => { + await Promise.all([ + this.emit("blockLogs", a), + this.emit("block", r) + ]), + e(void 0); + }); + }) + : await Promise.all([ + this.emit("blockLogs", a), + this.emit("block", r) + ]), + e + ); + }), + h.set(this, (e, t, r, a, n) => { + let o = `${j.EOL} Transaction: ${Q.Data.from(e)}${j.EOL}`; + const c = t.contractAddress; + return ( + null != c && + (o += ` Contract created: ${ot.default.from(c)}${ + j.EOL + }`), + (o += ` Gas usage: ${Q.Quantity.from( + t.raw[1] + ).toNumber()}${j.EOL}\n Block number: ${r.toNumber()}${ + j.EOL + }\n Block time: ${a}${j.EOL}`), + n && + ((o += ` Runtime error: ${n.data.message}${j.EOL}`), + n.data.reason && + (o += ` Revert reason: ${n.data.reason}${j.EOL}`)), + o + ); + }), + p.set( + this, + async e => ( + L( + this, + o, + C(this, o) + .then(() => C(this, b).call(this, e)) + .then(C(this, l)) + ), + C(this, o) + ) + ), + x.set(this, (e, t) => { + const r = e.header.number.toBigInt() || 0n; + return new st.RuntimeBlock( + Q.Quantity.from(r + 1n), + e.hash(), + this.coinbase, + C(this, s).miner.blockGasLimit.toBuffer(), + Q.Quantity.from(null == t ? C(this, w).call(this) : t) + ); + }), + (this.isStarted = () => C(this, a) === wt.started), + (this.mine = async (e, t, r = !1) => { + await C(this, o); + const a = C(this, x).call(this, this.blocks.latest, t); + return C(this, n).mine(a, e, r); + }), + m.set(this, () => 0 != (C(this, a) & wt.paused)), + (this.createVmFromStateTrie = (e, t) => { + const r = this.blocks, + a = class T { + static async [X.promisify.custom](e) { + const t = await r.get(e.toBuffer()).catch(e => null); + return t ? { hash: () => t.hash().toBuffer() } : null; + } + }; + return new it.default({ + state: e, + activatePrecompiles: !0, + common: C(this, d), + allowUnlimitedContractSize: t, + blockchain: { getBlock: a } + }); + }), + y.set( + this, + e => + new Promise((t, r) => { + let a = e.length; + const cb = e => { + e ? r(e) : 0 == --a && t(void 0); + }; + for (let t = 0; t < a; t++) { + const r = e[t]; + this.trie.put(r.address.toBuffer(), r.serialize(), cb); + } + }) + ), + g.set(this, async (e, t) => { + const r = pt, + a = new st.RuntimeBlock( + r, + Q.Quantity.from(xt), + C(this, s).miner.coinbase, + t.toBuffer(), + Q.Quantity.from(e) + ), + { block: n, serialized: o } = a.finalize( + J.KECCAK256_RLP, + J.KECCAK256_RLP, + mt, + this.trie.root, + ht, + C(this, s).miner.extraData, + [] + ); + n.header.number = yt; + const c = n.hash().toBuffer(); + return this.blocks + .putBlock(n.header.number.toBuffer(), c, o) + .then(e => ({ block: n, blockLogs: V.default.create(c) })); + }), + v.set(this, 0), + w.set(this, () => Math.floor((Date.now() + C(this, v)) / 1e3)), + _.set(this, e => + C(this, c).batch(() => { + const { + blocks: t, + transactions: r, + transactionReceipts: a, + blockLogs: n + } = this; + e.forEach(e => { + e.getTransactions().forEach(e => { + const t = e.hash(); + r.del(t), a.del(t); + }); + const o = e.header.number.toBuffer(); + t.del(o), t.del(e.hash().toBuffer()), n.del(o); + }); + }) + ), + k.set(this, { + snaps: [], + blocks: null, + unsubscribeFromBlocks: null + }), + L(this, s, e), + L(this, d, t); + const O = L( + this, + u, + !e.miner.blockTime || e.miner.blockTime <= 0 + ), + I = e.miner.legacyInstamine; + I && + console.info( + "Legacy instamining, where transactions are fully mined before the hash is returned, is deprecated and will be removed in the future." + ), + O || + (I && + console.info( + "Setting `legacyInstamine` to `true` has no effect when blockTime is non-zero" + ), + e.chain.vmErrorsOnRPCResponse && + console.info( + "Setting `vmErrorsOnRPCResponse` to `true` has no effect on transactions when blockTime is non-zero" + )); + const D = L(this, c, new W.default(e.database, this)); + D.once("ready").then(async () => { + const c = (this.blocks = await q.default.initialize( + t, + D.blockIndexes, + D.blocks + )), + d = c.latest; + d + ? (L(this, o, Promise.resolve({ block: d, blockLogs: null })), + (this.trie = new Y.default( + D.trie, + d.header.stateRoot.toBuffer() + ))) + : (this.trie = new Y.default(D.trie, null)), + (this.blockLogs = new ct.default(D.blockLogs)), + (this.transactions = new G.default( + e.miner, + t, + this, + D.transactions + )), + (this.transactionReceipts = new rt.default( + D.transactionReceipts, + at.default + )), + (this.accounts = new $.default(this, D.trie)), + (this.coinbase = P), + (this.vm = this.createVmFromStateTrie( + this.trie, + e.chain.allowUnlimitedContractSize + )); + { + let t; + if (null != e.chain.time) { + const r = +e.chain.time; + (t = Math.floor(r / 1e3)), this.setTime(r); + } else t = C(this, w).call(this); + d || + (await C(this, y).call(this, r), + L(this, o, C(this, g).call(this, t, e.miner.blockGasLimit)), + (c.earliest = c.latest = await C(this, o).then( + ({ block: e }) => e + ))); + } + { + const t = this.transactions.transactionPool, + r = e.miner, + a = L( + this, + n, + new z.default(r, t.executables, O, this.vm, C(this, x)) + ), + o = Promise.resolve(null), + mineAll = e => (C(this, m).call(this) ? o : this.mine(e)); + if (O) t.on("drain", mineAll.bind(null, 1)); + else { + const wait = () => vt(setTimeout(next, 1e3 * r.blockTime)), + next = () => mineAll(-1).then(wait); + wait(); + } + a.on("block", C(this, p)), + this.once("stop").then(() => a.clearListeners()); + } + L(this, a, wt.started), this.emit("start"); + }); + } + pause() { + L(this, a, C(this, a) | wt.paused); + } + resume(e = 1) { + if (C(this, m).call(this)) + return ( + L(this, a, C(this, a) ^ wt.paused), + C(this, u) ? this.mine(-1) : void 0 + ); + console.log( + "Warning: startMining called when miner was already started" + ); + } + increaseTime(e) { + return e < 0 && (e = 0), L(this, v, C(this, v) + e); + } + setTime(e) { + return L(this, v, e - Date.now()); + } + snapshot() { + const e = C(this, k), + t = e.snaps.push({ + block: this.blocks.latest, + timeAdjustment: C(this, v) + }); + return ( + 1 === t && + (e.unsubscribeFromBlocks = this.on("block", t => { + e.blocks = { current: t.hash().toBuffer(), next: e.blocks }; + })), + C(this, s).logging.logger.log("Saved snapshot #" + t), + t + ); + } + async revert(e) { + const t = e.valueOf(); + if (null == t) throw new Error("invalid snapshotId"); + if ( + (C(this, s).logging.logger.log("Reverting to snapshot #" + e), + t < 1n) + ) + return !1; + const r = C(this, k), + a = r.snaps, + c = Number(t - 1n), + d = a[c]; + if (!d) return !1; + await this.transactions.pause(), + await C(this, n).pause(), + await C(this, o), + this.transactions.clear(); + const u = this.blocks, + b = u.latest.hash().toBuffer(), + l = d.block, + h = l.header, + p = l.hash().toBuffer(); + if ( + (a.splice(c), + 0 === a.length && r.unsubscribeFromBlocks(), + !b.equals(p)) + ) { + const e = []; + let t = r.blocks; + for (; null !== t && !t.current.equals(p); ) + e.push(u.getByHash(t.current)), (t = t.next); + (r.blocks = t), + await Promise.all(e).then(C(this, _)), + (function setStateRootSync(e, t) { + (e._trie.root = t), + e._cache.clear(), + (e._storageTries = {}); + })(this.vm.stateManager, h.stateRoot.toBuffer()), + (u.latest = l); + } + return ( + L(this, v, d.timeAdjustment), + C(this, n).resume(), + this.transactions.resume(), + !0 + ); + } + async queueTransaction(e, t) { + !0 === (await this.transactions.add(e, t)) && + N.nextTick(this.emit.bind(this), "pendingTransaction", e); + const r = Q.Data.from(e.hash(), 32); + if (C(this, m).call(this) || !C(this, u)) return r; + if (C(this, u) && C(this, s).miner.legacyInstamine) { + const { status: t, error: r } = await e.once("finalized"); + if ( + r && + ("rejected" === t || C(this, s).chain.vmErrorsOnRPCResponse) + ) + throw r; + } + return r; + } + async simulateTransaction(e, t) { + let r; + const a = C(this, s), + n = e.data; + let o = e.gas.toBigInt(); + if ( + ((o -= tt.default.calculateIntrinsicGas( + n ? n.toBuffer() : null, + a.chain.hardfork + )), + o >= 0) + ) { + const a = new Y.default( + C(this, c).trie, + t.header.stateRoot.toBuffer() + ), + n = this.createVmFromStateTrie( + a, + this.vm.allowUnlimitedContractSize + ); + r = await n.runCall({ + caller: e.from.toBuffer(), + data: e.data && e.data.toBuffer(), + gasPrice: e.gasPrice.toBuffer(), + gasLimit: Q.Quantity.from(o).toBuffer(), + to: e.to && e.to.toBuffer(), + value: e.value && e.value.toBuffer(), + block: e.block + }); + } else + r = { + execResult: { + runState: { programCounter: 0 }, + exceptionError: new dt.VmError(dt.ERROR.OUT_OF_GAS), + returnValue: ht + } + }; + if (r.execResult.exceptionError) { + if (C(this, s).chain.vmErrorsOnRPCResponse) { + const e = ht; + throw new U.default(e, r, U.RETURN_TYPES.RETURN_VALUE); + } + return Q.Data.from(r.execResult.returnValue || "0x"); + } + return Q.Data.from(r.execResult.returnValue || "0x"); + } + async traceTransaction(e, t) { + let r = -1; + const a = []; + let n = 0; + const o = [], + u = Q.Data.from(e).toBuffer(), + b = await this.transactions.get(u); + if (!b) throw new Error("Unknown transaction " + e); + const l = await this.blocks.get(b._blockNum), + h = await this.blocks.getByHash(l.header.parentHash.toBuffer()), + p = new Y.default( + C(this, c).trie, + h.header.stateRoot.toBuffer() + ), + x = new st.RuntimeBlock( + Q.Quantity.from(h.header.number.toBigInt() + 1n), + h.hash(), + h.header.miner, + h.header.gasLimit.toBuffer(), + l.header.timestamp + ); + (x.transactions = []), (x.uncleHeaders = []); + const m = l.getTransactions(); + for (const e of m) + if ((x.transactions.push(e), e.hash().equals(u))) break; + const y = ut.TraceDataFactory(), + stepListener = (e, c) => { + const d = e.gasLeft.toNumber(), + s = Q.Quantity.from(b.gasLimit).toNumber() - d - n; + n += s; + const u = []; + if (!0 !== t.disableMemory) { + let t = 0; + for (; t < e.memory.length; ) { + const r = e.memory.slice(t, t + 32); + u.push(y.from(B.from(r))), (t += 32); + } + } + const l = []; + if (!0 !== t.disableStack) + for (const t of e.stack) l.push(y.from(t.toBuffer())); + const h = { + depth: e.depth, + error: "", + gas: d, + gasCost: 0, + memory: u, + op: e.opcode.name, + pc: e.pc, + stack: l, + storage: null + }; + if ( + (o.length && (o[o.length - 1].gasCost = s), + !0 === t.disableStorage) + ) + o.push(h), c(); + else { + const { depth: t } = e; + switch ( + (r > t ? a.pop() : r < t && a.push(new bt.default()), + (r = t), + e.opcode.name) + ) { + case "SSTORE": { + const e = l[l.length - 1], + r = l[l.length - 2]; + (h.storage = new bt.default(a[t])), + o.push(h), + c(), + a[t].set(e, r); + break; + } + case "SLOAD": { + const r = l[l.length - 1]; + _.stateManager.getContractStorage( + e.address, + r.toBuffer(), + (e, n) => { + if (e) return c(e); + const d = y.from(n); + a[t].set(r, d), + (h.storage = new bt.default(a[t])), + o.push(h), + c(); + } + ); + break; + } + default: + (h.storage = new bt.default(a[t])), o.push(h), c(); + } + } + }; + let g = null; + const beforeTxListener = t => { + (g = Q.Data.from(t.hash()).toString()), + g == e && _.on("step", stepListener); + }, + afterTxListener = () => { + g == e && removeListeners(); + }, + removeListeners = () => { + _.removeListener("step", stepListener), + _.removeListener("beforeTx", beforeTxListener), + _.removeListener("afterTx", afterTxListener); + }, + v = this.blocks, + w = class T { + static async [X.promisify.custom](e) { + const t = await v.get(e.toBuffer()).catch(e => null); + return t ? t.value : null; + } + }, + _ = new it.default({ + state: p, + activatePrecompiles: !0, + common: C(this, d), + allowUnlimitedContractSize: C(this, s).chain + .allowUnlimitedContractSize, + blockchain: { getBlock: w } + }); + return ( + _.on("beforeTx", beforeTxListener), + _.on("afterTx", afterTxListener), + (_.stateManager._cache.flush = e => e()), + await _.runBlock({ + block: x, + generate: !0, + skipBlockValidation: !0 + }), + removeListeners(), + { gas: n, structLogs: o, returnValue: "" } + ); + } + async stop() { + C(this, a) === wt.starting && (await this.once("start")), + this.vm.removeAllListeners(), + await this.transactions.pause(), + await C(this, n).pause(), + await C(this, o), + await this.emit("stop"), + C(this, a) === wt.started && + (L(this, a, wt.stopping), + await C(this, c).close(), + L(this, a, wt.stopped)); + } + } + (t.default = Blockchain), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()), + (s = new WeakMap()), + (u = new WeakMap()), + (b = new WeakMap()), + (l = new WeakMap()), + (h = new WeakMap()), + (p = new WeakMap()), + (x = new WeakMap()), + (m = new WeakMap()), + (y = new WeakMap()), + (g = new WeakMap()), + (v = new WeakMap()), + (w = new WeakMap()), + (_ = new WeakMap()), + (k = new WeakMap()); + }, + 70276: function (e, t, r) { + "use strict"; + var a, + n, + o = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + c = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + d = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + o(t, e, r); + return c(t, e), t; + }, + s = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + u = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + b = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.Connector = t.FlavorName = t.Provider = void 0); + const l = b(r(50800)), + h = r(52426), + p = b(r(56433)), + x = d(r(4388)); + (t.Provider = p.default), (t.FlavorName = "ethereum"); + class Connector extends l.default.Typed { + constructor(e = null, t) { + super(), + a.set(this, void 0), + n.set(this, (e, t) => { + const r = e.method; + if ( + "eth_subscribe" === r && + (function isHttp(e) { + return "uWS.HttpRequest" === e.constructor.name; + })(t) + ) + return Promise.reject( + new x.default( + "notifications not supported", + x.ErrorCodes.METHOD_NOT_SUPPORTED + ) + ); + const n = e.params; + return u(this, a)._requestRaw({ method: r, params: n }); + }); + s(this, a, new p.default(e, t)).on("connect", () => { + this.emit("ready"); + }); + } + get provider() { + return u(this, a); + } + parse(e) { + try { + return JSON.parse(e); + } catch (e) { + throw new x.default(e.message, x.ErrorCodes.PARSE_ERROR); + } + } + handle(e, t) { + if (Array.isArray(e)) { + const r = e.map(e => + u(this, n) + .call(this, e, t) + .then(({ value: e }) => e) + .catch(e => e) + ); + return Promise.resolve({ value: Promise.all(r) }); + } + return u(this, n).call(this, e, t); + } + format(e, t) { + if (Array.isArray(t)) + return JSON.stringify( + t.map((t, r) => { + const a = e[r]; + return a instanceof Error + ? h.JsonRpcTypes.Error(t.id, a) + : h.JsonRpcTypes.Response(t.id, a); + }) + ); + { + const r = h.JsonRpcTypes.Response(t.id, e); + return JSON.stringify(r); + } + } + formatError(e, t) { + const r = h.JsonRpcTypes.Error(t && t.id ? t.id : null, e); + return JSON.stringify(r); + } + close() { + return u(this, a).disconnect(); + } + } + (t.Connector = Connector), (a = new WeakMap()), (n = new WeakMap()); + }, + 78207: function (e, t, r) { + "use strict"; + var a, + n, + o = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + c = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + d = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const s = d(r(28583)), + u = d(r(84638)), + b = d(r(1169)), + l = r(85761), + h = r(52426), + { keccak: p, RPCQUANTITY_ZERO: x } = h.utils; + (t.default = class AccountManager { + constructor(e, t) { + a.set(this, void 0), + n.set(this, void 0), + o(this, a, e), + o(this, n, t); + } + async getRaw(e, t = b.default.LATEST) { + const r = c(this, a), + o = await r.blocks.get(t), + d = new u.default(c(this, n), o.header.stateRoot.toBuffer()); + return new Promise((t, r) => { + d.get(p(e.toBuffer()), (e, a) => { + if (e) return r(e); + t(a); + }); + }); + } + async getNonce(e, t = b.default.LATEST) { + return this.getRaw(e, t).then(e => { + if (e) { + const [t] = l.rlp.decode(e); + return 0 === t.length ? x : h.Quantity.from(t); + } + return x; + }); + } + async getBalance(e, t = b.default.LATEST) { + return this.getRaw(e, t).then(e => { + if (e) { + const [, t] = l.rlp.decode(e); + return 0 === t.length ? x : h.Quantity.from(t); + } + return x; + }); + } + async get(e, t = b.default.LATEST) { + return this.getRaw(e, t).then(e => s.default.fromBuffer(e)); + } + }), + (a = new WeakMap()), + (n = new WeakMap()); + }, + 81223: function (e, t, r) { + "use strict"; + var a, + n, + o = r(98188).Buffer, + c = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + d = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + s = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const u = s(r(37719)), + b = s(r(1169)), + l = r(52426), + h = r(57898), + p = o.from([]); + class BlockManager extends u.default { + constructor(e, t, r) { + super(r, h.Block, e), + a.set(this, void 0), + n.set(this, void 0), + c(this, a, e), + c(this, n, t); + } + static async initialize(e, t, r) { + const a = new BlockManager(e, t, r); + return await a.updateTaggedBlocks(), a; + } + getBlockByTag(e) { + switch (b.default.normalize(e)) { + case b.default.LATEST: + return this.latest; + case void 0: + case null: + break; + case b.default.PENDING: + return this.latest; + case b.default.EARLIEST: + return this.earliest; + default: + throw new Error("Invalid block Tag: " + e); + } + } + getEffectiveNumber(e = b.default.LATEST) { + if ("string" == typeof e) { + const t = this.getBlockByTag(e); + if (t) return t.header.number; + } + return l.Quantity.from(e); + } + async getNumberFromHash(e) { + return d(this, n) + .get(l.Data.from(e).toBuffer()) + .catch(e => { + if (404 === e.status) return null; + throw e; + }); + } + async getByHash(e) { + const t = await this.getNumberFromHash(e); + return t ? super.get(t) : null; + } + async getRaw(e) { + return super.getRaw(this.getEffectiveNumber(e).toBuffer()); + } + async get(e) { + if ("string" == typeof e) { + const t = this.getBlockByTag(e); + if (t) return t; + } + const t = await super.get(e); + if (t) return t; + throw new Error("header not found"); + } + async putBlock(e, t, r) { + let a = e; + p.equals(a) && (a = o.from([0])); + const c = t; + await Promise.all([d(this, n).put(c, a), super.set(a, r)]); + } + updateTaggedBlocks() { + return new Promise((e, t) => { + this.base + .createValueStream({ limit: 1 }) + .on("data", e => { + this.earliest = new h.Block(e, d(this, a)); + }) + .on("error", e => { + t(e); + }) + .on("end", () => { + e(void 0); + }), + this.base + .createValueStream({ reverse: !0, limit: 1 }) + .on("data", e => { + this.latest = new h.Block(e, d(this, a)); + }) + .on("error", e => { + t(e); + }) + .on("end", () => { + e(void 0); + }); + }); + } + } + (t.default = BlockManager), (a = new WeakMap()), (n = new WeakMap()); + }, + 81702: function (e, t, r) { + "use strict"; + var a = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const n = a(r(3078)), + o = a(r(37719)), + c = r(52426); + class BlockLogManager extends o.default { + constructor(e) { + super(e, n.default); + } + async get(e) { + const t = await super.get(e); + return ( + t && + (t.blockNumber = + e instanceof c.Quantity ? e : c.Quantity.from(e)), + t + ); + } + } + t.default = BlockLogManager; + }, + 37719: function (e, t, r) { + "use strict"; + var a, + n, + o = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + c = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const d = r(52426); + (t.default = class Manager { + constructor(e, t, r) { + a.set(this, void 0), + n.set(this, void 0), + o(this, a, t), + o(this, n, r), + (this.base = e); + } + getRaw(e) { + return ( + "string" == typeof e && (e = d.Data.from(e).toBuffer()), + 0 === e.length + ? null + : this.base.get(e).catch(e => { + if (404 === e.status) return null; + throw e; + }) + ); + } + async get(e) { + const t = await this.getRaw(e); + return t ? new (c(this, a))(t, c(this, n)) : null; + } + set(e, t) { + return this.base.put(e, t); + } + del(e) { + return this.base.del(e); + } + }), + (a = new WeakMap()), + (n = new WeakMap()); + }, + 73565: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + s = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + u = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const b = u(r(9436)), + l = u(r(37719)), + h = u(r(87454)), + p = u(r(32516)); + class TransactionManager extends l.default { + constructor(e, t, r, u) { + super(u, b.default, t), + a.set(this, new p.default()), + n.set(this, !1), + o.set(this, void 0), + c.set(this, void 0), + (this.resume = () => { + d(this, n) && (s(this, n, !1), d(this, c).call(this)); + }), + (this.transactionPool = new h.default(e, r)); + } + async add(e, t) { + d(this, n) && (await d(this, o)); + const r = this.transactionPool.prepareTransaction(e, t), + c = await d(this, a).add(r); + return c && this.transactionPool.drain(), c; + } + clear() { + d(this, a).clear(!1), this.transactionPool.clear(); + } + async pause() { + d(this, n) || + (s(this, n, !0), + s( + this, + o, + new Promise(e => { + s(this, c, e); + }) + )), + d(this, a).isBusy() && (await d(this, a).emit("idle")); + } + } + (t.default = TransactionManager), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()); + }, + 54994: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s, + u = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + b = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + l = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const h = l(r(50800)), + p = r(56235), + x = l(r(1945)), + m = r(99558), + y = r(48788), + g = r(29378); + p.setGracefulCleanup(); + const v = { prefix: "ganache-core_", unsafeCleanup: !0 }, + noop = () => Promise.resolve(); + class Database extends h.default { + constructor(e, t) { + super(), + a.set(this, void 0), + n.set(this, noop), + o.set(this, !1), + (this.directory = null), + (this.db = null), + c.set(this, void 0), + d.set(this, async () => { + const e = { valueEncoding: "binary" }, + t = b(this, a).db; + let r; + if (t) u(this, c, g(t, e)), (r = x.default(b(this, c), {})); + else { + let t = b(this, a).dbPath; + if (!t) { + const e = await p.dir(v); + if (((t = e.path), u(this, n, e.cleanup), b(this, o))) + return b(this, s).call(this); + } + this.directory = t; + const d = g(m(t, { prefix: "" }), e); + u(this, c, d), (r = x.default(d, {})); + } + if (b(this, o)) return b(this, s).call(this); + const d = r.open(); + return ( + (this.trie = y(r, "T", e)), + (this.db = r), + await d, + b(this, o) + ? b(this, s).call(this) + : ((this.blocks = y(r, "b", e)), + (this.blockIndexes = y(r, "i", e)), + (this.blockLogs = y(r, "l", e)), + (this.transactions = y(r, "t", e)), + (this.transactionReceipts = y(r, "r", e)), + this.emit("ready")) + ); + }), + s.set(this, async () => { + const e = this.db; + return ( + e && + (await new Promise((t, r) => + e.close(e => { + e ? r(e) : t(void 0); + }) + ), + await Promise.all([ + this.blocks.close(), + this.blockIndexes.close(), + this.blockIndexes.close(), + this.transactionReceipts.close(), + this.transactions.close(), + this.trie.close() + ])), + b(this, n).call(this) + ); + }), + u(this, a, e), + (this.blockchain = t), + b(this, d).call(this); + } + batch(e) { + const t = b(this, c).db, + r = this.db.batch(), + a = t.put, + n = t.del; + let o; + (t.put = r.put.bind(r)), (t.del = r.del.bind(r)); + try { + const c = e(); + o = r.write().then(() => c); + } finally { + (t.put = a), (t.del = n); + } + return o; + } + async close() { + const e = b(this, o); + u(this, o, !0), + await b(this, s).call(this), + e || this.emit("close"); + } + } + (t.default = Database), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()), + (s = new WeakMap()); + }, + 4388: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.ErrorCodes = void 0), + (t.ErrorCodes = { + PARSE_ERROR: -32700, + INVALID_REQUEST: -32600, + METHOD_NOT_FOUND: -32601, + INVALID_PARAMS: -32602, + INTERNAL_ERROR: -32603, + INVALID_INPUT: -32e3, + TRANSACTION_REJECTED: -32003, + METHOD_NOT_SUPPORTED: -32004, + JSON_RPC_VERSION_NOT_SUPPORTED: -32006 + }); + class CodedError extends Error { + constructor(e, t) { + super(e), + Error.captureStackTrace(this, this.constructor), + (this.code = t); + } + static from(e, t) { + const r = new CodedError(e.message, t); + return (r.stack = e.stack), r; + } + } + t.default = CodedError; + }, + 95768: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.VM_EXCEPTIONS = t.VM_EXCEPTION = t.GAS_LIMIT = t.INTRINSIC_GAS_TOO_LOW = t.UNDERPRICED = t.NONCE_TOO_LOW = t.INVALID_SENDER = void 0), + (t.INVALID_SENDER = "invalid sender"), + (t.NONCE_TOO_LOW = "nonce too low"), + (t.UNDERPRICED = "transaction underpriced"), + (t.INTRINSIC_GAS_TOO_LOW = "intrinsic gas too low"), + (t.GAS_LIMIT = "exceeds block gas limit"), + (t.VM_EXCEPTION = "VM Exception while processing transaction: "), + (t.VM_EXCEPTIONS = + "Multiple VM Exceptions while processing transactions: : \n\n"); + }, + 98539: function (e, t, r) { + "use strict"; + var a = r(98188).Buffer, + n = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + o = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + c = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + n(t, e, r); + return o(t, e), t; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.RETURN_TYPES = void 0); + const d = r(95768), + s = r(52426), + u = r(872), + b = c(r(4388)), + l = a.from("08c379a0", "hex"); + var h; + !(function (e) { + (e[(e.TRANSACTION_HASH = 0)] = "TRANSACTION_HASH"), + (e[(e.RETURN_VALUE = 1)] = "RETURN_VALUE"); + })((h = t.RETURN_TYPES || (t.RETURN_TYPES = {}))); + class RuntimeError extends b.default { + constructor(e, t, r) { + const a = t.execResult, + n = a.exceptionError.error; + let o = d.VM_EXCEPTION + n; + super(o, b.ErrorCodes.INVALID_INPUT), + Error.captureStackTrace(this, this.constructor), + (this.name = this.constructor.name); + const c = a.returnValue, + p = "0x" + e.toString("hex"); + let x; + if (c.length > 4 && 0 === l.compare(c, 0, 4)) + try { + (x = u.rawDecode(["bytes"], c.slice(4))[0].toString()), + (o += " " + x); + } catch { + x = null; + } + else x = null; + (this.message = o), + (this.data = { + hash: p, + programCounter: a.runState.programCounter, + result: + r === h.TRANSACTION_HASH + ? p + : s.Data.from(c || "0x").toString(), + reason: x, + message: n + }); + } + } + t.default = RuntimeError; + }, + 25925: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.assertArgLength = void 0), + (t.assertArgLength = function assertArgLength(e, t = e) { + return function (r, a, n) { + const o = n.value; + return ( + (n.value = function () { + const r = arguments.length; + if (r < e || r > t) + throw new Error( + `Incorrect number of arguments. '${a}' requires ${ + e === t + ? `exactly ${e} ${ + 1 === e ? "argument" : "arguments" + }.` + : `between ${e} and ${t} arguments.` + }` + ); + return Reflect.apply(o, this, arguments); + }), + n + ); + }; + }); + }, + 475: function (e, t, r) { + "use strict"; + var a = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.parseFilter = t.parseFilterRange = t.parseFilterDetails = void 0); + const n = a(r(68246)); + function parseFilterDetails(e) { + return { + addresses: e.address + ? (Array.isArray(e.address) ? e.address : [e.address]).map(e => + n.default.from(e.toLowerCase()).toBuffer() + ) + : [], + topics: e.topics ? e.topics : [] + }; + } + function parseFilterRange(e, t) { + const r = t.blocks.latest.header.number, + a = t.blocks.getEffectiveNumber(e.fromBlock || "latest"), + n = r.toNumber(), + o = t.blocks.getEffectiveNumber(e.toBlock || "latest"); + let c; + return ( + (c = o > r ? n : o.toNumber()), + { fromBlock: a, toBlock: o, toBlockNumber: c } + ); + } + (t.parseFilterDetails = parseFilterDetails), + (t.parseFilterRange = parseFilterRange), + (t.parseFilter = function parseFilter( + e = { address: [], topics: [] }, + t + ) { + const { addresses: r, topics: a } = parseFilterDetails(e), + { + fromBlock: n, + toBlock: o, + toBlockNumber: c + } = parseFilterRange(e, t); + return { + addresses: r, + fromBlock: n, + toBlock: o, + toBlockNumber: c, + topics: a + }; + }); + }, + 16943: function (e, t, r) { + "use strict"; + var a = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + n = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + o = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + a(t, e, r); + return n(t, e), t; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const c = r(52426), + d = r(85761), + s = o(r(98539)), + bn = (e = 0) => new d.BN(e), + u = bn(2300), + check = e => t => e.has(t), + b = check( + new Set(["CALL", "DELEGATECALL", "STATICCALL", "CALLCODE"]) + ), + l = check(new Set(["CALL", "CALLCODE"])), + h = check(new Set(["CREATE", "CREATE2"])), + p = check( + new Set(["STOP", "RETURN", "REVERT", "INVALID", "SELFDESTRUCT"]) + ), + binSearch = async (e, t, r, a) => { + const n = c.Quantity.from(t.block.header.gasLimit).toBigInt(), + o = r.execResult.gasRefund, + d = o ? r.gasEstimate.add(o) : r.gasEstimate, + s = { lo: d, hi: d }, + isEnoughGas = async r => { + const a = e(); + t.tx.gasLimit = r.toBuffer(); + const n = await a.runTx(t).catch(e => ({ vmerr: e })); + return !n.vmerr && !n.execResult.exceptionError; + }; + if (!(await isEnoughGas(s.hi))) { + do { + s.hi = s.hi.muln(1.0158730158730158); + } while (!(await isEnoughGas(s.hi))); + for (; s.lo.addn(1).lt(s.hi); ) { + const e = s.lo.add(s.hi).divn(2); + (await isEnoughGas(e)) ? (s.hi = e) : (s.lo = e); + } + if (s.hi.gte(n) && !(await isEnoughGas(s.hi))) + return a( + new Error( + "gas required exceeds allowance or always failing transaction" + ) + ); + } + (r.gasEstimate = s.hi), a(null, r); + }, + exactimate = async (e, t, r) => { + const a = (() => { + const e = [], + t = [], + r = new Set(); + let a = !1, + n = 0; + return { + collect: o => { + a && (o.depth === n && r.add(t.length - 1), (a = !1)), + b(o.opcode.name) + ? ((o.stack = o.stack.map(e => e.clone())), + (a = !0), + (n = o.depth), + e.push({ + index: t.length, + depth: o.depth, + name: o.opcode.name + })) + : (h(o.opcode.name) || p(o.opcode.name)) && + e.push({ + index: t.length, + depth: o.depth, + name: o.opcode.name + }), + t.push(o); + }, + isPrecompile: e => r.has(e), + done: () => + !t.length || + e.length < 2 || + !p(t[t.length - 1].opcode.name), + ops: t, + systemOps: e + }; + })(); + e.on("step", a.collect); + const Context = (e, t) => { + const r = 0 === e; + let n = e, + o = 0; + const c = bn(); + let d = bn(); + const s = a.ops[e], + b = a.ops[e + 1], + h = s.gasLeft.sub(b.gasLeft), + p = t || bn(); + let x = !1; + function addGas(e) { + d.gtn(0) && (e.gte(d) ? (d = bn()) : d.isub(e)), c.iadd(e); + } + return { + start: () => n, + stop: () => o, + setStart: e => { + (n = e), (x = !0); + }, + setStop: e => { + o = e; + }, + getCost: () => ({ cost: c, sixtyFloorths: d }), + transfer: e => { + const t = e.getCost(); + addGas(t.cost), d.iadd(t.sixtyFloorths); + }, + addSixtyFloorth: e => { + d.iadd(e); + }, + addRange: (e = bn()) => { + addGas( + a.ops[r || x ? n : n + 1].gasLeft + .sub(a.ops[o].gasLeft) + .add(e) + ); + }, + finalizeRange: () => { + let e; + if (x && o !== a.ops.length - 1) { + (e = a.ops[n].gasLeft.sub(a.ops[o - 1].gasLeft)), + addGas(e); + e = a.ops[o - 1].gasLeft.sub(a.ops[o].gasLeft).add(h); + } else e = a.ops[n].gasLeft.sub(a.ops[o].gasLeft); + if ( + (e.isub(p), + addGas(e), + l(s.opcode.name) && + !s.stack[s.stack.length - 3].isZero()) + ) { + c.iadd(d); + const e = b.gasLeft.sub(a.ops[o - 1].gasLeft); + e.gt(u) ? (d = c.divn(63)) : e.lte(u) && (d = u.sub(e)); + } else + o !== a.ops.length - 1 && (c.iadd(d), (d = c.divn(63))); + } + }; + }, + n = await e.runTx(t).catch(e => ({ vmerr: e })), + o = n.vmerr; + if (o) return r(o); + if (n.execResult.exceptionError) { + return r( + new s.default(t.tx.hash(), n, s.RETURN_TYPES.RETURN_VALUE), + n + ); + } + if (a.done()) { + const e = n.gasUsed; + n.gasEstimate = e; + } else { + const e = a.ops[0].gasLeft.sub(a.ops[a.ops.length - 1].gasLeft), + t = (() => { + const e = a.systemOps, + t = a.ops, + opIndex = t => e[t].index, + r = []; + let n = 0, + o = Context(0); + for (; n < e.length; ) { + const e = opIndex(n), + c = t[e], + d = c.opcode.name; + if (b(d) || h(d)) + a.isPrecompile(e) + ? (o.setStop(e + 1), + o.addRange(), + o.setStart(e + 1), + o.addSixtyFloorth(u)) + : (o.setStop(e), + o.addRange(bn(c.opcode.fee)), + r.push(o), + (o = Context(e, bn(c.opcode.fee)))); + else { + if (!p(d)) throw new Error("INVALID OPCODE"); + { + o.setStop(e + 1 < a.ops.length ? e + 1 : e), + o.finalizeRange(); + const t = r.pop(); + if (!t) break; + t.transfer(o), (o = t), o.setStart(e + 1); + } + } + n++; + } + const c = o.getCost(); + return c.cost.add(c.sixtyFloorths); + })().sub(e); + n.gasEstimate = n.gasUsed.add(t); + } + r(o, n); + }; + t.default = (e, t, r) => { + exactimate(e(), t, (a, n) => { + if (a) return r(a); + binSearch(e, t, n, (e, t) => { + if (e) return r(e); + r(null, t); + }); + }); + }; + }, + 12623: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s, + u, + b, + l, + h, + p, + x, + m, + y, + g, + v, + w, + _, + k, + B, + N, + P, + O, + I = r(98188).Buffer, + L = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + C = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + D = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + L(t, e, r); + return C(t, e), t; + }, + j = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + U = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + z = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const W = z(r(87334)), + H = r(52426), + q = r(89539), + V = z(r(74933)), + G = z(r(50800)), + Y = r(65205), + J = D(r(98539)), + X = z(r(20854)), + { BUFFER_EMPTY: Q, BUFFER_256_ZERO: $ } = H.utils, + putInTrie = (e, t, r) => q.promisify(e.put.bind(e))(t, r), + sortByPrice = (e, t, r) => + H.Quantity.from(e[t].gasPrice) > H.Quantity.from(e[r].gasPrice); + class Miner extends G.default.Typed { + constructor(e, t, r, L, C) { + super(), + a.set(this, 0n), + n.set(this, new Set()), + o.set(this, void 0), + c.set(this, !1), + d.set(this, !1), + s.set(this, void 0), + u.set(this, void 0), + b.set(this, void 0), + l.set(this, void 0), + h.set(this, void 0), + p.set(this, void 0), + x.set(this, void 0), + m.set(this, void 0), + y.set(this, void 0), + g.set(this, void 0), + v.set(this, new H.utils.Heap(sortByPrice)), + w.set(this, async (e, t = -1, r = !1) => { + const { block: a, transactions: n } = await U(this, _).call( + this, + e, + t, + r + ); + if ( + U(this, o) && + (U(this, P).call(this), + j(this, o, !1), + !r && U(this, v).length > 0) + ) { + const e = U(this, g).call(this, a); + await U(this, w).call(this, e, U(this, h) ? 1 : -1); + } + return n; + }), + _.set(this, async (e, t, r) => { + let n; + const { pending: o, inProgress: d } = U(this, b), + s = U(this, l); + let u = !0; + const w = U(this, v), + _ = U(this, l).legacyInstamine; + let P; + do { + (u = !1), j(this, c, !0), (P = []); + const b = new V.default(null, null), + l = new V.default(null, null); + if (0 === t) { + await U(this, x).call(this), await U(this, m).call(this); + const t = e.finalize( + b.root, + l.root, + $, + U(this, p).stateManager._trie.root, + Q, + s.extraData, + [] + ); + return ( + this.emit("block", t), + U(this, N).call(this), + { block: t.block, transactions: [] } + ); + } + let v = 0, + L = s.blockGasLimit.toBigInt(), + C = 0n; + const D = I.allocUnsafe(256).fill(0), + z = []; + let q; + for (await U(this, x).call(this); (q = w.peek()); ) { + const r = H.Data.from(q.from).toString(); + if (q.calculateIntrinsicGas() > L) { + (q.locked = !1), U(this, B).call(this, r); + continue; + } + j(this, a, H.Quantity.from(q.gasPrice).toBigInt()), + await U(this, x).call(this); + const n = await U(this, k).call(this, q, e, r, o); + if (null !== n) { + const e = H.Quantity.from( + n.gasUsed.toArrayLike(I) + ).toBigInt(); + if (L >= e) { + await U(this, m).call(this), + (P[v] = q), + (L -= e), + (C += e); + const a = Y.encode(v); + z.push(putInTrie(b, a, q.serialize())); + const c = q.fillFromResult(n, C); + z.push(putInTrie(l, a, c)); + const s = n.bloom.bitvector; + for (let e = 0; e < 256; e++) D[e] |= s[e]; + v++; + const h = o.get(r); + if ( + ((u = h.removeBest()), + d.add(q), + q.once("finalized").then(() => { + d.delete(q); + }), + L <= W.default.TRANSACTION_GAS || v === t) + ) { + u = u ? X.default(w, h) : U(this, B).call(this, r); + break; + } + u = u ? X.default(w, h) : U(this, B).call(this, r); + } else + await U(this, y).call(this), + (q.locked = !1), + (u = w.removeBest()); + } else await U(this, y).call(this); + } + await Promise.all(z), await U(this, m).call(this); + const G = e.finalize( + b.root, + l.root, + D, + U(this, p).stateManager._trie.root, + 0n === C ? Q : H.Quantity.from(C).toBuffer(), + s.extraData, + P + ); + n = G.block; + const J = this.emit("block", G); + if ((!0 === _ && (await J), r)) { + j(this, a, 0n), U(this, N).call(this); + break; + } + j(this, a, 0n), + U(this, O).call(this), + 0 !== w.length + ? ((t = U(this, h) ? 1 : -1), + (e = U(this, g).call(this, n))) + : U(this, N).call(this); + } while (u); + return { block: n, transactions: P }; + }), + k.set(this, async (e, t, r, a) => { + try { + return await U(this, p).runTx({ tx: e, block: t }); + } catch (t) { + const n = t.message, + o = a.get(r); + o.removeBest() + ? X.default(U(this, v), o) + : U(this, B).call(this, r); + const c = { + execResult: { + runState: { programCounter: 0 }, + exceptionError: { error: n }, + returnValue: Q + } + }; + return ( + e.finalize( + "rejected", + new J.default( + e.hash(), + c, + J.RETURN_TYPES.TRANSACTION_HASH + ) + ), + null + ); + } + }), + B.set( + this, + e => (U(this, n).delete(e), U(this, v).removeBest()) + ), + N.set(this, () => { + U(this, n).clear(), U(this, v).clear(), j(this, c, !1); + }), + P.set(this, () => { + const { pending: e } = U(this, b), + t = U(this, n), + r = U(this, v); + for (let a of e) { + const e = a[1].peek(); + if (e && !e.locked) { + const a = H.Data.from(e.from).toString(); + t.add(a), r.push(e), (e.locked = !0); + } + } + }), + O.set(this, () => { + const { pending: e } = U(this, b), + t = U(this, n), + r = U(this, v); + for (let n of e) { + const e = n[1].peek(); + if (e && !e.locked) { + const n = H.Quantity.from(e.gasPrice).toBigInt(); + if (U(this, a) > n) continue; + const o = H.Data.from(e.from).toString(); + if (t.has(o)) continue; + t.add(o), r.push(e), (e.locked = !0); + } + } + }); + const D = L.stateManager; + j(this, p, L), + j(this, l, e), + j(this, b, t), + j(this, h, r), + j(this, x, q.promisify(D.checkpoint.bind(D))), + j(this, m, q.promisify(D.commit.bind(D))), + j(this, y, q.promisify(D.revert.bind(D))), + j(this, g, C), + U(this, v).init([]); + } + async pause() { + U(this, d) || + (j(this, d, !0), + j( + this, + s, + new Promise(e => { + j(this, u, e); + }) + )), + U(this, c) && (await this.once("idle")); + } + resume() { + U(this, d) && (j(this, d, !1), U(this, u).call(this)); + } + async mine(e, t = -1, r = !1) { + if ((U(this, d) && (await U(this, s)), U(this, c))) + return j(this, o, !0), void U(this, O).call(this); + { + U(this, P).call(this); + const a = await U(this, w).call(this, e, t, r); + return this.emit("idle"), a; + } + } + } + (t.default = Miner), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()), + (s = new WeakMap()), + (u = new WeakMap()), + (b = new WeakMap()), + (l = new WeakMap()), + (h = new WeakMap()), + (p = new WeakMap()), + (x = new WeakMap()), + (m = new WeakMap()), + (y = new WeakMap()), + (g = new WeakMap()), + (v = new WeakMap()), + (w = new WeakMap()), + (_ = new WeakMap()), + (k = new WeakMap()), + (B = new WeakMap()), + (N = new WeakMap()), + (P = new WeakMap()), + (O = new WeakMap()); + }, + 20854: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function replaceFromHeap(e, t) { + const r = t.peek(); + return r + ? (e.replaceBest(r), (r.locked = !0), !0) + : e.removeBest(); + }); + }, + 96613: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.ChainOptions = void 0); + const a = r(41071); + t.ChainOptions = { + allowUnlimitedContractSize: { + normalize: a.normalize, + default: () => !1, + legacyName: "allowUnlimitedContractSize" + }, + asyncRequestProcessing: { + normalize: a.normalize, + default: () => !0, + legacyName: "asyncRequestProcessing" + }, + chainId: { + normalize: a.normalize, + default: () => 1337, + legacyName: "chainId" + }, + networkId: { + normalize: a.normalize, + default: () => Date.now(), + legacyName: "network_id" + }, + time: { normalize: a.normalize, legacyName: "time" }, + hardfork: { + normalize: a.normalize, + default: () => "muirGlacier", + legacyName: "hardfork" + }, + vmErrorsOnRPCResponse: { + normalize: a.normalize, + default: () => !1, + legacyName: "vmErrorsOnRPCResponse" + } + }; + }, + 34236: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.DatabaseOptions = void 0); + const a = r(41071); + t.DatabaseOptions = { + db: { normalize: a.normalize, legacyName: "db" }, + dbPath: { normalize: a.normalize, legacyName: "db_path" } + }; + }, + 41071: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.normalize = void 0); + t.normalize = e => e; + }, + 10876: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.EthereumOptionsConfig = t.ethereumDefaults = void 0); + const a = r(96613), + n = r(34236), + o = r(9541), + c = r(67899), + d = r(21885), + s = r(32297); + (t.ethereumDefaults = { + chain: a.ChainOptions, + database: n.DatabaseOptions, + logging: o.LoggingOptions, + miner: c.MinerOptions, + wallet: d.WalletOptions + }), + (t.EthereumOptionsConfig = new s.OptionsConfig(t.ethereumDefaults)); + }, + 9541: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.LoggingOptions = void 0); + const a = r(41071), + n = { log: () => {} }; + t.LoggingOptions = { + debug: { + normalize: a.normalize, + default: () => !1, + legacyName: "debug" + }, + logger: { + normalize: a.normalize, + default: () => n, + legacyName: "logger" + }, + verbose: { + normalize: a.normalize, + default: () => !1, + legacyName: "verbose" + } + }; + }, + 67899: function (e, t, r) { + "use strict"; + var a = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.MinerOptions = void 0); + const n = r(41071), + o = r(52426), + c = a(r(68246)); + t.MinerOptions = { + blockTime: { + normalize: n.normalize, + default: () => 0, + legacyName: "blockTime" + }, + gasPrice: { + normalize: o.Quantity.from, + default: () => o.Quantity.from(2e9), + legacyName: "gasPrice" + }, + blockGasLimit: { + normalize: o.Quantity.from, + default: () => o.Quantity.from(12e6), + legacyName: "gasLimit" + }, + defaultTransactionGasLimit: { + normalize: e => + "estimate" === e + ? o.utils.RPCQUANTITY_EMPTY + : o.Quantity.from(e), + default: () => o.Quantity.from(9e4) + }, + callGasLimit: { + normalize: o.Quantity.from, + default: () => o.Quantity.from(Number.MAX_SAFE_INTEGER), + legacyName: "callGasLimit" + }, + coinbase: { + normalize: e => ("number" == typeof e ? e : c.default.from(e)), + default: () => c.default.from(o.utils.ACCOUNT_ZERO) + }, + legacyInstamine: { + normalize: n.normalize, + default: () => !1, + legacyName: "legacyInstamine" + }, + extraData: { + normalize: e => { + const t = o.Data.from(e); + if (t.toBuffer().length > 32) + throw new Error( + `extra exceeds max length. ${t.toBuffer().length} > 32` + ); + return t; + }, + default: () => o.Data.from(o.utils.BUFFER_EMPTY) + } + }; + }, + 21885: function (e, t, r) { + "use strict"; + var a = r(98188).Buffer, + n = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.WalletOptions = void 0); + const o = r(41071), + c = n(r(36990)), + d = r(96874), + { alea: s } = c.default; + const u = (() => { + const e = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", + t = e.length; + return (r, a) => { + let n = ""; + for (let o = 0; o < r; o++) n += e[(a() * t) | 0]; + return n; + }; + })(); + t.WalletOptions = { + totalAccounts: { + normalize: o.normalize, + default: () => 10, + legacyName: "total_accounts" + }, + accounts: { normalize: o.normalize, legacyName: "accounts" }, + seed: { + normalize: o.normalize, + default: () => u(10, s()), + legacyName: "seed" + }, + mnemonic: { + normalize: o.normalize, + default: e => + d.entropyToMnemonic( + (function randomBytes(e, t) { + const r = a.allocUnsafe(e); + for (let a = 0; a < e; a++) r[a] = (255 * t()) | 0; + return r; + })(16, c.default(e.seed)) + ), + legacyName: "mnemonic" + }, + unlockedAccounts: { + normalize: o.normalize, + legacyName: "unlocked_accounts" + }, + secure: { + normalize: o.normalize, + default: () => !1, + legacyName: "secure" + }, + accountKeysPath: { + normalize: o.normalize, + legacyName: "account_keys_path" + }, + defaultBalance: { + normalize: o.normalize, + default: () => 100, + legacyName: "default_balance_ether" + }, + hdPath: { + normalize: o.normalize, + default: () => "m/44'/60'/0'/0/", + legacyName: "hd_path" + } + }; + }, + 56433: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s, + u, + b, + l = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + h = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + p = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const x = p(r(50800)), + m = p(r(44955)), + y = r(52426), + g = r(10876), + v = p(r(18688)), + w = r(52426), + _ = p(r(64845)), + k = w.utils.hasOwn; + class EthereumProvider extends x.default.Typed { + constructor(e = {}, t) { + super(), + a.set(this, void 0), + n.set(this, void 0), + o.set(this, void 0), + c.set(this, void 0), + (this.removeListener = this.off), + d.set(this, (e, t) => { + let r, a, n; + if ("string" == typeof e) + (r = e), + (a = t), + (n = this.request({ method: r, params: a })); + else { + if ("function" != typeof t) + throw new Error( + "No callback provided to provider's send function. As of web3 1.0, provider.send is no longer synchronous and must be passed a callback as its final argument." + ); + if (Array.isArray(e)) { + const r = t; + h(this, u) + .call(this, e) + .then(({ error: e, result: t }) => { + r(e, t); + }); + } else { + const r = t; + h(this, b) + .call(this, e) + .then(({ error: e, result: t }) => { + r(e, t); + }); + } + } + return n; + }), + s.set(this, (e, t) => { + const r = h(this, a); + r.logging.verbose && + r.logging.logger.log( + ` > ${e}: ${ + null == t + ? t + : JSON.stringify(t, null, 2) + .split("\n") + .join("\n > ") + }` + ); + }), + (this.disconnect = async () => { + await this.emit("disconnect"); + }), + u.set(this, e => + Promise.all(e.map(h(this, b))).then(e => { + let t = null; + const r = []; + return ( + e.forEach(({ error: e, result: a }, n) => { + r.push(a), + e && + (null == t && (t = new Error("Batch error:")), + (t.errors[n] = e)); + }), + { error: t, result: r } + ); + }) + ), + b.set(this, async e => { + const t = e.method, + r = e.params; + try { + const a = await this.request({ method: t, params: r }); + return { + error: null, + result: y.JsonRpcTypes.Response( + e.id, + JSON.parse(JSON.stringify(a)) + ) + }; + } catch (t) { + let r; + return ( + k(t, "result") && ((r = t.result), delete t.result), + { error: t, result: y.JsonRpcTypes.Error(e.id, t, r) } + ); + } + }); + const r = l(this, a, g.EthereumOptionsConfig.normalize(e)); + l(this, o, t); + const p = l(this, c, new _.default(r.wallet)); + l(this, n, new m.default(r, p, this)); + } + getOptions() { + return v.default(h(this, a)); + } + getInitialAccounts() { + const e = {}, + t = h(this, c), + r = h(this, c).unlockedAccounts; + return ( + t.initialAccounts.forEach(t => { + const a = t.address.toString(); + e[a] = { + secretKey: t.privateKey.toString(), + balance: t.balance.toBigInt(), + unlocked: r.has(a) + }; + }), + e + ); + } + send(e, t) { + return h(this, d).call(this, e, t); + } + sendAsync(e, t) { + h(this, d).call(this, e, t); + } + async request(e) { + const t = await this._requestRaw(e), + r = await t.value; + return JSON.parse(JSON.stringify(r)); + } + async _requestRaw({ method: e, params: t }) { + h(this, s).call(this, e, t); + const r = (await h(this, o).execute(h(this, n), e, t)).value; + r instanceof w.PromiEvent && + r.on("message", e => { + this.emit("message", e), + this.emit("data", { + jsonrpc: "2.0", + method: "eth_subscription", + params: e.data + }); + }); + return { + value: r.catch(e => { + throw ( + (h(this, a).chain.vmErrorsOnRPCResponse && + k(e, "result") && + (e.result = JSON.parse(JSON.stringify(e.result))), + e) + ); + }) + }; + } + } + (t.default = EthereumProvider), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()), + (s = new WeakMap()), + (u = new WeakMap()), + (b = new WeakMap()); + }, + 28583: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }); + const a = r(52426), + n = r(85761), + o = r(52426).utils.RPCQUANTITY_ZERO; + class Account { + constructor(e) { + (this.stateRoot = n.KECCAK256_RLP), + (this.codeHash = n.KECCAK256_NULL), + (this.address = e), + (this.balance = o), + (this.nonce = o); + } + static fromBuffer(e) { + const t = Object.create(Account.prototype), + r = n.rlp.decode(e); + return ( + (t.nonce = a.Quantity.from(r[0])), + (t.balance = a.Quantity.from(r[1])), + (t.stateRoot = r[2]), + (t.codeHash = r[3]), + t + ); + } + serialize() { + return n.rlp.encode([ + this.nonce.toBuffer(), + this.balance.toBuffer(), + this.stateRoot, + this.codeHash + ]); + } + } + t.default = Account; + }, + 68246: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }); + const a = r(52426); + class Address extends a.Data { + constructor(e, t = 20) { + super(e, t); + } + } + t.default = Address; + }, + 3078: function (e, t, r) { + "use strict"; + var a = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const n = r(65205), + o = r(52426), + c = a(r(68246)), + d = r(52426), + s = Symbol("raw"), + u = Symbol("logs"), + filterByTopic = (e, t) => + !(e.length > t.length) && + e.every((e, r) => { + if (null === e) return !0; + let a; + if (!Array.isArray(e)) + return t[r].equals(o.Data.from(e).toBuffer()); + if (0 === e.length) return !0; + a = e; + const n = t[r]; + return a.some(e => n.equals(o.Data.from(e).toBuffer())); + }); + class BlockLogs { + constructor(e) { + if (e) { + const t = n.decode(e); + this[s] = t; + } + } + static create(e) { + const t = Object.create(BlockLogs.prototype); + return (t[s] = [e, []]), t; + } + serialize() { + return n.encode(this[s]); + } + append(e, t, r) { + this[s][1].push([d.utils.BUFFER_ZERO, e, t, r[0], r[1], r[2]]); + } + get length() { + return this[s][1].length; + } + toJSON() { + return this[u]().toJSON(); + } + [u]() { + const e = this.blockNumber, + t = this[s], + r = t[1], + a = this.length, + n = o.Data.from(t[0]); + return { + toJSON: () => ({ + *[Symbol.iterator]() { + for (let t = 0; t < a; t++) + yield BlockLogs.logToJSON(r[t], o.Quantity.from(t), n, e); + } + }), + *[Symbol.iterator]() { + for (let t = 0; t < a; t++) { + const a = r[t], + c = a[3], + d = a[4]; + yield { + address: c, + topics: d, + toJSON: () => + BlockLogs.logToJSON(a, o.Quantity.from(t), n, e) + }; + } + } + }; + } + static logToJSON(e, t, r, a) { + const n = e[4], + s = e[5]; + return { + address: c.default.from(e[3]), + blockHash: r, + blockNumber: a, + data: Array.isArray(s) + ? s.map(e => o.Data.from(e, e.length)) + : o.Data.from(s, s.length), + logIndex: t, + removed: !e[0].equals(d.utils.BUFFER_ZERO), + topics: Array.isArray(n) + ? n.map(e => o.Data.from(e, 32)) + : o.Data.from(n, 32), + transactionHash: o.Data.from(e[2], 32), + transactionIndex: o.Quantity.from(e[1]) + }; + } + *filter(e, t) { + const r = this[u](); + if (0 !== e.length) + if (0 === t.length) + for (const t of r) + e.some(e => e.equals(t.address)) && (yield t.toJSON()); + else + for (const a of r) + e.some(e => e.equals(a.address)) && + filterByTopic(t, a.topics) && + (yield a.toJSON()); + else if (0 !== t.length) + for (const e of r) + filterByTopic(t, e.topics) && (yield e.toJSON()); + else yield* r.toJSON(); + } + } + t.default = BlockLogs; + }, + 87334: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = { + TRANSACTION_GAS: 21000n, + TRANSACTION_DATA_NON_ZERO_GAS: new Map([ + ["constantinople", 68n], + ["byzantium", 68n], + ["petersburg", 68n], + ["istanbul", 68n], + ["muirGlacier", 16n] + ]), + TRANSACTION_DATA_ZERO_GAS: 4n + }); + }, + 57898: function (e, t, r) { + "use strict"; + var a = r(98188).Buffer, + n = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.RuntimeBlock = t.Block = void 0); + const o = r(52426), + c = r(52426), + d = n(r(32605)), + s = r(65205), + u = n(r(9436)), + b = r(85761), + { BUFFER_EMPTY: l, RPCQUANTITY_ZERO: h } = c.utils; + function makeHeader(e) { + e[8]; + return { + parentHash: o.Data.from(e[0], 32), + sha3Uncles: o.Data.from(e[1], 32), + miner: o.Data.from(e[2], 20), + stateRoot: o.Data.from(e[3], 32), + transactionsRoot: o.Data.from(e[4], 32), + receiptsRoot: o.Data.from(e[5], 32), + logsBloom: o.Data.from(e[6], 256), + difficulty: o.Quantity.from(e[7], !1), + number: o.Quantity.from(e[8], !1), + gasLimit: o.Quantity.from(e[9], !1), + gasUsed: o.Quantity.from(e[10], !1), + timestamp: o.Quantity.from(e[11], !1), + extraData: o.Data.from(e[12]), + mixHash: o.Data.from(e[13], 32), + nonce: o.Data.from(e[14], 8) + }; + } + class Block { + constructor(e, t) { + if ( + ((this._transactions = null), (this._rawTransactions = null), e) + ) { + (this._common = t), (this._size = e.length); + const r = s.decode(e), + a = (this._raw = r[0]); + (this._rawTransactions = r[1]), (this.header = makeHeader(a)); + } + } + hash() { + return ( + this._hash || + (this._hash = o.Data.from( + d.default("keccak256").update(s.encode(this._raw)).digest(), + 32 + )) + ); + } + getTransactions() { + if (this._transactions) return this._transactions; + const e = this._common; + return (this._transactions = this._rawTransactions.map( + t => new u.default(t, e) + )); + } + toJSON(e = !1) { + const t = this.getTxFn(e); + let r, + a = this._transactions; + if (a) r = a.map(t); + else { + const e = this._common; + (a = this._transactions = []), + (r = this._rawTransactions.map(r => { + const n = new u.default(r, e); + return a.push(n), t(n); + })); + } + return { + hash: this.hash(), + ...this.header, + totalDifficulty: h, + size: o.Quantity.from(this._size), + transactions: r, + uncles: [] + }; + } + getTxFn(e = !1) { + return e ? e => e.toJSON(this) : e => o.Data.from(e.hash()); + } + } + t.Block = Block; + t.RuntimeBlock = class RuntimeBlock { + constructor(e, t, r, a, n) { + const o = n.toBuffer(); + this.header = { + parentHash: t.toBuffer(), + coinbase: r.toBuffer(), + number: e.toBuffer(), + gasLimit: 0 === a.length ? l : a, + timestamp: 0 === o.length ? l : o + }; + } + finalize(e, t, r, n, o, c, d) { + const { header: u } = this, + h = [ + u.parentHash, + b.KECCAK256_RLP_ARRAY, + u.coinbase, + n, + e, + t, + r, + l, + u.number, + u.gasLimit, + o, + u.timestamp, + c.toBuffer(), + a.allocUnsafe(32).fill(0), + a.allocUnsafe(8).fill(0) + ], + p = d.map(e => e.raw), + x = [h, p], + m = s.encode(x), + y = new Block(null, null); + return ( + (y._size = m.length), + (y._raw = h), + (y._rawTransactions = p), + (y._transactions = d), + (y.header = makeHeader(h)), + { block: y, serialized: m } + ); + } + }; + }, + 1169: (e, t) => { + "use strict"; + var r, a; + Object.defineProperty(t, "__esModule", { value: !0 }), + (function (e) { + (e.EARLIEST = "earliest"), + (e.LATEST = "latest"), + (e.PENDING = "pending"); + })(r || (r = {})), + (function (e) { + (e[(e.earliest = 0)] = "earliest"), + (e[(e.latest = 1)] = "latest"), + (e[(e.pending = 2)] = "pending"); + })(a || (a = {})), + (function (e) { + e.normalize = function normalize(t) { + if ("string" == typeof t) return e[t.toUpperCase()]; + switch (t) { + case a.earliest: + return e.EARLIEST; + case a.latest: + return e.LATEST; + case a.pending: + return e.PENDING; + } + }; + })(r || (r = {})), + (t.default = r); + }, + 23214: (e, t, r) => { + "use strict"; + var a = r(98188).Buffer; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.TraceDataFactory = void 0); + const n = r(52426), + { bufferToMinHexKey: o } = n.utils, + c = [ + "", + "00", + "0000", + "000000", + "00000000", + "0000000000", + "000000000000", + "00000000000000", + "0000000000000000", + "000000000000000000", + "00000000000000000000", + "0000000000000000000000", + "000000000000000000000000", + "00000000000000000000000000", + "0000000000000000000000000000", + "000000000000000000000000000000", + "00000000000000000000000000000000", + "0000000000000000000000000000000000", + "000000000000000000000000000000000000", + "00000000000000000000000000000000000000", + "0000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000000000000000" + ]; + (t.TraceDataFactory = () => { + const e = new Map(); + return { + from: t => { + const r = o(t), + n = e.get(r); + if (n) return n; + let d, s; + const u = { + toBuffer: () => { + if (d) return d; + const e = t.byteLength; + if (32 === e) d = t; + else { + const r = 32 - e; + (d = a.allocUnsafe(32).fill(0, 0, r)), t.copy(d, r, 0, e); + } + return d; + }, + toJSON: () => s || (s = `${c[32 - r.length / 2]}${r}`) + }; + return e.set(r, u), u; + } + }; + }), + (t.default = t.TraceDataFactory); + }, + 63547: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }); + class TraceStorageMap extends Map { + toJSON() { + const e = {}; + for (const [t, r] of this) e[t.toJSON()] = r; + return e; + } + } + t.default = TraceStorageMap; + }, + 3901: function (e, t, r) { + "use strict"; + var a, + n, + o = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + c = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + d = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const s = r(65205), + u = r(52426), + b = d(r(3078)), + l = r(52426), + h = [l.utils.RPCQUANTITY_ZERO, l.utils.RPCQUANTITY_ONE]; + class TransactionReceipt { + constructor(e) { + if ( + (a.set(this, void 0), + n.set(this, (e, t, r, n, o, d = null) => { + (this.raw = [e, t, r, n]), + (this.contractAddress = d), + c(this, a, o); + }), + e) + ) { + const t = s.decode(e); + o(this, n).call(this, t[0], t[1], t[2], t[3], t[4], t[5]); + } + } + static fromValues(e, t, r, a, c, d) { + const s = new TransactionReceipt(); + return o(s, n).call(s, e, t, r, a, d, c), s; + } + serialize(e) { + return e + ? s.encode([...this.raw, o(this, a), this.contractAddress]) + : s.encode(this.raw); + } + toJSON(e, t) { + const r = this.raw, + n = + 0 === this.contractAddress.length + ? null + : u.Data.from(this.contractAddress), + c = e.hash(), + d = e.header.number, + s = b.default.create(c.toBuffer()); + (s.blockNumber = d), + r[3].forEach(e => { + s.append(t._index, t.hash(), e); + }); + const l = [...s.toJSON()]; + return { + transactionHash: u.Data.from(t.hash()), + transactionIndex: u.Quantity.from(t._index), + blockNumber: d, + blockHash: c, + from: u.Data.from(t.from), + to: n ? null : u.Data.from(t.to), + cumulativeGasUsed: u.Quantity.from(r[1]), + gasUsed: u.Quantity.from(o(this, a)), + contractAddress: n, + logs: l, + logsBloom: u.Data.from(r[2], 256), + status: h[r[0][0]] + }; + } + } + (t.default = TransactionReceipt), + (a = new WeakMap()), + (n = new WeakMap()); + }, + 9436: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d = r(98188).Buffer, + s = r(34155), + u = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + b = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + l = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + u(t, e, r); + return b(t, e), t; + }, + h = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + p = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + x = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const m = l(r(98539)), + y = r(52426), + g = x(r(87334)), + v = r(27987), + w = l(r(85761)), + _ = x(r(69282)), + k = r(65205), + B = x(r(3901)), + N = x(r(68246)), + P = (1n << 64n) - 1n, + O = d.from([0]), + I = d.from([1]), + L = v.Transaction.prototype.sign, + fakeHash = function () { + return null != this._hash + ? this._hash + : v.FakeTransaction.prototype.hash.apply(this, arguments); + }; + function fixProps(e, t) { + e._originals = []; + ["nonce", "gasPrice", "gasLimit", "value"].forEach(t => + (function configZeroableField(e, t, r = 32) { + const a = e._fields.indexOf(t), + n = Object.getOwnPropertyDescriptor(e, t); + Object.defineProperty(e, t, { + set: o => { + n.set.call(e, o), + (o = w.toBuffer(o)), + _.default( + r >= o.length, + `The field ${t} must not have more ${r} bytes` + ), + (e._originals[a] = o); + }, + get: () => e._originals[a] + }); + })(e, t, 32) + ); + const r = Object.getOwnPropertyDescriptor(e, "v"); + Object.defineProperty(e, "v", { + set: t => { + r.set.call(e, t); + const a = w.bufferToInt(e.v); + let n = Math.floor((a - 35) / 2); + n < 0 && (n = 0), (e._chainId = n || 0); + } + }); + } + class Transaction extends v.Transaction { + constructor(e, t, r = Transaction.types.none) { + let u; + super(void 0, { common: t }), + (this.locked = !1), + a.set(this, void 0), + n.set(this, void 0), + o.set(this, void 0), + c.set(this, void 0), + (this.execException = null), + (this.toJSON = Transaction.prototype.toJSON.bind(this)), + (this.type = r), + fixProps(this), + (function initData(e, t) { + if (t) { + let r; + if ("string" == typeof t) + r = k.decode(y.Data.from(t).toBuffer()); + else if (d.isBuffer(t)) r = k.decode(t); + else if ("Buffer" === t.type) { + const e = t.data, + a = e.length, + n = d.allocUnsafe(a); + for (let t = 0; t < a; t++) n[t] = e[t]; + r = k.decode(n); + } else { + if (!Array.isArray(t)) { + if ("object" == typeof t) { + const r = Object.keys(t); + return ( + e._fields.forEach(a => { + -1 !== r.indexOf(a) && (e[a] = t[a]), + "gasLimit" === a + ? -1 !== r.indexOf("gas") && (e.gas = t.gas) + : "data" === a && + -1 !== r.indexOf("input") && + (e.input = t.input); + }), + void ( + !e._chainId && + t && + null != t.chainId && + (e.raw[e._fields.indexOf("v")] = e._chainId = + t.chainId || 0) + ) + ); + } + throw new Error("invalid data"); + } + r = t; + } + if ( + (r.length === e._fields.length + 5 && + ((e._from = r.pop()), + (e.type = r.pop()[0]), + (e._index = r.pop()), + (e._blockNum = r.pop()), + (e._blockHash = r.pop())), + r.length > e._fields.length) + ) + throw new Error("wrong number of fields in data"); + r.forEach((t, r) => { + e[e._fields[r]] = w.toBuffer(t); + }); + } + })(this, e), + this.isFake() && + (function makeFake(e, t) { + e.isFake() && + (Object.defineProperty(e, "from", { + enumerable: !0, + configurable: !0, + get: e.getSenderAddress.bind(e), + set: t => { + e._from = t ? w.toBuffer(t) : null; + } + }), + t && t.from && (e.from = t.from), + (e.hash = fakeHash)); + })(this, e), + h( + this, + c, + new Promise(e => { + u = (...t) => s.nextTick(e, ...t); + }) + ), + h(this, o, u); + } + static get types() { + return { none: 0, signed: 1, fake: 2 }; + } + cost() { + return ( + y.Quantity.from(this.gasPrice).toBigInt() * + y.Quantity.from(this.gasLimit).toBigInt() + + y.Quantity.from(this.value).toBigInt() + ); + } + once(e) { + return p(this, c); + } + finalize(e, t = null) { + p(this, o).call(this, { status: e, error: t }); + } + static calculateIntrinsicGas(e, t) { + let r = g.default.TRANSACTION_GAS; + if (e) { + const a = e.byteLength; + if (a > 0) { + const n = g.default.TRANSACTION_DATA_NON_ZERO_GAS.get(t), + o = g.default.TRANSACTION_DATA_ZERO_GAS; + let c = 0n; + for (const t of e) 0 !== t && c++; + if ((P - r) / n < c) return -1n; + r += c * n; + const d = BigInt(a) - c; + if ((P - r) / o < d) return -1n; + r += d * o; + } + } + return r; + } + calculateIntrinsicGas() { + return Transaction.calculateIntrinsicGas( + this.data, + this._common._hardfork + ); + } + static fromJSON(e, t, r) { + let a; + if (e.to) { + const t = y.Data.from(e.to).toBuffer(); + a = t.equals(y.utils.BUFFER_ZERO) ? y.utils.ACCOUNT_ZERO : t; + } + const n = e.data || e.input, + o = { + nonce: y.Data.from(e.nonce).toBuffer(), + from: y.Data.from(e.from).toBuffer(), + value: y.Quantity.from(e.value).toBuffer(), + gasLimit: y.Quantity.from(e.gas || e.gasLimit).toBuffer(), + gasPrice: y.Quantity.from(e.gasPrice).toBuffer(), + data: n ? y.Data.from(n).toBuffer() : null, + to: a, + v: y.Data.from(e.v).toBuffer(), + r: y.Data.from(e.r).toBuffer(), + s: y.Data.from(e.s).toBuffer() + }, + c = new Transaction(o, t, r); + return ( + (c._hash = e.hash ? y.Data.from(e.hash).toBuffer() : null), + (c._from = e.from ? y.Data.from(e.from).toBuffer() : null), + c + ); + } + encode() { + return { + hash: y.Data.from(this.hash()).toString(), + nonce: y.Quantity.from(this.nonce).toString() || "0x", + from: y.Data.from(this.from).toString(), + to: y.Data.from(this.to).toString(), + value: y.Quantity.from(this.value).toString(), + gas: y.Quantity.from(this.gasLimit).toString(), + gasPrice: y.Quantity.from(this.gasPrice).toString(), + data: this.data ? this.data.toString("hex") : null, + v: y.Quantity.from(this.v).toString(), + r: y.Quantity.from(this.r).toString(), + s: y.Quantity.from(this.s).toString(), + _type: this.type + }; + } + isFake() { + return ( + (this.type & Transaction.types.fake) === Transaction.types.fake + ); + } + isSigned() { + return ( + (this.type & Transaction.types.signed) === + Transaction.types.signed + ); + } + validateNonce(e) { + let t; + return ( + (t = + this.isSigned() && 0 === this.nonce.length + ? y.utils.BUFFER_ZERO + : this.nonce), + t.equals(e) + ); + } + sign(e) { + return (this.type |= Transaction.types.signed), L.call(this, e); + } + toJSON(e) { + let t, r; + return ( + e + ? ((t = e.hash()), (r = e.header.number)) + : ((t = this._blockHash + ? y.Data.from(this._blockHash, 32) + : null), + (r = this._blockNum + ? y.Quantity.from(this._blockNum) + : null)), + { + hash: y.Data.from(this.hash(), 32), + nonce: y.Quantity.from(this.nonce), + blockHash: t || null, + blockNumber: r || null, + transactionIndex: this._index + ? y.Quantity.from(this._index) + : null, + from: N.default.from(this.from), + to: 0 === this.to.length ? null : N.default.from(this.to), + value: y.Quantity.from(this.value), + gas: y.Quantity.from(this.gasLimit), + gasPrice: y.Quantity.from(this.gasPrice), + input: y.Data.from(this.data), + v: y.Quantity.from(this.v), + r: y.Quantity.from(this.r), + s: y.Quantity.from(this.s) + } + ); + } + fillFromResult(e, t) { + const r = e.execResult; + let o; + r.exceptionError + ? ((o = O), + (this.execException = new m.default( + this.hash(), + e, + m.RETURN_TYPES.TRANSACTION_HASH + ))) + : (o = I); + return h( + this, + a, + B.default.fromValues( + o, + y.Quantity.from(t).toBuffer(), + e.bloom.bitvector, + h(this, n, r.logs || []), + e.createdAddress, + e.gasUsed.toArrayLike(d) + ) + ).serialize(!1); + } + getReceipt() { + return p(this, a); + } + getLogs() { + return p(this, n); + } + } + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (t.default = Transaction); + }, + 87454: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s, + u = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, a) { + void 0 === a && (a = r), + Object.defineProperty(e, a, { + enumerable: !0, + get: function () { + return t[r]; + } + }); + } + : function (e, t, r, a) { + void 0 === a && (a = r), (e[a] = t[r]); + }), + b = + (this && this.__setModuleDefault) || + (Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t + }); + } + : function (e, t) { + e.default = t; + }), + l = + (this && this.__importStar) || + function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + u(t, e, r); + return b(t, e), t; + }, + h = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + p = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + x = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const m = x(r(50800)), + y = r(52426), + g = r(52426), + v = r(95768), + w = l(r(4388)); + function byNonce(e, t, r) { + return ( + (g.Quantity.from(e[r].nonce).toBigInt() || 0n) > + (g.Quantity.from(e[t].nonce).toBigInt() || 0n) + ); + } + class TransactionPool extends m.default.Typed { + constructor(e, t) { + super(), + a.set(this, void 0), + n.set(this, 10n), + o.set(this, void 0), + (this.executables = { + inProgress: new Set(), + pending: new Map() + }), + c.set(this, new Map()), + d.set(this, new Map()), + (this.drain = () => { + this.emit("drain"); + }), + s.set(this, e => { + if (g.Quantity.from(e.gasLimit) > p(this, a).blockGasLimit) + return new w.default( + v.GAS_LIMIT, + w.ErrorCodes.INVALID_INPUT + ); + const t = e.calculateIntrinsicGas(); + return -1n === t || g.Quantity.from(e.gasLimit).toBigInt() < t + ? new w.default( + v.INTRINSIC_GAS_TOO_LOW, + w.ErrorCodes.INVALID_INPUT + ) + : null; + }), + h(this, o, t), + h(this, a, e); + } + async prepareTransaction(e, t) { + let r; + if (((r = p(this, s).call(this, e)), null != r)) throw r; + const a = g.Data.from(e.from); + let u; + if ( + (null == t || 0 !== e.nonce.length) && + ((u = g.Quantity.from(e.nonce).toBigInt() || 0n), u < 0n) + ) + throw new w.default( + v.NONCE_TOO_LOW, + w.ErrorCodes.INVALID_INPUT + ); + const b = a.toString(); + let l = p(this, d).get(b); + l && (await l); + let h = 0n; + const x = p(this, c), + m = x.get(b); + let _ = !1; + const k = this.executables.pending; + let B, + N = k.get(b); + if (N && (B = N.length)) { + const r = N.array, + a = p(this, n), + o = g.Quantity.from(e.gasPrice).toBigInt(); + for (let t = 0; t < B; t++) { + const n = r[t], + c = g.Quantity.from(n.nonce).toBigInt(); + if (c === u) { + const c = g.Quantity.from(n.gasPrice).toBigInt(), + d = c + (c * a) / 100n; + if (n.locked || !(o > d)) + throw new w.default( + "replacement transaction underpriced", + w.ErrorCodes.TRANSACTION_REJECTED + ); + (_ = !0), + (r[t] = e), + n.finalize( + "rejected", + new w.default( + "Transaction replaced by better transaction", + w.ErrorCodes.TRANSACTION_REJECTED + ) + ); + } + c > h && (h = c); + } + t && void 0 === u + ? ((u = h + 1n), + (e.nonce = g.Quantity.from(u).toBuffer()), + (_ = !0), + (h = u)) + : u === h + 1n && ((_ = !0), (h = u)); + } else { + l || + ((l = p(this, o).accounts.getNonce(a)), + p(this, d).set(b, l), + l.then(() => { + p(this, d).delete(b); + })); + const r = await l, + n = r ? r.toBigInt() : 0n; + if (t && void 0 === u) + (u = n || 0n), + (h = u), + (_ = !0), + (e.nonce = g.Quantity.from(u).toBuffer()); + else { + if (u < n) + throw new Error( + `the tx doesn't have the correct nonce. account has nonce of: ${n} tx has nonce of: ${u}` + ); + u === n && (_ = !0); + } + } + if ((t && e.sign(t.toBuffer()), _)) { + if ( + (N + ? N.push(e) + : ((N = y.utils.Heap.from(e, byNonce)), k.set(b, N)), + m) + ) { + let e = u + 1n; + for (;;) { + const t = m.peek(); + if ((g.Quantity.from(t.nonce).toBigInt() || 0n) !== e) + break; + if ((N.push(t), !m.removeBest())) { + x.delete(b); + break; + } + e += 1n; + } + } + return !0; + } + return ( + m ? m.push(e) : x.set(b, y.utils.Heap.from(e, byNonce)), !1 + ); + } + clear() { + p(this, c).clear(), + p(this, d).clear(), + this.executables.pending.clear(); + } + find(e) { + const { pending: t, inProgress: r } = this.executables; + for (let [t, r] of p(this, c)) { + if (void 0 === r) continue; + const t = r.array; + for (let a = 0; a < r.length; a++) { + const r = t[a]; + if (r.hash().equals(e)) return r; + } + } + for (let [r, a] of t) { + const t = a.array; + for (let r = 0; r < a.length; r++) { + const a = t[r]; + if (a.hash().equals(e)) return a; + } + } + for (let t of r) if (t.hash().equals(e)) return t; + return null; + } + } + (t.default = TransactionPool), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()), + (s = new WeakMap()); + }, + 77690: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.FilterTypes = void 0), + (function (e) { + (e[(e.log = 0)] = "log"), + (e[(e.block = 1)] = "block"), + (e[(e.pendingTransaction = 2)] = "pendingTransaction"); + })(t.FilterTypes || (t.FilterTypes = {})); + }, + 64845: function (e, t, r) { + "use strict"; + var a, + n, + o, + c, + d, + s = r(98188).Buffer, + u = + (this && this.__classPrivateFieldSet) || + function (e, t, r) { + if (!t.has(e)) + throw new TypeError( + "attempted to set private field on non-instance" + ); + return t.set(e, r), r; + }, + b = + (this && this.__classPrivateFieldGet) || + function (e, t) { + if (!t.has(e)) + throw new TypeError( + "attempted to get private field on non-instance" + ); + return t.get(e); + }, + l = + (this && this.__importDefault) || + function (e) { + return e && e.__esModule ? e : { default: e }; + }; + Object.defineProperty(t, "__esModule", { value: !0 }); + const h = r(52426), + p = r(52426), + x = l(r(68246)), + m = r(85761), + y = l(r(28583)), + g = l(r(72747)), + v = r(96874), + w = l(r(88283)), + _ = r(36990), + k = l(r(55835)), + B = l(r(32605)), + N = r(12993), + P = { dklen: 32, n: 1024, p: 8, r: 1 }, + O = "aes-128-ctr", + I = h.utils.WEI, + scrypt = (...e) => + new Promise((t, r) => { + k.default.scrypt.call(k.default, ...e, (e, a) => { + if (!e) return t(a); + r(e); + }); + }), + uncompressedPublicKeyToAddress = e => { + const t = g.default.publicKeyConvert(e, !1).slice(1), + r = B.default("keccak256"); + return r._state.absorb(t), x.default.from(r.digest().slice(-20)); + }, + asUUID = e => + `${e.toString("hex", 0, 4)}-${e.toString( + "hex", + 4, + 6 + )}-${e.toString("hex", 6, 8)}-${e.toString( + "hex", + 8, + 10 + )}-${e.toString("hex", 10)}`; + class Wallet { + constructor(e) { + (this.knownAccounts = new Set()), + (this.encryptedKeyFiles = new Map()), + (this.unlockedAccounts = new Map()), + (this.lockTimers = new Map()), + a.set(this, void 0), + n.set(this, 0n), + o.set(this, e => { + const t = s.allocUnsafe(e), + r = u(this, n, b(this, n) + 1n), + a = _.alea(r.toString()); + for (let r = 0; r < e; r++) t[r] = (255 * a()) | 0; + return t; + }), + c.set(this, e => { + const t = e.defaultBalance.toString().split(".", 2), + r = BigInt(t[0]), + n = t[1] || "0", + o = BigInt(n), + c = 10n ** BigInt(n.length), + d = I * r + o * (I / c), + s = p.Quantity.from(d); + let u, + l, + h = e.accounts; + if (h && 0 !== (l = h.length)) { + const t = b(this, a), + r = e.hdPath; + u = Array(l); + for (let e = 0; e < l; e++) { + const a = h[e], + n = a.secretKey; + let o, c; + if (n) { + o = p.Data.from(n); + (u[e] = Wallet.createAccountFromPrivateKey( + o + )).balance = p.Quantity.from(a.balance); + } else { + const n = t.derive(r + e); + (c = uncompressedPublicKeyToAddress(n.publicKey)), + (o = p.Data.from(n.privateKey)), + (u[e] = Wallet.createAccount( + p.Quantity.from(a.balance), + o, + c + )); + } + } + } else { + const t = e.totalAccounts; + if (!t) + throw new Error( + "Cannot initialize chain: either options.accounts or options.total_accounts must be specified" + ); + { + u = Array(t); + const r = e.hdPath, + n = b(this, a); + for (let e = 0; e < t; e++) { + const t = n.derive(r + e), + a = uncompressedPublicKeyToAddress(t.publicKey), + o = p.Data.from(t.privateKey); + u[e] = Wallet.createAccount(s, o, a); + } + } + } + return u; + }), + d.set( + this, + e => ( + this.lockTimers.delete(e), + this.unlockedAccounts.delete(e), + !0 + ) + ), + u( + this, + a, + w.default.fromMasterSeed( + v.mnemonicToSeedSync(e.mnemonic, null) + ) + ); + const t = (this.initialAccounts = b(this, c).call(this, e)), + r = t.length, + l = this.knownAccounts, + h = this.unlockedAccounts, + x = e.unlockedAccounts; + if (x) { + const e = x.length; + for (let a = 0; a < e; a++) { + let e, + n = x[a]; + switch (typeof n) { + case "string": + const a = n.toLowerCase(); + if (0 === a.indexOf("0x")) { + e = a; + break; + } + { + const e = n - 0; + if (!Number.isSafeInteger(e)) + throw new Error( + "Invalid value in unlocked_accounts: " + n + ); + n = e; + } + case "number": + const o = t[n]; + if (null == o) + throw new Error( + `Account at index ${n} not found. Max index available is ${ + r - 1 + }.` + ); + e = o.address.toString().toLowerCase(); + break; + default: + throw new Error( + "Invalid value specified in unlocked_accounts" + ); + } + h.has(e) || h.set(e, null); + } + } + const m = (this.addresses = Array(r)); + for (let a = 0; a < r; a++) { + const r = t[a], + n = r.address.toString(); + (m[a] = n), + l.add(n), + (e.secure && !h.has(n)) || h.set(n, r.privateKey); + } + if (null != e.accountKeysPath) { + const t = { addresses: {}, private_keys: {} }; + h.forEach((e, r) => { + (t.addresses[r] = r), (t.private_keys[r] = e); + }), + N.writeFileSync(e.accountKeysPath, JSON.stringify(t)); + } + } + async encrypt(e, t) { + const r = b(this, o).call(this, 64), + a = r.slice(0, 32), + n = r.slice(32, 48), + c = r.slice(48), + d = await scrypt(t, a, P.dklen, { ...P, N: P.n }), + u = k.default.createCipheriv(O, d.slice(0, 16), n), + l = s.concat([u.update(e.toBuffer()), u.final()]), + h = B.default("keccak256") + .update(s.concat([d.slice(16, 32), l])) + .digest(); + return { + crypto: { + cipher: O, + ciphertext: p.Data.from(l), + cipherparams: { iv: p.Data.from(n) }, + kdf: "scrypt", + kdfParams: { ...P, salt: p.Data.from(a) }, + mac: p.Data.from(h) + }, + id: asUUID(c), + version: 3 + }; + } + async decrypt(e, t) { + const r = e.crypto; + if (r.cipher !== O) + throw new Error(`keyfile cypher must be "${O}"`); + if ("scrypt" !== r.kdf) + throw new Error('keyfile kdf must be "script"'); + const a = r.kdfParams, + n = a.salt, + o = r.mac, + c = r.ciphertext.toBuffer(); + let d, u; + if (null != t) + try { + (d = await scrypt(t, n.toBuffer(), a.dklen, { + ...a, + N: a.n + })), + (u = B.default("keccak256") + .update(s.concat([d.slice(16, 32), c])) + .digest()); + } catch { + u = null; + } + if (!u || !o.toBuffer().equals(u)) + throw new Error("could not decrypt key with given password"); + return k.default + .createDecipheriv( + r.cipher, + d.slice(0, 16), + r.cipherparams.iv.toBuffer() + ) + .update(c); + } + static createAccount(e, t, r) { + const a = new y.default(r); + return (a.privateKey = t), (a.balance = e), a; + } + static createAccountFromPrivateKey(e) { + const t = x.default.from(m.privateToAddress(e.toBuffer())), + r = new y.default(t); + return (r.privateKey = e), r; + } + createRandomAccount(e) { + const t = s.concat([s.from(e), b(this, o).call(this, 64)]), + r = w.default.fromMasterSeed(t), + a = uncompressedPublicKeyToAddress(r.publicKey), + n = p.Data.from(r.privateKey); + return Wallet.createAccount(h.utils.RPCQUANTITY_ZERO, n, a); + } + async unlockAccount(e, t, r) { + const a = this.encryptedKeyFiles.get(e); + if (null == a) return !1; + const n = await this.decrypt(a, t), + o = this.lockTimers.get(e); + o && clearTimeout(o); + const c = (1e3 * r) | 0; + if (c > 0) { + const t = setTimeout(b(this, d), c, e); + h.utils.unref(t), this.lockTimers.set(e, t); + } + return this.unlockedAccounts.set(e, p.Data.from(n)), !0; + } + async unlockUnknownAccount(e, t) { + if (this.unlockedAccounts.has(e)) return !1; + if (this.knownAccounts.has(e)) + throw new Error("cannot unlock known/personal account"); + const r = (1e3 * t) | 0; + if (r > 0) { + const t = setTimeout(b(this, d), r, e); + h.utils.unref(t), this.lockTimers.set(e, t); + } + return this.unlockedAccounts.set(e, null), !0; + } + lockAccount(e) { + return ( + !!this.unlockedAccounts.has(e) && + (clearTimeout(this.lockTimers.get(e)), b(this, d).call(this, e)) + ); + } + } + (t.default = Wallet), + (a = new WeakMap()), + (n = new WeakMap()), + (o = new WeakMap()), + (c = new WeakMap()), + (d = new WeakMap()); + }, + 65363: (e, t, r) => { + var a = r(34155); + function AbstractChainedBatch(e) { + (this._db = e), (this._operations = []), (this._written = !1); + } + (AbstractChainedBatch.prototype._serializeKey = function (e) { + return this._db._serializeKey(e); + }), + (AbstractChainedBatch.prototype._serializeValue = function (e) { + return this._db._serializeValue(e); + }), + (AbstractChainedBatch.prototype._checkWritten = function () { + if (this._written) + throw new Error("write() already called on this batch"); + }), + (AbstractChainedBatch.prototype.put = function (e, t) { + this._checkWritten(); + var r = this._db._checkKey(e, "key", this._db._isBuffer); + if (r) throw r; + return ( + (e = this._serializeKey(e)), + (t = this._serializeValue(t)), + "function" == typeof this._put + ? this._put(e, t) + : this._operations.push({ type: "put", key: e, value: t }), + this + ); + }), + (AbstractChainedBatch.prototype.del = function (e) { + this._checkWritten(); + var t = this._db._checkKey(e, "key", this._db._isBuffer); + if (t) throw t; + return ( + (e = this._serializeKey(e)), + "function" == typeof this._del + ? this._del(e) + : this._operations.push({ type: "del", key: e }), + this + ); + }), + (AbstractChainedBatch.prototype.clear = function () { + return ( + this._checkWritten(), + (this._operations = []), + "function" == typeof this._clear && this._clear(), + this + ); + }), + (AbstractChainedBatch.prototype.write = function (e, t) { + if ( + (this._checkWritten(), + "function" == typeof e && (t = e), + "function" != typeof t) + ) + throw new Error("write() requires a callback argument"); + return ( + "object" != typeof e && (e = {}), + (this._written = !0), + "function" == typeof this._write + ? this._write(t) + : "function" == typeof this._db._batch + ? this._db._batch(this._operations, e, t) + : void a.nextTick(t) + ); + }), + (e.exports = AbstractChainedBatch); + }, + 53308: (e, t, r) => { + var a = r(34155); + function AbstractIterator(e) { + (this.db = e), (this._ended = !1), (this._nexting = !1); + } + (AbstractIterator.prototype.next = function (e) { + var t = this; + if ("function" != typeof e) + throw new Error("next() requires a callback argument"); + return t._ended + ? e(new Error("cannot call next() after end()")) + : t._nexting + ? e( + new Error( + "cannot call next() before previous next() has completed" + ) + ) + : ((t._nexting = !0), + "function" == typeof t._next + ? t._next(function () { + (t._nexting = !1), e.apply(null, arguments); + }) + : void a.nextTick(function () { + (t._nexting = !1), e(); + })); + }), + (AbstractIterator.prototype.end = function (e) { + if ("function" != typeof e) + throw new Error("end() requires a callback argument"); + return this._ended + ? e(new Error("end() already called on iterator")) + : ((this._ended = !0), + "function" == typeof this._end + ? this._end(e) + : void a.nextTick(e)); + }), + (e.exports = AbstractIterator); + }, + 51122: (e, t, r) => { + var a = r(34155), + n = r(98188).Buffer, + o = r(18390), + c = r(53308), + d = r(65363); + function AbstractLevelDOWN(e) { + if (!arguments.length || void 0 === e) + throw new Error( + "constructor requires at least a location argument" + ); + if ("string" != typeof e) + throw new Error( + "constructor requires a location string argument" + ); + (this.location = e), (this.status = "new"); + } + (AbstractLevelDOWN.prototype.open = function (e, t) { + var r = this, + n = this.status; + if (("function" == typeof e && (t = e), "function" != typeof t)) + throw new Error("open() requires a callback argument"); + "object" != typeof e && (e = {}), + (e.createIfMissing = 0 != e.createIfMissing), + (e.errorIfExists = !!e.errorIfExists), + "function" == typeof this._open + ? ((this.status = "opening"), + this._open(e, function (e) { + if (e) return (r.status = n), t(e); + (r.status = "open"), t(); + })) + : ((this.status = "open"), a.nextTick(t)); + }), + (AbstractLevelDOWN.prototype.close = function (e) { + var t = this, + r = this.status; + if ("function" != typeof e) + throw new Error("close() requires a callback argument"); + "function" == typeof this._close + ? ((this.status = "closing"), + this._close(function (a) { + if (a) return (t.status = r), e(a); + (t.status = "closed"), e(); + })) + : ((this.status = "closed"), a.nextTick(e)); + }), + (AbstractLevelDOWN.prototype.get = function (e, t, r) { + var n; + if (("function" == typeof t && (r = t), "function" != typeof r)) + throw new Error("get() requires a callback argument"); + return (n = this._checkKey(e, "key")) + ? r(n) + : ((e = this._serializeKey(e)), + "object" != typeof t && (t = {}), + (t.asBuffer = 0 != t.asBuffer), + "function" == typeof this._get + ? this._get(e, t, r) + : void a.nextTick(function () { + r(new Error("NotFound")); + })); + }), + (AbstractLevelDOWN.prototype.put = function (e, t, r, n) { + var o; + if (("function" == typeof r && (n = r), "function" != typeof n)) + throw new Error("put() requires a callback argument"); + return (o = this._checkKey(e, "key")) + ? n(o) + : ((e = this._serializeKey(e)), + (t = this._serializeValue(t)), + "object" != typeof r && (r = {}), + "function" == typeof this._put + ? this._put(e, t, r, n) + : void a.nextTick(n)); + }), + (AbstractLevelDOWN.prototype.del = function (e, t, r) { + var n; + if (("function" == typeof t && (r = t), "function" != typeof r)) + throw new Error("del() requires a callback argument"); + return (n = this._checkKey(e, "key")) + ? r(n) + : ((e = this._serializeKey(e)), + "object" != typeof t && (t = {}), + "function" == typeof this._del + ? this._del(e, t, r) + : void a.nextTick(r)); + }), + (AbstractLevelDOWN.prototype.batch = function (e, t, r) { + if (!arguments.length) return this._chainedBatch(); + if ( + ("function" == typeof t && (r = t), + "function" == typeof e && (r = e), + "function" != typeof r) + ) + throw new Error("batch(array) requires a callback argument"); + if (!Array.isArray(e)) + return r(new Error("batch(array) requires an array argument")); + (t && "object" == typeof t) || (t = {}); + for (var n, o, c = 0, d = e.length; c < d; c++) + if ("object" == typeof (n = e[c])) { + if ((o = this._checkKey(n.type, "type"))) return r(o); + if ((o = this._checkKey(n.key, "key"))) return r(o); + } + if ("function" == typeof this._batch) return this._batch(e, t, r); + a.nextTick(r); + }), + (AbstractLevelDOWN.prototype.approximateSize = function (e, t, r) { + if ( + null == e || + null == t || + "function" == typeof e || + "function" == typeof t + ) + throw new Error( + "approximateSize() requires valid `start`, `end` and `callback` arguments" + ); + if ("function" != typeof r) + throw new Error( + "approximateSize() requires a callback argument" + ); + if ( + ((e = this._serializeKey(e)), + (t = this._serializeKey(t)), + "function" == typeof this._approximateSize) + ) + return this._approximateSize(e, t, r); + a.nextTick(function () { + r(null, 0); + }); + }), + (AbstractLevelDOWN.prototype._setupIteratorOptions = function (e) { + var t = this; + return ( + (e = o(e)), + ["start", "end", "gt", "gte", "lt", "lte"].forEach(function ( + r + ) { + e[r] && t._isBuffer(e[r]) && 0 === e[r].length && delete e[r]; + }), + (e.reverse = !!e.reverse), + (e.keys = 0 != e.keys), + (e.values = 0 != e.values), + (e.limit = "limit" in e ? e.limit : -1), + (e.keyAsBuffer = 0 != e.keyAsBuffer), + (e.valueAsBuffer = 0 != e.valueAsBuffer), + e + ); + }), + (AbstractLevelDOWN.prototype.iterator = function (e) { + return ( + "object" != typeof e && (e = {}), + (e = this._setupIteratorOptions(e)), + "function" == typeof this._iterator + ? this._iterator(e) + : new c(this) + ); + }), + (AbstractLevelDOWN.prototype._chainedBatch = function () { + return new d(this); + }), + (AbstractLevelDOWN.prototype._isBuffer = function (e) { + return n.isBuffer(e); + }), + (AbstractLevelDOWN.prototype._serializeKey = function (e) { + return this._isBuffer(e) ? e : String(e); + }), + (AbstractLevelDOWN.prototype._serializeValue = function (e) { + return null == e + ? "" + : this._isBuffer(e) || a.browser + ? e + : String(e); + }), + (AbstractLevelDOWN.prototype._checkKey = function (e, t) { + return null == e + ? new Error(t + " cannot be `null` or `undefined`") + : this._isBuffer(e) && 0 === e.length + ? new Error(t + " cannot be an empty Buffer") + : "" === String(e) + ? new Error(t + " cannot be an empty String") + : void 0; + }), + (e.exports = AbstractLevelDOWN); + }, + 13356: (e, t, r) => { + (t.AbstractLevelDOWN = r(51122)), + (t.AbstractIterator = r(53308)), + r(65363), + r(93004); + }, + 93004: (e, t, r) => { + var a = r(51122); + e.exports = function isLevelDOWN(e) { + return ( + !(!e || "object" != typeof e) && + Object.keys(a.prototype) + .filter(function (e) { + return "_" != e[0] && "approximateSize" != e; + }) + .every(function (t) { + return "function" == typeof e[t]; + }) + ); + }; + }, + 18390: e => { + e.exports = function extend() { + for (var e = {}, r = 0; r < arguments.length; r++) { + var a = arguments[r]; + for (var n in a) t.call(a, n) && (e[n] = a[n]); + } + return e; + }; + var t = Object.prototype.hasOwnProperty; + }, + 28319: (e, t, r) => { + "use strict"; + e.exports = r(1263); + }, + 1263: (e, t, r) => { + "use strict"; + var a, + n = r(17187).EventEmitter, + o = r(89539), + c = r(91661); + (e.exports = a = function AsyncEventEmitter() { + n.call(this); + }), + o.inherits(a, n), + (a.prototype.emit = function (e, t, r) { + var a = this, + n = a._events[e] || []; + return ( + r || "function" != typeof t || ((r = t), (t = void 0)), + ("newListener" !== e && "removeListener" !== e) || + ((t = { event: t, fn: r }), (r = void 0)), + (n = Array.isArray(n) ? n : [n]), + c( + n.slice(), + function (e, r) { + var n; + if (e.length < 2) { + try { + e.call(a, t); + } catch (e) { + n = e; + } + return r(n); + } + e.call(a, t, r); + }, + r + ), + a + ); + }), + (a.prototype.once = function (e, t) { + var r, + a = this; + if ("function" != typeof t) + throw new TypeError("listener must be a function"); + return ( + ((r = + t.length >= 2 + ? function (n, o) { + a.removeListener(e, r), t(n, o); + } + : function (n) { + a.removeListener(e, r), t(n); + }).listener = t), + a.on(e, r), + a + ); + }), + (a.prototype.first = function (e, t) { + var r = this._events[e] || []; + if ("function" != typeof t) + throw new TypeError("listener must be a function"); + return ( + Array.isArray(r) || (this._events[e] = r = [r]), + r.unshift(t), + this + ); + }), + (a.prototype.at = function (e, t, r) { + var a = this._events[e] || []; + if ("function" != typeof r) + throw new TypeError("listener must be a function"); + if ("number" != typeof t || t < 0) + throw new TypeError("index must be a non-negative integer"); + return ( + Array.isArray(a) || (this._events[e] = a = [a]), + a.splice(t, 0, r), + this + ); + }), + (a.prototype.before = function (e, t, r) { + return this._beforeOrAfter(e, t, r); + }), + (a.prototype.after = function (e, t, r) { + return this._beforeOrAfter(e, t, r, "after"); + }), + (a.prototype._beforeOrAfter = function (e, t, r, a) { + var n, + o, + c = this._events[e] || [], + d = "after" === a ? 1 : 0; + if ("function" != typeof r) + throw new TypeError("listener must be a function"); + if ("function" != typeof t) + throw new TypeError("target must be a function"); + for ( + Array.isArray(c) || (this._events[e] = c = [c]), + o = c.length, + n = c.length; + n--; + + ) + if (c[n] === t) { + o = n + d; + break; + } + return c.splice(o, 0, r), this; + }); + }, + 68870: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function asyncify(e) { + return (0, n.default)(function (t, r) { + var n; + try { + n = e.apply(this, t); + } catch (e) { + return r(e); + } + (0, a.default)(n) && "function" == typeof n.then + ? n.then( + function (e) { + invokeCallback(r, null, e); + }, + function (e) { + invokeCallback(r, e.message ? e : new Error(e)); + } + ) + : r(null, n); + }); + }); + var a = _interopRequireDefault(r(68912)), + n = _interopRequireDefault(r(39089)), + o = _interopRequireDefault(r(31747)); + function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + } + function invokeCallback(e, t, r) { + try { + e(t, r); + } catch (e) { + (0, o.default)(rethrow, e); + } + } + function rethrow(e) { + throw e; + } + e.exports = t.default; + }, + 85808: function (e, t, r) { + e = r.nmd(e); + var a = r(34155); + !(function (t) { + "use strict"; + function slice(e, t) { + t |= 0; + for ( + var r = Math.max(e.length - t, 0), a = Array(r), n = 0; + n < r; + n++ + ) + a[n] = e[t + n]; + return a; + } + var apply = function (e) { + var t = slice(arguments, 1); + return function () { + var r = slice(arguments); + return e.apply(null, t.concat(r)); + }; + }, + initialParams = function (e) { + return function () { + var t = slice(arguments), + r = t.pop(); + e.call(this, t, r); + }; + }; + function isObject(e) { + var t = typeof e; + return null != e && ("object" == t || "function" == t); + } + var n = "function" == typeof setImmediate && setImmediate, + o = "object" == typeof a && "function" == typeof a.nextTick; + function fallback(e) { + setTimeout(e, 0); + } + function wrap(e) { + return function (t) { + var r = slice(arguments, 1); + e(function () { + t.apply(null, r); + }); + }; + } + var c = wrap(n ? setImmediate : o ? a.nextTick : fallback); + function asyncify(e) { + return initialParams(function (t, r) { + var a; + try { + a = e.apply(this, t); + } catch (e) { + return r(e); + } + isObject(a) && "function" == typeof a.then + ? a.then( + function (e) { + invokeCallback(r, null, e); + }, + function (e) { + invokeCallback(r, e.message ? e : new Error(e)); + } + ) + : r(null, a); + }); + } + function invokeCallback(e, t, r) { + try { + e(t, r); + } catch (e) { + c(rethrow, e); + } + } + function rethrow(e) { + throw e; + } + var d = "function" == typeof Symbol; + function isAsync(e) { + return d && "AsyncFunction" === e[Symbol.toStringTag]; + } + function wrapAsync(e) { + return isAsync(e) ? asyncify(e) : e; + } + function applyEach$1(e) { + return function (t) { + var r = slice(arguments, 1), + a = initialParams(function (r, a) { + var n = this; + return e( + t, + function (e, t) { + wrapAsync(e).apply(n, r.concat(t)); + }, + a + ); + }); + return r.length ? a.apply(this, r) : a; + }; + } + var s = + "object" == typeof r.g && r.g && r.g.Object === Object && r.g, + u = + "object" == typeof self && + self && + self.Object === Object && + self, + b = s || u || Function("return this")(), + l = b.Symbol, + h = Object.prototype, + p = h.hasOwnProperty, + x = h.toString, + m = l ? l.toStringTag : void 0; + function getRawTag(e) { + var t = p.call(e, m), + r = e[m]; + try { + e[m] = void 0; + var a = !0; + } catch (e) {} + var n = x.call(e); + return a && (t ? (e[m] = r) : delete e[m]), n; + } + var y = Object.prototype.toString; + function objectToString(e) { + return y.call(e); + } + var g = "[object Null]", + v = "[object Undefined]", + w = l ? l.toStringTag : void 0; + function baseGetTag(e) { + return null == e + ? void 0 === e + ? v + : g + : w && w in Object(e) + ? getRawTag(e) + : objectToString(e); + } + var _ = "[object AsyncFunction]", + k = "[object Function]", + B = "[object GeneratorFunction]", + N = "[object Proxy]"; + function isFunction(e) { + if (!isObject(e)) return !1; + var t = baseGetTag(e); + return t == k || t == B || t == _ || t == N; + } + var P = 9007199254740991; + function isLength(e) { + return "number" == typeof e && e > -1 && e % 1 == 0 && e <= P; + } + function isArrayLike(e) { + return null != e && isLength(e.length) && !isFunction(e); + } + var O = {}; + function noop() {} + function once(e) { + return function () { + if (null !== e) { + var t = e; + (e = null), t.apply(this, arguments); + } + }; + } + var I = "function" == typeof Symbol && Symbol.iterator, + getIterator = function (e) { + return I && e[I] && e[I](); + }; + function baseTimes(e, t) { + for (var r = -1, a = Array(e); ++r < e; ) a[r] = t(r); + return a; + } + function isObjectLike(e) { + return null != e && "object" == typeof e; + } + var L = "[object Arguments]"; + function baseIsArguments(e) { + return isObjectLike(e) && baseGetTag(e) == L; + } + var C = Object.prototype, + D = C.hasOwnProperty, + j = C.propertyIsEnumerable, + U = baseIsArguments( + (function () { + return arguments; + })() + ) + ? baseIsArguments + : function (e) { + return ( + isObjectLike(e) && + D.call(e, "callee") && + !j.call(e, "callee") + ); + }, + z = Array.isArray; + function stubFalse() { + return !1; + } + var W = "object" == typeof t && t && !t.nodeType && t, + H = W && e && !e.nodeType && e, + q = H && H.exports === W ? b.Buffer : void 0, + V = (q ? q.isBuffer : void 0) || stubFalse, + G = 9007199254740991, + Y = /^(?:0|[1-9]\d*)$/; + function isIndex(e, t) { + var r = typeof e; + return ( + !!(t = null == t ? G : t) && + ("number" == r || ("symbol" != r && Y.test(e))) && + e > -1 && + e % 1 == 0 && + e < t + ); + } + var J = "[object Arguments]", + X = "[object Array]", + Q = "[object Boolean]", + $ = "[object Date]", + et = "[object Error]", + tt = "[object Function]", + rt = "[object Map]", + at = "[object Number]", + nt = "[object Object]", + it = "[object RegExp]", + ot = "[object Set]", + ct = "[object String]", + dt = "[object WeakMap]", + st = "[object ArrayBuffer]", + ut = "[object DataView]", + bt = "[object Float64Array]", + ht = "[object Int8Array]", + pt = "[object Int16Array]", + xt = "[object Int32Array]", + mt = "[object Uint8Array]", + yt = "[object Uint8ClampedArray]", + vt = "[object Uint16Array]", + wt = "[object Uint32Array]", + At = {}; + function baseIsTypedArray(e) { + return ( + isObjectLike(e) && isLength(e.length) && !!At[baseGetTag(e)] + ); + } + function baseUnary(e) { + return function (t) { + return e(t); + }; + } + (At["[object Float32Array]"] = At[bt] = At[ht] = At[pt] = At[ + xt + ] = At[mt] = At[yt] = At[vt] = At[wt] = !0), + (At[J] = At[X] = At[st] = At[Q] = At[ut] = At[$] = At[et] = At[ + tt + ] = At[rt] = At[at] = At[nt] = At[it] = At[ot] = At[ct] = At[ + dt + ] = !1); + var _t = "object" == typeof t && t && !t.nodeType && t, + Mt = _t && e && !e.nodeType && e, + kt = Mt && Mt.exports === _t && s.process, + Et = (function () { + try { + var e = Mt && Mt.require && Mt.require("util").types; + return e || (kt && kt.binding && kt.binding("util")); + } catch (e) {} + })(), + St = Et && Et.isTypedArray, + Bt = St ? baseUnary(St) : baseIsTypedArray, + Nt = Object.prototype.hasOwnProperty; + function arrayLikeKeys(e, t) { + var r = z(e), + a = !r && U(e), + n = !r && !a && V(e), + o = !r && !a && !n && Bt(e), + c = r || a || n || o, + d = c ? baseTimes(e.length, String) : [], + s = d.length; + for (var u in e) + (!t && !Nt.call(e, u)) || + (c && + ("length" == u || + (n && ("offset" == u || "parent" == u)) || + (o && + ("buffer" == u || + "byteLength" == u || + "byteOffset" == u)) || + isIndex(u, s))) || + d.push(u); + return d; + } + var Rt = Object.prototype; + function isPrototype(e) { + var t = e && e.constructor; + return e === (("function" == typeof t && t.prototype) || Rt); + } + function overArg(e, t) { + return function (r) { + return e(t(r)); + }; + } + var Tt = overArg(Object.keys, Object), + Pt = Object.prototype.hasOwnProperty; + function baseKeys(e) { + if (!isPrototype(e)) return Tt(e); + var t = []; + for (var r in Object(e)) + Pt.call(e, r) && "constructor" != r && t.push(r); + return t; + } + function keys(e) { + return isArrayLike(e) ? arrayLikeKeys(e) : baseKeys(e); + } + function createArrayIterator(e) { + var t = -1, + r = e.length; + return function next() { + return ++t < r ? { value: e[t], key: t } : null; + }; + } + function createES2015Iterator(e) { + var t = -1; + return function next() { + var r = e.next(); + return r.done ? null : (t++, { value: r.value, key: t }); + }; + } + function createObjectIterator(e) { + var t = keys(e), + r = -1, + a = t.length; + return function next() { + var n = t[++r]; + return r < a ? { value: e[n], key: n } : null; + }; + } + function iterator(e) { + if (isArrayLike(e)) return createArrayIterator(e); + var t = getIterator(e); + return t ? createES2015Iterator(t) : createObjectIterator(e); + } + function onlyOnce(e) { + return function () { + if (null === e) throw new Error("Callback was already called."); + var t = e; + (e = null), t.apply(this, arguments); + }; + } + function _eachOfLimit(e) { + return function (t, r, a) { + if (((a = once(a || noop)), e <= 0 || !t)) return a(null); + var n = iterator(t), + o = !1, + c = 0, + d = !1; + function iterateeCallback(e, t) { + if (((c -= 1), e)) (o = !0), a(e); + else { + if (t === O || (o && c <= 0)) return (o = !0), a(null); + d || replenish(); + } + } + function replenish() { + for (d = !0; c < e && !o; ) { + var t = n(); + if (null === t) return (o = !0), void (c <= 0 && a(null)); + (c += 1), r(t.value, t.key, onlyOnce(iterateeCallback)); + } + d = !1; + } + replenish(); + }; + } + function eachOfLimit(e, t, r, a) { + _eachOfLimit(t)(e, wrapAsync(r), a); + } + function doLimit(e, t) { + return function (r, a, n) { + return e(r, t, a, n); + }; + } + function eachOfArrayLike(e, t, r) { + r = once(r || noop); + var a = 0, + n = 0, + o = e.length; + function iteratorCallback(e, t) { + e ? r(e) : (++n !== o && t !== O) || r(null); + } + for (0 === o && r(null); a < o; a++) + t(e[a], a, onlyOnce(iteratorCallback)); + } + var Ot = doLimit(eachOfLimit, 1 / 0), + eachOf = function (e, t, r) { + (isArrayLike(e) ? eachOfArrayLike : Ot)(e, wrapAsync(t), r); + }; + function doParallel(e) { + return function (t, r, a) { + return e(eachOf, t, wrapAsync(r), a); + }; + } + function _asyncMap(e, t, r, a) { + (a = a || noop), (t = t || []); + var n = [], + o = 0, + c = wrapAsync(r); + e( + t, + function (e, t, r) { + var a = o++; + c(e, function (e, t) { + (n[a] = t), r(e); + }); + }, + function (e) { + a(e, n); + } + ); + } + var It = doParallel(_asyncMap), + Lt = applyEach$1(It); + function doParallelLimit(e) { + return function (t, r, a, n) { + return e(_eachOfLimit(r), t, wrapAsync(a), n); + }; + } + var Ct = doParallelLimit(_asyncMap), + Dt = doLimit(Ct, 1), + jt = applyEach$1(Dt); + function arrayEach(e, t) { + for ( + var r = -1, a = null == e ? 0 : e.length; + ++r < a && !1 !== t(e[r], r, e); + + ); + return e; + } + function createBaseFor(e) { + return function (t, r, a) { + for (var n = -1, o = Object(t), c = a(t), d = c.length; d--; ) { + var s = c[e ? d : ++n]; + if (!1 === r(o[s], s, o)) break; + } + return t; + }; + } + var Ft = createBaseFor(); + function baseForOwn(e, t) { + return e && Ft(e, t, keys); + } + function baseFindIndex(e, t, r, a) { + for (var n = e.length, o = r + (a ? 1 : -1); a ? o-- : ++o < n; ) + if (t(e[o], o, e)) return o; + return -1; + } + function baseIsNaN(e) { + return e != e; + } + function strictIndexOf(e, t, r) { + for (var a = r - 1, n = e.length; ++a < n; ) + if (e[a] === t) return a; + return -1; + } + function baseIndexOf(e, t, r) { + return t == t + ? strictIndexOf(e, t, r) + : baseFindIndex(e, baseIsNaN, r); + } + var auto = function (e, t, r) { + "function" == typeof t && ((r = t), (t = null)), + (r = once(r || noop)); + var a = keys(e).length; + if (!a) return r(null); + t || (t = a); + var n = {}, + o = 0, + c = !1, + d = Object.create(null), + s = [], + u = [], + b = {}; + function enqueueTask(e, t) { + s.push(function () { + runTask(e, t); + }); + } + function processQueue() { + if (0 === s.length && 0 === o) return r(null, n); + for (; s.length && o < t; ) s.shift()(); + } + function addListener(e, t) { + var r = d[e]; + r || (r = d[e] = []), r.push(t); + } + function taskComplete(e) { + arrayEach(d[e] || [], function (e) { + e(); + }), + processQueue(); + } + function runTask(e, t) { + if (!c) { + var a = onlyOnce(function (t, a) { + if ( + (o--, + arguments.length > 2 && (a = slice(arguments, 1)), + t) + ) { + var s = {}; + baseForOwn(n, function (e, t) { + s[t] = e; + }), + (s[e] = a), + (c = !0), + (d = Object.create(null)), + r(t, s); + } else (n[e] = a), taskComplete(e); + }); + o++; + var s = wrapAsync(t[t.length - 1]); + t.length > 1 ? s(n, a) : s(a); + } + } + function checkForDeadlocks() { + for (var e = 0; u.length; ) + e++, + arrayEach(getDependents(u.pop()), function (e) { + 0 == --b[e] && u.push(e); + }); + if (e !== a) + throw new Error( + "async.auto cannot execute tasks due to a recursive dependency" + ); + } + function getDependents(t) { + var r = []; + return ( + baseForOwn(e, function (e, a) { + z(e) && baseIndexOf(e, t, 0) >= 0 && r.push(a); + }), + r + ); + } + baseForOwn(e, function (t, r) { + if (!z(t)) return enqueueTask(r, [t]), void u.push(r); + var a = t.slice(0, t.length - 1), + n = a.length; + if (0 === n) return enqueueTask(r, t), void u.push(r); + (b[r] = n), + arrayEach(a, function (o) { + if (!e[o]) + throw new Error( + "async.auto task `" + + r + + "` has a non-existent dependency `" + + o + + "` in " + + a.join(", ") + ); + addListener(o, function () { + 0 == --n && enqueueTask(r, t); + }); + }); + }), + checkForDeadlocks(), + processQueue(); + }; + function arrayMap(e, t) { + for ( + var r = -1, a = null == e ? 0 : e.length, n = Array(a); + ++r < a; + + ) + n[r] = t(e[r], r, e); + return n; + } + var Ut = "[object Symbol]"; + function isSymbol(e) { + return ( + "symbol" == typeof e || (isObjectLike(e) && baseGetTag(e) == Ut) + ); + } + var zt = 1 / 0, + Kt = l ? l.prototype : void 0, + Wt = Kt ? Kt.toString : void 0; + function baseToString(e) { + if ("string" == typeof e) return e; + if (z(e)) return arrayMap(e, baseToString) + ""; + if (isSymbol(e)) return Wt ? Wt.call(e) : ""; + var t = e + ""; + return "0" == t && 1 / e == -zt ? "-0" : t; + } + function baseSlice(e, t, r) { + var a = -1, + n = e.length; + t < 0 && (t = -t > n ? 0 : n + t), + (r = r > n ? n : r) < 0 && (r += n), + (n = t > r ? 0 : (r - t) >>> 0), + (t >>>= 0); + for (var o = Array(n); ++a < n; ) o[a] = e[a + t]; + return o; + } + function castSlice(e, t, r) { + var a = e.length; + return ( + (r = void 0 === r ? a : r), + !t && r >= a ? e : baseSlice(e, t, r) + ); + } + function charsEndIndex(e, t) { + for (var r = e.length; r-- && baseIndexOf(t, e[r], 0) > -1; ); + return r; + } + function charsStartIndex(e, t) { + for ( + var r = -1, a = e.length; + ++r < a && baseIndexOf(t, e[r], 0) > -1; + + ); + return r; + } + function asciiToArray(e) { + return e.split(""); + } + var Ht = RegExp( + "[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]" + ); + function hasUnicode(e) { + return Ht.test(e); + } + var qt = "\\ud800-\\udfff", + Vt = "[" + qt + "]", + Gt = "[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]", + Zt = "\\ud83c[\\udffb-\\udfff]", + Yt = "[^" + qt + "]", + Jt = "(?:\\ud83c[\\udde6-\\uddff]){2}", + Xt = "[\\ud800-\\udbff][\\udc00-\\udfff]", + Qt = "(?:" + Gt + "|" + Zt + ")?", + $t = "[\\ufe0e\\ufe0f]?", + er = + "(?:\\u200d(?:" + [Yt, Jt, Xt].join("|") + ")" + $t + Qt + ")*", + tr = $t + Qt + er, + rr = "(?:" + [Yt + Gt + "?", Gt, Jt, Xt, Vt].join("|") + ")", + ar = RegExp(Zt + "(?=" + Zt + ")|" + rr + tr, "g"); + function unicodeToArray(e) { + return e.match(ar) || []; + } + function stringToArray(e) { + return hasUnicode(e) ? unicodeToArray(e) : asciiToArray(e); + } + function toString(e) { + return null == e ? "" : baseToString(e); + } + var nr = /^\s+|\s+$/g; + function trim(e, t, r) { + if ((e = toString(e)) && (r || void 0 === t)) + return e.replace(nr, ""); + if (!e || !(t = baseToString(t))) return e; + var a = stringToArray(e), + n = stringToArray(t); + return castSlice( + a, + charsStartIndex(a, n), + charsEndIndex(a, n) + 1 + ).join(""); + } + var ir = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m, + cr = /,/, + fr = /(=.+)?(\s*)$/, + dr = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm; + function parseParams(e) { + return (e = (e = (e = (e = e.toString().replace(dr, "")) + .match(ir)[2] + .replace(" ", "")) + ? e.split(cr) + : []).map(function (e) { + return trim(e.replace(fr, "")); + })); + } + function autoInject(e, t) { + var r = {}; + baseForOwn(e, function (e, t) { + var a, + n = isAsync(e), + o = (!n && 1 === e.length) || (n && 0 === e.length); + if (z(e)) + (a = e.slice(0, -1)), + (e = e[e.length - 1]), + (r[t] = a.concat(a.length > 0 ? newTask : e)); + else if (o) r[t] = e; + else { + if ( + ((a = parseParams(e)), + 0 === e.length && !n && 0 === a.length) + ) + throw new Error( + "autoInject task functions require explicit parameters." + ); + n || a.pop(), (r[t] = a.concat(newTask)); + } + function newTask(t, r) { + var n = arrayMap(a, function (e) { + return t[e]; + }); + n.push(r), wrapAsync(e).apply(null, n); + } + }), + auto(r, t); + } + function DLL() { + (this.head = this.tail = null), (this.length = 0); + } + function setInitial(e, t) { + (e.length = 1), (e.head = e.tail = t); + } + function queue(e, t, r) { + if (null == t) t = 1; + else if (0 === t) throw new Error("Concurrency must not be zero"); + var a = wrapAsync(e), + n = 0, + o = [], + d = !1; + function _insert(e, t, r) { + if (null != r && "function" != typeof r) + throw new Error("task callback must be a function"); + if ( + ((u.started = !0), + z(e) || (e = [e]), + 0 === e.length && u.idle()) + ) + return c(function () { + u.drain(); + }); + for (var a = 0, n = e.length; a < n; a++) { + var o = { data: e[a], callback: r || noop }; + t ? u._tasks.unshift(o) : u._tasks.push(o); + } + d || + ((d = !0), + c(function () { + (d = !1), u.process(); + })); + } + function _next(e) { + return function (t) { + n -= 1; + for (var r = 0, a = e.length; r < a; r++) { + var c = e[r], + d = baseIndexOf(o, c, 0); + 0 === d ? o.shift() : d > 0 && o.splice(d, 1), + c.callback.apply(c, arguments), + null != t && u.error(t, c.data); + } + n <= u.concurrency - u.buffer && u.unsaturated(), + u.idle() && u.drain(), + u.process(); + }; + } + var s = !1, + u = { + _tasks: new DLL(), + concurrency: t, + payload: r, + saturated: noop, + unsaturated: noop, + buffer: t / 4, + empty: noop, + drain: noop, + error: noop, + started: !1, + paused: !1, + push: function (e, t) { + _insert(e, !1, t); + }, + kill: function () { + (u.drain = noop), u._tasks.empty(); + }, + unshift: function (e, t) { + _insert(e, !0, t); + }, + remove: function (e) { + u._tasks.remove(e); + }, + process: function () { + if (!s) { + for ( + s = !0; + !u.paused && n < u.concurrency && u._tasks.length; + + ) { + var e = [], + t = [], + r = u._tasks.length; + u.payload && (r = Math.min(r, u.payload)); + for (var c = 0; c < r; c++) { + var d = u._tasks.shift(); + e.push(d), o.push(d), t.push(d.data); + } + (n += 1), + 0 === u._tasks.length && u.empty(), + n === u.concurrency && u.saturated(); + var b = onlyOnce(_next(e)); + a(t, b); + } + s = !1; + } + }, + length: function () { + return u._tasks.length; + }, + running: function () { + return n; + }, + workersList: function () { + return o; + }, + idle: function () { + return u._tasks.length + n === 0; + }, + pause: function () { + u.paused = !0; + }, + resume: function () { + !1 !== u.paused && ((u.paused = !1), c(u.process)); + } + }; + return u; + } + function cargo(e, t) { + return queue(e, 1, t); + } + (DLL.prototype.removeLink = function (e) { + return ( + e.prev ? (e.prev.next = e.next) : (this.head = e.next), + e.next ? (e.next.prev = e.prev) : (this.tail = e.prev), + (e.prev = e.next = null), + (this.length -= 1), + e + ); + }), + (DLL.prototype.empty = function () { + for (; this.head; ) this.shift(); + return this; + }), + (DLL.prototype.insertAfter = function (e, t) { + (t.prev = e), + (t.next = e.next), + e.next ? (e.next.prev = t) : (this.tail = t), + (e.next = t), + (this.length += 1); + }), + (DLL.prototype.insertBefore = function (e, t) { + (t.prev = e.prev), + (t.next = e), + e.prev ? (e.prev.next = t) : (this.head = t), + (e.prev = t), + (this.length += 1); + }), + (DLL.prototype.unshift = function (e) { + this.head + ? this.insertBefore(this.head, e) + : setInitial(this, e); + }), + (DLL.prototype.push = function (e) { + this.tail + ? this.insertAfter(this.tail, e) + : setInitial(this, e); + }), + (DLL.prototype.shift = function () { + return this.head && this.removeLink(this.head); + }), + (DLL.prototype.pop = function () { + return this.tail && this.removeLink(this.tail); + }), + (DLL.prototype.toArray = function () { + for ( + var e = Array(this.length), t = this.head, r = 0; + r < this.length; + r++ + ) + (e[r] = t.data), (t = t.next); + return e; + }), + (DLL.prototype.remove = function (e) { + for (var t = this.head; t; ) { + var r = t.next; + e(t) && this.removeLink(t), (t = r); + } + return this; + }); + var sr = doLimit(eachOfLimit, 1); + function reduce(e, t, r, a) { + a = once(a || noop); + var n = wrapAsync(r); + sr( + e, + function (e, r, a) { + n(t, e, function (e, r) { + (t = r), a(e); + }); + }, + function (e) { + a(e, t); + } + ); + } + function seq() { + var e = arrayMap(arguments, wrapAsync); + return function () { + var t = slice(arguments), + r = this, + a = t[t.length - 1]; + "function" == typeof a ? t.pop() : (a = noop), + reduce( + e, + t, + function (e, t, a) { + t.apply( + r, + e.concat(function (e) { + var t = slice(arguments, 1); + a(e, t); + }) + ); + }, + function (e, t) { + a.apply(r, [e].concat(t)); + } + ); + }; + } + var compose = function () { + return seq.apply(null, slice(arguments).reverse()); + }, + ur = Array.prototype.concat, + concatLimit = function (e, t, r, a) { + a = a || noop; + var n = wrapAsync(r); + Ct( + e, + t, + function (e, t) { + n(e, function (e) { + return e ? t(e) : t(null, slice(arguments, 1)); + }); + }, + function (e, t) { + for (var r = [], n = 0; n < t.length; n++) + t[n] && (r = ur.apply(r, t[n])); + return a(e, r); + } + ); + }, + br = doLimit(concatLimit, 1 / 0), + lr = doLimit(concatLimit, 1), + constant = function () { + var e = slice(arguments), + t = [null].concat(e); + return function () { + return arguments[arguments.length - 1].apply(this, t); + }; + }; + function identity(e) { + return e; + } + function _createTester(e, t) { + return function (r, a, n, o) { + o = o || noop; + var c, + d = !1; + r( + a, + function (r, a, o) { + n(r, function (a, n) { + a + ? o(a) + : e(n) && !c + ? ((d = !0), (c = t(!0, r)), o(null, O)) + : o(); + }); + }, + function (e) { + e ? o(e) : o(null, d ? c : t(!1)); + } + ); + }; + } + function _findGetResult(e, t) { + return t; + } + var hr = doParallel(_createTester(identity, _findGetResult)), + pr = doParallelLimit(_createTester(identity, _findGetResult)), + xr = doLimit(pr, 1); + function consoleFunc(e) { + return function (t) { + var r = slice(arguments, 1); + r.push(function (t) { + var r = slice(arguments, 1); + "object" == typeof console && + (t + ? console.error && console.error(t) + : console[e] && + arrayEach(r, function (t) { + console[e](t); + })); + }), + wrapAsync(t).apply(null, r); + }; + } + var mr = consoleFunc("dir"); + function doDuring(e, t, r) { + r = onlyOnce(r || noop); + var a = wrapAsync(e), + n = wrapAsync(t); + function next(e) { + if (e) return r(e); + var t = slice(arguments, 1); + t.push(check), n.apply(this, t); + } + function check(e, t) { + return e ? r(e) : t ? void a(next) : r(null); + } + check(null, !0); + } + function doWhilst(e, t, r) { + r = onlyOnce(r || noop); + var a = wrapAsync(e), + next = function (e) { + if (e) return r(e); + var n = slice(arguments, 1); + if (t.apply(this, n)) return a(next); + r.apply(null, [null].concat(n)); + }; + a(next); + } + function doUntil(e, t, r) { + doWhilst( + e, + function () { + return !t.apply(this, arguments); + }, + r + ); + } + function during(e, t, r) { + r = onlyOnce(r || noop); + var a = wrapAsync(t), + n = wrapAsync(e); + function next(e) { + if (e) return r(e); + n(check); + } + function check(e, t) { + return e ? r(e) : t ? void a(next) : r(null); + } + n(check); + } + function _withoutIndex(e) { + return function (t, r, a) { + return e(t, a); + }; + } + function eachLimit(e, t, r) { + eachOf(e, _withoutIndex(wrapAsync(t)), r); + } + function eachLimit$1(e, t, r, a) { + _eachOfLimit(t)(e, _withoutIndex(wrapAsync(r)), a); + } + var yr = doLimit(eachLimit$1, 1); + function ensureAsync(e) { + return isAsync(e) + ? e + : initialParams(function (t, r) { + var a = !0; + t.push(function () { + var e = arguments; + a + ? c(function () { + r.apply(null, e); + }) + : r.apply(null, e); + }), + e.apply(this, t), + (a = !1); + }); + } + function notId(e) { + return !e; + } + var gr = doParallel(_createTester(notId, notId)), + vr = doParallelLimit(_createTester(notId, notId)), + wr = doLimit(vr, 1); + function baseProperty(e) { + return function (t) { + return null == t ? void 0 : t[e]; + }; + } + function filterArray(e, t, r, a) { + var n = new Array(t.length); + e( + t, + function (e, t, a) { + r(e, function (e, r) { + (n[t] = !!r), a(e); + }); + }, + function (e) { + if (e) return a(e); + for (var r = [], o = 0; o < t.length; o++) + n[o] && r.push(t[o]); + a(null, r); + } + ); + } + function filterGeneric(e, t, r, a) { + var n = []; + e( + t, + function (e, t, a) { + r(e, function (r, o) { + r ? a(r) : (o && n.push({ index: t, value: e }), a()); + }); + }, + function (e) { + e + ? a(e) + : a( + null, + arrayMap( + n.sort(function (e, t) { + return e.index - t.index; + }), + baseProperty("value") + ) + ); + } + ); + } + function _filter(e, t, r, a) { + (isArrayLike(t) ? filterArray : filterGeneric)( + e, + t, + wrapAsync(r), + a || noop + ); + } + var Ar = doParallel(_filter), + _r = doParallelLimit(_filter), + Mr = doLimit(_r, 1); + function forever(e, t) { + var r = onlyOnce(t || noop), + a = wrapAsync(ensureAsync(e)); + function next(e) { + if (e) return r(e); + a(next); + } + next(); + } + var groupByLimit = function (e, t, r, a) { + a = a || noop; + var n = wrapAsync(r); + Ct( + e, + t, + function (e, t) { + n(e, function (r, a) { + return r ? t(r) : t(null, { key: a, val: e }); + }); + }, + function (e, t) { + for ( + var r = {}, n = Object.prototype.hasOwnProperty, o = 0; + o < t.length; + o++ + ) + if (t[o]) { + var c = t[o].key, + d = t[o].val; + n.call(r, c) ? r[c].push(d) : (r[c] = [d]); + } + return a(e, r); + } + ); + }, + kr = doLimit(groupByLimit, 1 / 0), + Er = doLimit(groupByLimit, 1), + Sr = consoleFunc("log"); + function mapValuesLimit(e, t, r, a) { + a = once(a || noop); + var n = {}, + o = wrapAsync(r); + eachOfLimit( + e, + t, + function (e, t, r) { + o(e, t, function (e, a) { + if (e) return r(e); + (n[t] = a), r(); + }); + }, + function (e) { + a(e, n); + } + ); + } + var Br = doLimit(mapValuesLimit, 1 / 0), + Nr = doLimit(mapValuesLimit, 1); + function has(e, t) { + return t in e; + } + function memoize(e, t) { + var r = Object.create(null), + a = Object.create(null); + t = t || identity; + var n = wrapAsync(e), + o = initialParams(function memoized(e, o) { + var d = t.apply(null, e); + has(r, d) + ? c(function () { + o.apply(null, r[d]); + }) + : has(a, d) + ? a[d].push(o) + : ((a[d] = [o]), + n.apply( + null, + e.concat(function () { + var e = slice(arguments); + r[d] = e; + var t = a[d]; + delete a[d]; + for (var n = 0, o = t.length; n < o; n++) + t[n].apply(null, e); + }) + )); + }); + return (o.memo = r), (o.unmemoized = e), o; + } + var Rr = wrap(o ? a.nextTick : n ? setImmediate : fallback); + function _parallel(e, t, r) { + r = r || noop; + var a = isArrayLike(t) ? [] : {}; + e( + t, + function (e, t, r) { + wrapAsync(e)(function (e, n) { + arguments.length > 2 && (n = slice(arguments, 1)), + (a[t] = n), + r(e); + }); + }, + function (e) { + r(e, a); + } + ); + } + function parallelLimit(e, t) { + _parallel(eachOf, e, t); + } + function parallelLimit$1(e, t, r) { + _parallel(_eachOfLimit(t), e, r); + } + var queue$1 = function (e, t) { + var r = wrapAsync(e); + return queue( + function (e, t) { + r(e[0], t); + }, + t, + 1 + ); + }, + priorityQueue = function (e, t) { + var r = queue$1(e, t); + return ( + (r.push = function (e, t, a) { + if ((null == a && (a = noop), "function" != typeof a)) + throw new Error("task callback must be a function"); + if (((r.started = !0), z(e) || (e = [e]), 0 === e.length)) + return c(function () { + r.drain(); + }); + t = t || 0; + for (var n = r._tasks.head; n && t >= n.priority; ) + n = n.next; + for (var o = 0, d = e.length; o < d; o++) { + var s = { data: e[o], priority: t, callback: a }; + n ? r._tasks.insertBefore(n, s) : r._tasks.push(s); + } + c(r.process); + }), + delete r.unshift, + r + ); + }; + function race(e, t) { + if (((t = once(t || noop)), !z(e))) + return t( + new TypeError( + "First argument to race must be an array of functions" + ) + ); + if (!e.length) return t(); + for (var r = 0, a = e.length; r < a; r++) wrapAsync(e[r])(t); + } + function reduceRight(e, t, r, a) { + reduce(slice(e).reverse(), t, r, a); + } + function reflect(e) { + var t = wrapAsync(e); + return initialParams(function reflectOn(e, r) { + return ( + e.push(function callback(e, t) { + var a; + e + ? r(null, { error: e }) + : ((a = arguments.length <= 2 ? t : slice(arguments, 1)), + r(null, { value: a })); + }), + t.apply(this, e) + ); + }); + } + function reflectAll(e) { + var t; + return ( + z(e) + ? (t = arrayMap(e, reflect)) + : ((t = {}), + baseForOwn(e, function (e, r) { + t[r] = reflect.call(this, e); + })), + t + ); + } + function reject$1(e, t, r, a) { + _filter( + e, + t, + function (e, t) { + r(e, function (e, r) { + t(e, !r); + }); + }, + a + ); + } + var Tr = doParallel(reject$1), + Pr = doParallelLimit(reject$1), + Or = doLimit(Pr, 1); + function constant$1(e) { + return function () { + return e; + }; + } + function retry(e, t, r) { + var a = 5, + n = 0, + o = { times: a, intervalFunc: constant$1(n) }; + function parseTimes(e, t) { + if ("object" == typeof t) + (e.times = +t.times || a), + (e.intervalFunc = + "function" == typeof t.interval + ? t.interval + : constant$1(+t.interval || n)), + (e.errorFilter = t.errorFilter); + else { + if ("number" != typeof t && "string" != typeof t) + throw new Error("Invalid arguments for async.retry"); + e.times = +t || a; + } + } + if ( + (arguments.length < 3 && "function" == typeof e + ? ((r = t || noop), (t = e)) + : (parseTimes(o, e), (r = r || noop)), + "function" != typeof t) + ) + throw new Error("Invalid arguments for async.retry"); + var c = wrapAsync(t), + d = 1; + function retryAttempt() { + c(function (e) { + e && + d++ < o.times && + ("function" != typeof o.errorFilter || o.errorFilter(e)) + ? setTimeout(retryAttempt, o.intervalFunc(d)) + : r.apply(null, arguments); + }); + } + retryAttempt(); + } + var retryable = function (e, t) { + t || ((t = e), (e = null)); + var r = wrapAsync(t); + return initialParams(function (t, a) { + function taskFn(e) { + r.apply(null, t.concat(e)); + } + e ? retry(e, taskFn, a) : retry(taskFn, a); + }); + }; + function series(e, t) { + _parallel(sr, e, t); + } + var Ir = doParallel(_createTester(Boolean, identity)), + Lr = doParallelLimit(_createTester(Boolean, identity)), + Cr = doLimit(Lr, 1); + function sortBy(e, t, r) { + var a = wrapAsync(t); + function comparator(e, t) { + var r = e.criteria, + a = t.criteria; + return r < a ? -1 : r > a ? 1 : 0; + } + It( + e, + function (e, t) { + a(e, function (r, a) { + if (r) return t(r); + t(null, { value: e, criteria: a }); + }); + }, + function (e, t) { + if (e) return r(e); + r(null, arrayMap(t.sort(comparator), baseProperty("value"))); + } + ); + } + function timeout(e, t, r) { + var a = wrapAsync(e); + return initialParams(function (n, o) { + var c, + d = !1; + function timeoutCallback() { + var t = e.name || "anonymous", + a = new Error('Callback function "' + t + '" timed out.'); + (a.code = "ETIMEDOUT"), r && (a.info = r), (d = !0), o(a); + } + n.push(function () { + d || (o.apply(null, arguments), clearTimeout(c)); + }), + (c = setTimeout(timeoutCallback, t)), + a.apply(null, n); + }); + } + var Dr = Math.ceil, + jr = Math.max; + function baseRange(e, t, r, a) { + for ( + var n = -1, o = jr(Dr((t - e) / (r || 1)), 0), c = Array(o); + o--; + + ) + (c[a ? o : ++n] = e), (e += r); + return c; + } + function timeLimit(e, t, r, a) { + var n = wrapAsync(r); + Ct(baseRange(0, e, 1), t, n, a); + } + var Fr = doLimit(timeLimit, 1 / 0), + Ur = doLimit(timeLimit, 1); + function transform(e, t, r, a) { + arguments.length <= 3 && ((a = r), (r = t), (t = z(e) ? [] : {})), + (a = once(a || noop)); + var n = wrapAsync(r); + eachOf( + e, + function (e, r, a) { + n(t, e, r, a); + }, + function (e) { + a(e, t); + } + ); + } + function tryEach(e, t) { + var r, + a = null; + (t = t || noop), + yr( + e, + function (e, t) { + wrapAsync(e)(function (e, n) { + (r = arguments.length > 2 ? slice(arguments, 1) : n), + (a = e), + t(!e); + }); + }, + function () { + t(a, r); + } + ); + } + function unmemoize(e) { + return function () { + return (e.unmemoized || e).apply(null, arguments); + }; + } + function whilst(e, t, r) { + r = onlyOnce(r || noop); + var a = wrapAsync(t); + if (!e()) return r(null); + var next = function (t) { + if (t) return r(t); + if (e()) return a(next); + var n = slice(arguments, 1); + r.apply(null, [null].concat(n)); + }; + a(next); + } + function until(e, t, r) { + whilst( + function () { + return !e.apply(this, arguments); + }, + t, + r + ); + } + var waterfall = function (e, t) { + if (((t = once(t || noop)), !z(e))) + return t( + new Error( + "First argument to waterfall must be an array of functions" + ) + ); + if (!e.length) return t(); + var r = 0; + function nextTask(t) { + var a = wrapAsync(e[r++]); + t.push(onlyOnce(next)), a.apply(null, t); + } + function next(a) { + if (a || r === e.length) return t.apply(null, arguments); + nextTask(slice(arguments, 1)); + } + nextTask([]); + }, + zr = { + apply, + applyEach: Lt, + applyEachSeries: jt, + asyncify, + auto, + autoInject, + cargo, + compose, + concat: br, + concatLimit, + concatSeries: lr, + constant, + detect: hr, + detectLimit: pr, + detectSeries: xr, + dir: mr, + doDuring, + doUntil, + doWhilst, + during, + each: eachLimit, + eachLimit: eachLimit$1, + eachOf, + eachOfLimit, + eachOfSeries: sr, + eachSeries: yr, + ensureAsync, + every: gr, + everyLimit: vr, + everySeries: wr, + filter: Ar, + filterLimit: _r, + filterSeries: Mr, + forever, + groupBy: kr, + groupByLimit, + groupBySeries: Er, + log: Sr, + map: It, + mapLimit: Ct, + mapSeries: Dt, + mapValues: Br, + mapValuesLimit, + mapValuesSeries: Nr, + memoize, + nextTick: Rr, + parallel: parallelLimit, + parallelLimit: parallelLimit$1, + priorityQueue, + queue: queue$1, + race, + reduce, + reduceRight, + reflect, + reflectAll, + reject: Tr, + rejectLimit: Pr, + rejectSeries: Or, + retry, + retryable, + seq, + series, + setImmediate: c, + some: Ir, + someLimit: Lr, + someSeries: Cr, + sortBy, + timeout, + times: Fr, + timesLimit: timeLimit, + timesSeries: Ur, + transform, + tryEach, + unmemoize, + until, + waterfall, + whilst, + all: gr, + allLimit: vr, + allSeries: wr, + any: Ir, + anyLimit: Lr, + anySeries: Cr, + find: hr, + findLimit: pr, + findSeries: xr, + forEach: eachLimit, + forEachSeries: yr, + forEachLimit: eachLimit$1, + forEachOf: eachOf, + forEachOfSeries: sr, + forEachOfLimit: eachOfLimit, + inject: reduce, + foldl: reduce, + foldr: reduceRight, + select: Ar, + selectLimit: _r, + selectSeries: Mr, + wrapSync: asyncify + }; + (t.default = zr), + (t.apply = apply), + (t.applyEach = Lt), + (t.applyEachSeries = jt), + (t.asyncify = asyncify), + (t.auto = auto), + (t.autoInject = autoInject), + (t.cargo = cargo), + (t.compose = compose), + (t.concat = br), + (t.concatLimit = concatLimit), + (t.concatSeries = lr), + (t.constant = constant), + (t.detect = hr), + (t.detectLimit = pr), + (t.detectSeries = xr), + (t.dir = mr), + (t.doDuring = doDuring), + (t.doUntil = doUntil), + (t.doWhilst = doWhilst), + (t.during = during), + (t.each = eachLimit), + (t.eachLimit = eachLimit$1), + (t.eachOf = eachOf), + (t.eachOfLimit = eachOfLimit), + (t.eachOfSeries = sr), + (t.eachSeries = yr), + (t.ensureAsync = ensureAsync), + (t.every = gr), + (t.everyLimit = vr), + (t.everySeries = wr), + (t.filter = Ar), + (t.filterLimit = _r), + (t.filterSeries = Mr), + (t.forever = forever), + (t.groupBy = kr), + (t.groupByLimit = groupByLimit), + (t.groupBySeries = Er), + (t.log = Sr), + (t.map = It), + (t.mapLimit = Ct), + (t.mapSeries = Dt), + (t.mapValues = Br), + (t.mapValuesLimit = mapValuesLimit), + (t.mapValuesSeries = Nr), + (t.memoize = memoize), + (t.nextTick = Rr), + (t.parallel = parallelLimit), + (t.parallelLimit = parallelLimit$1), + (t.priorityQueue = priorityQueue), + (t.queue = queue$1), + (t.race = race), + (t.reduce = reduce), + (t.reduceRight = reduceRight), + (t.reflect = reflect), + (t.reflectAll = reflectAll), + (t.reject = Tr), + (t.rejectLimit = Pr), + (t.rejectSeries = Or), + (t.retry = retry), + (t.retryable = retryable), + (t.seq = seq), + (t.series = series), + (t.setImmediate = c), + (t.some = Ir), + (t.someLimit = Lr), + (t.someSeries = Cr), + (t.sortBy = sortBy), + (t.timeout = timeout), + (t.times = Fr), + (t.timesLimit = timeLimit), + (t.timesSeries = Ur), + (t.transform = transform), + (t.tryEach = tryEach), + (t.unmemoize = unmemoize), + (t.until = until), + (t.waterfall = waterfall), + (t.whilst = whilst), + (t.all = gr), + (t.allLimit = vr), + (t.allSeries = wr), + (t.any = Ir), + (t.anyLimit = Lr), + (t.anySeries = Cr), + (t.find = hr), + (t.findLimit = pr), + (t.findSeries = xr), + (t.forEach = eachLimit), + (t.forEachSeries = yr), + (t.forEachLimit = eachLimit$1), + (t.forEachOf = eachOf), + (t.forEachOfSeries = sr), + (t.forEachOfLimit = eachOfLimit), + (t.inject = reduce), + (t.foldl = reduce), + (t.foldr = reduceRight), + (t.select = Ar), + (t.selectLimit = _r), + (t.selectSeries = Mr), + (t.wrapSync = asyncify), + Object.defineProperty(t, "__esModule", { value: !0 }); + })(t); + }, + 14310: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function eachLimit(e, t, r, c) { + (0, a.default)(t)(e, (0, n.default)((0, o.default)(r)), c); + }); + var a = _interopRequireDefault(r(1007)), + n = _interopRequireDefault(r(60680)), + o = _interopRequireDefault(r(19220)); + function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + } + e.exports = t.default; + }, + 91661: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }); + var a = _interopRequireDefault(r(14310)), + n = _interopRequireDefault(r(83089)); + function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + } + (t.default = (0, n.default)(a.default, 1)), (e.exports = t.default); + }, + 93071: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = {}), + (e.exports = t.default); + }, + 83089: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function doLimit(e, t) { + return function (r, a, n) { + return e(r, t, a, n); + }; + }), + (e.exports = t.default); + }, + 1007: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function _eachOfLimit(e) { + return function (t, r, s) { + if (((s = (0, n.default)(s || a.default)), e <= 0 || !t)) + return s(null); + var u = (0, o.default)(t), + b = !1, + l = 0, + h = !1; + function iterateeCallback(e, t) { + if (((l -= 1), e)) (b = !0), s(e); + else { + if (t === d.default || (b && l <= 0)) + return (b = !0), s(null); + h || replenish(); + } + } + function replenish() { + for (h = !0; l < e && !b; ) { + var t = u(); + if (null === t) return (b = !0), void (l <= 0 && s(null)); + (l += 1), + r(t.value, t.key, (0, c.default)(iterateeCallback)); + } + h = !1; + } + replenish(); + }; + }); + var a = _interopRequireDefault(r(97349)), + n = _interopRequireDefault(r(52869)), + o = _interopRequireDefault(r(83743)), + c = _interopRequireDefault(r(28870)), + d = _interopRequireDefault(r(93071)); + function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + } + e.exports = t.default; + }, + 30985: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function (e) { + return r && e[r] && e[r](); + }); + var r = "function" == typeof Symbol && Symbol.iterator; + e.exports = t.default; + }, + 39089: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function (e) { + return function () { + var t = (0, a.default)(arguments), + r = t.pop(); + e.call(this, t, r); + }; + }); + var a = (function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + })(r(84150)); + e.exports = t.default; + }, + 83743: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function iterator(e) { + if ((0, a.default)(e)) + return (function createArrayIterator(e) { + var t = -1, + r = e.length; + return function next() { + return ++t < r ? { value: e[t], key: t } : null; + }; + })(e); + var t = (0, n.default)(e); + return t + ? (function createES2015Iterator(e) { + var t = -1; + return function next() { + var r = e.next(); + return r.done ? null : (t++, { value: r.value, key: t }); + }; + })(t) + : (function createObjectIterator(e) { + var t = (0, o.default)(e), + r = -1, + a = t.length; + return function next() { + var n = t[++r]; + return r < a ? { value: e[n], key: n } : null; + }; + })(e); + }); + var a = _interopRequireDefault(r(47905)), + n = _interopRequireDefault(r(30985)), + o = _interopRequireDefault(r(99512)); + function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + } + e.exports = t.default; + }, + 52869: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function once(e) { + return function () { + if (null !== e) { + var t = e; + (e = null), t.apply(this, arguments); + } + }; + }), + (e.exports = t.default); + }, + 28870: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function onlyOnce(e) { + return function () { + if (null === e) throw new Error("Callback was already called."); + var t = e; + (e = null), t.apply(this, arguments); + }; + }), + (e.exports = t.default); + }, + 31747: (e, t, r) => { + "use strict"; + var a = r(34155); + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.hasNextTick = t.hasSetImmediate = void 0), + (t.fallback = fallback), + (t.wrap = wrap); + var n = (function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + })(r(84150)); + var o, + c = (t.hasSetImmediate = + "function" == typeof setImmediate && setImmediate), + d = (t.hasNextTick = + "object" == typeof a && "function" == typeof a.nextTick); + function fallback(e) { + setTimeout(e, 0); + } + function wrap(e) { + return function (t) { + var r = (0, n.default)(arguments, 1); + e(function () { + t.apply(null, r); + }); + }; + } + (o = c ? setImmediate : d ? a.nextTick : fallback), + (t.default = wrap(o)); + }, + 84150: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function slice(e, t) { + t |= 0; + for ( + var r = Math.max(e.length - t, 0), a = Array(r), n = 0; + n < r; + n++ + ) + a[n] = e[t + n]; + return a; + }), + (e.exports = t.default); + }, + 60680: (e, t) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.default = function _withoutIndex(e) { + return function (t, r, a) { + return e(t, a); + }; + }), + (e.exports = t.default); + }, + 19220: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }), + (t.isAsync = void 0); + var a = (function _interopRequireDefault(e) { + return e && e.__esModule ? e : { default: e }; + })(r(68870)); + var n = "function" == typeof Symbol; + function isAsync(e) { + return n && "AsyncFunction" === e[Symbol.toStringTag]; + } + (t.default = function wrapAsync(e) { + return isAsync(e) ? (0, a.default)(e) : e; + }), + (t.isAsync = isAsync); + }, + 81435: (e, t, r) => { + "use strict"; + var a = r(62659).Buffer; + e.exports = function base(e) { + if (e.length >= 255) throw new TypeError("Alphabet too long"); + for (var t = new Uint8Array(256), r = 0; r < t.length; r++) + t[r] = 255; + for (var n = 0; n < e.length; n++) { + var o = e.charAt(n), + c = o.charCodeAt(0); + if (255 !== t[c]) throw new TypeError(o + " is ambiguous"); + t[c] = n; + } + var d = e.length, + s = e.charAt(0), + u = Math.log(d) / Math.log(256), + b = Math.log(256) / Math.log(d); + function decodeUnsafe(e) { + if ("string" != typeof e) throw new TypeError("Expected String"); + if (0 === e.length) return a.alloc(0); + var r = 0; + if (" " !== e[r]) { + for (var n = 0, o = 0; e[r] === s; ) n++, r++; + for ( + var c = ((e.length - r) * u + 1) >>> 0, b = new Uint8Array(c); + e[r]; + + ) { + var l = t[e.charCodeAt(r)]; + if (255 === l) return; + for ( + var h = 0, p = c - 1; + (0 !== l || h < o) && -1 !== p; + p--, h++ + ) + (l += (d * b[p]) >>> 0), + (b[p] = l % 256 >>> 0), + (l = (l / 256) >>> 0); + if (0 !== l) throw new Error("Non-zero carry"); + (o = h), r++; + } + if (" " !== e[r]) { + for (var x = c - o; x !== c && 0 === b[x]; ) x++; + var m = a.allocUnsafe(n + (c - x)); + m.fill(0, 0, n); + for (var y = n; x !== c; ) m[y++] = b[x++]; + return m; + } + } + } + return { + encode: function encode(t) { + if ( + ((Array.isArray(t) || t instanceof Uint8Array) && + (t = a.from(t)), + !a.isBuffer(t)) + ) + throw new TypeError("Expected Buffer"); + if (0 === t.length) return ""; + for ( + var r = 0, n = 0, o = 0, c = t.length; + o !== c && 0 === t[o]; + + ) + o++, r++; + for ( + var u = ((c - o) * b + 1) >>> 0, l = new Uint8Array(u); + o !== c; + + ) { + for ( + var h = t[o], p = 0, x = u - 1; + (0 !== h || p < n) && -1 !== x; + x--, p++ + ) + (h += (256 * l[x]) >>> 0), + (l[x] = h % d >>> 0), + (h = (h / d) >>> 0); + if (0 !== h) throw new Error("Non-zero carry"); + (n = p), o++; + } + for (var m = u - n; m !== u && 0 === l[m]; ) m++; + for (var y = s.repeat(r); m < u; ++m) y += e.charAt(l[m]); + return y; + }, + decodeUnsafe, + decode: function decode(e) { + var t = decodeUnsafe(e); + if (t) return t; + throw new Error("Non-base" + d + " character"); + } + }; + }; + }, + 62226: (e, t) => { + "use strict"; + (t.byteLength = function byteLength(e) { + var t = getLens(e), + r = t[0], + a = t[1]; + return (3 * (r + a)) / 4 - a; + }), + (t.toByteArray = function toByteArray(e) { + var t, + r, + o = getLens(e), + c = o[0], + d = o[1], + s = new n( + (function _byteLength(e, t, r) { + return (3 * (t + r)) / 4 - r; + })(0, c, d) + ), + u = 0, + b = d > 0 ? c - 4 : c; + for (r = 0; r < b; r += 4) + (t = + (a[e.charCodeAt(r)] << 18) | + (a[e.charCodeAt(r + 1)] << 12) | + (a[e.charCodeAt(r + 2)] << 6) | + a[e.charCodeAt(r + 3)]), + (s[u++] = (t >> 16) & 255), + (s[u++] = (t >> 8) & 255), + (s[u++] = 255 & t); + 2 === d && + ((t = + (a[e.charCodeAt(r)] << 2) | (a[e.charCodeAt(r + 1)] >> 4)), + (s[u++] = 255 & t)); + 1 === d && + ((t = + (a[e.charCodeAt(r)] << 10) | + (a[e.charCodeAt(r + 1)] << 4) | + (a[e.charCodeAt(r + 2)] >> 2)), + (s[u++] = (t >> 8) & 255), + (s[u++] = 255 & t)); + return s; + }), + (t.fromByteArray = function fromByteArray(e) { + for ( + var t, + a = e.length, + n = a % 3, + o = [], + c = 16383, + d = 0, + s = a - n; + d < s; + d += c + ) + o.push(encodeChunk(e, d, d + c > s ? s : d + c)); + 1 === n + ? ((t = e[a - 1]), o.push(r[t >> 2] + r[(t << 4) & 63] + "==")) + : 2 === n && + ((t = (e[a - 2] << 8) + e[a - 1]), + o.push( + r[t >> 10] + r[(t >> 4) & 63] + r[(t << 2) & 63] + "=" + )); + return o.join(""); + }); + for ( + var r = [], + a = [], + n = "undefined" != typeof Uint8Array ? Uint8Array : Array, + o = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + c = 0, + d = o.length; + c < d; + ++c + ) + (r[c] = o[c]), (a[o.charCodeAt(c)] = c); + function getLens(e) { + var t = e.length; + if (t % 4 > 0) + throw new Error("Invalid string. Length must be a multiple of 4"); + var r = e.indexOf("="); + return -1 === r && (r = t), [r, r === t ? 0 : 4 - (r % 4)]; + } + function encodeChunk(e, t, a) { + for (var n, o, c = [], d = t; d < a; d += 3) + (n = + ((e[d] << 16) & 16711680) + + ((e[d + 1] << 8) & 65280) + + (255 & e[d + 2])), + c.push( + r[((o = n) >> 18) & 63] + + r[(o >> 12) & 63] + + r[(o >> 6) & 63] + + r[63 & o] + ); + return c.join(""); + } + (a["-".charCodeAt(0)] = 62), (a["_".charCodeAt(0)] = 63); + }, + 64643: (e, t, r) => { + "use strict"; + Object.defineProperty(t, "__esModule", { value: !0 }); + const a = {}; + let n; + (t.wordlists = a), (t._default = n); + try { + (t._default = n = r(67684)), (a.chinese_simplified = n); + } catch (e) {} + try { + (t._default = n = r(12359)), (a.chinese_traditional = n); + } catch (e) {} + try { + (t._default = n = r(51194)), (a.korean = n); + } catch (e) {} + try { + (t._default = n = r(91949)), (a.french = n); + } catch (e) {} + try { + (t._default = n = r(81981)), (a.italian = n); + } catch (e) {} + try { + (t._default = n = r(8843)), (a.spanish = n); + } catch (e) {} + try { + (t._default = n = r(95751)), (a.japanese = n), (a.JA = n); + } catch (e) {} + try { + (t._default = n = r(19170)), (a.english = n), (a.EN = n); + } catch (e) {} + }, + 96874: (e, t, r) => { + "use strict"; + var a = r(98188).Buffer; + Object.defineProperty(t, "__esModule", { value: !0 }); + const n = r(38492), + o = r(62236), + c = r(71905), + d = r(64643); + let s = d._default; + const u = "Invalid mnemonic", + b = "Invalid entropy", + l = + "A wordlist is required but a default could not be found.\nPlease explicitly pass a 2048 word array explicitly."; + function lpad(e, t, r) { + for (; e.length < r; ) e = t + e; + return e; + } + function binaryToByte(e) { + return parseInt(e, 2); + } + function bytesToBinary(e) { + return e.map(e => lpad(e.toString(2), "0", 8)).join(""); + } + function deriveChecksumBits(e) { + const t = (8 * e.length) / 32; + return bytesToBinary([...n("sha256").update(e).digest()]).slice( + 0, + t + ); + } + function salt(e) { + return "mnemonic" + (e || ""); + } + function mnemonicToEntropy(e, t) { + if (!(t = t || s)) throw new Error(l); + const r = (e || "").normalize("NFKD").split(" "); + if (r.length % 3 != 0) throw new Error(u); + const n = r + .map(e => { + const r = t.indexOf(e); + if (-1 === r) throw new Error(u); + return lpad(r.toString(2), "0", 11); + }) + .join(""), + o = 32 * Math.floor(n.length / 33), + c = n.slice(0, o), + d = n.slice(o), + h = c.match(/(.{1,8})/g).map(binaryToByte); + if (h.length < 16) throw new Error(b); + if (h.length > 32) throw new Error(b); + if (h.length % 4 != 0) throw new Error(b); + const p = a.from(h); + if (deriveChecksumBits(p) !== d) + throw new Error("Invalid mnemonic checksum"); + return p.toString("hex"); + } + function entropyToMnemonic(e, t) { + if ((a.isBuffer(e) || (e = a.from(e, "hex")), !(t = t || s))) + throw new Error(l); + if (e.length < 16) throw new TypeError(b); + if (e.length > 32) throw new TypeError(b); + if (e.length % 4 != 0) throw new TypeError(b); + const r = (bytesToBinary([...e]) + deriveChecksumBits(e)) + .match(/(.{1,11})/g) + .map(e => { + const r = binaryToByte(e); + return t[r]; + }); + return "あいこくしん" === t[0] ? r.join("　") : r.join(" "); + } + (t.mnemonicToSeedSync = function mnemonicToSeedSync(e, t) { + const r = a.from((e || "").normalize("NFKD"), "utf8"), + n = a.from(salt((t || "").normalize("NFKD")), "utf8"); + return o.pbkdf2Sync(r, n, 2048, 64, "sha512"); + }), + (t.mnemonicToSeed = function mnemonicToSeed(e, t) { + return new Promise((r, n) => { + try { + const c = a.from((e || "").normalize("NFKD"), "utf8"), + d = a.from(salt((t || "").normalize("NFKD")), "utf8"); + o.pbkdf2(c, d, 2048, 64, "sha512", (e, t) => + e ? n(e) : r(t) + ); + } catch (e) { + return n(e); + } + }); + }), + (t.mnemonicToEntropy = mnemonicToEntropy), + (t.entropyToMnemonic = entropyToMnemonic), + (t.generateMnemonic = function generateMnemonic(e, t, r) { + if ((e = e || 128) % 32 != 0) throw new TypeError(b); + return entropyToMnemonic((t = t || c)(e / 8), r); + }), + (t.validateMnemonic = function validateMnemonic(e, t) { + try { + mnemonicToEntropy(e, t); + } catch (e) { + return !1; + } + return !0; + }), + (t.setDefaultWordlist = function setDefaultWordlist(e) { + const t = d.wordlists[e]; + if (!t) + throw new Error( + 'Could not find wordlist for language "' + e + '"' + ); + s = t; + }), + (t.getDefaultWordlist = function getDefaultWordlist() { + if (!s) throw new Error("No Default Wordlist set"); + return Object.keys(d.wordlists).filter( + e => + "JA" !== e && + "EN" !== e && + d.wordlists[e].every((e, t) => e === s[t]) + )[0]; + }); + var h = r(64643); + t.wordlists = h.wordlists; + }, + 67684: e => { + "use strict"; + e.exports = JSON.parse( + '["的","一","是","在","不","了","有","和","人","这","中","大","为","上","个","国","我","以","要","他","时","来","用","们","生","到","作","地","于","出","就","分","对","成","会","可","主","发","年","动","同","工","也","能","下","过","子","说","产","种","面","而","方","后","多","定","行","学","法","所","民","得","经","十","三","之","进","着","等","部","度","家","电","力","里","如","水","化","高","自","二","理","起","小","物","现","实","加","量","都","两","体","制","机","当","使","点","从","业","本","去","把","性","好","应","开","它","合","还","因","由","其","些","然","前","外","天","政","四","日","那","社","义","事","平","形","相","全","表","间","样","与","关","各","重","新","线","内","数","正","心","反","你","明","看","原","又","么","利","比","或","但","质","气","第","向","道","命","此","变","条","只","没","结","解","问","意","建","月","公","无","系","军","很","情","者","最","立","代","想","已","通","并","提","直","题","党","程","展","五","果","料","象","员","革","位","入","常","文","总","次","品","式","活","设","及","管","特","件","长","求","老","头","基","资","边","流","路","级","少","图","山","统","接","知","较","将","组","见","计","别","她","手","角","期","根","论","运","农","指","几","九","区","强","放","决","西","被","干","做","必","战","先","回","则","任","取","据","处","队","南","给","色","光","门","即","保","治","北","造","百","规","热","领","七","海","口","东","导","器","压","志","世","金","增","争","济","阶","油","思","术","极","交","受","联","什","认","六","共","权","收","证","改","清","美","再","采","转","更","单","风","切","打","白","教","速","花","带","安","场","身","车","例","真","务","具","万","每","目","至","达","走","积","示","议","声","报","斗","完","类","八","离","华","名","确","才","科","张","信","马","节","话","米","整","空","元","况","今","集","温","传","土","许","步","群","广","石","记","需","段","研","界","拉","林","律","叫","且","究","观","越","织","装","影","算","低","持","音","众","书","布","复","容","儿","须","际","商","非","验","连","断","深","难","近","矿","千","周","委","素","技","备","半","办","青","省","列","习","响","约","支","般","史","感","劳","便","团","往","酸","历","市","克","何","除","消","构","府","称","太","准","精","值","号","率","族","维","划","选","标","写","存","候","毛","亲","快","效","斯","院","查","江","型","眼","王","按","格","养","易","置","派","层","片","始","却","专","状","育","厂","京","识","适","属","圆","包","火","住","调","满","县","局","照","参","红","细","引","听","该","铁","价","严","首","底","液","官","德","随","病","苏","失","尔","死","讲","配","女","黄","推","显","谈","罪","神","艺","呢","席","含","企","望","密","批","营","项","防","举","球","英","氧","势","告","李","台","落","木","帮","轮","破","亚","师","围","注","远","字","材","排","供","河","态","封","另","施","减","树","溶","怎","止","案","言","士","均","武","固","叶","鱼","波","视","仅","费","紧","爱","左","章","早","朝","害","续","轻","服","试","食","充","兵","源","判","护","司","足","某","练","差","致","板","田","降","黑","犯","负","击","范","继","兴","似","余","坚","曲","输","修","故","城","夫","够","送","笔","船","占","右","财","吃","富","春","职","觉","汉","画","功","巴","跟","虽","杂","飞","检","吸","助","升","阳","互","初","创","抗","考","投","坏","策","古","径","换","未","跑","留","钢","曾","端","责","站","简","述","钱","副","尽","帝","射","草","冲","承","独","令","限","阿","宣","环","双","请","超","微","让","控","州","良","轴","找","否","纪","益","依","优","顶","础","载","倒","房","突","坐","粉","敌","略","客","袁","冷","胜","绝","析","块","剂","测","丝","协","诉","念","陈","仍","罗","盐","友","洋","错","苦","夜","刑","移","频","逐","靠","混","母","短","皮","终","聚","汽","村","云","哪","既","距","卫","停","烈","央","察","烧","迅","境","若","印","洲","刻","括","激","孔","搞","甚","室","待","核","校","散","侵","吧","甲","游","久","菜","味","旧","模","湖","货","损","预","阻","毫","普","稳","乙","妈","植","息","扩","银","语","挥","酒","守","拿","序","纸","医","缺","雨","吗","针","刘","啊","急","唱","误","训","愿","审","附","获","茶","鲜","粮","斤","孩","脱","硫","肥","善","龙","演","父","渐","血","欢","械","掌","歌","沙","刚","攻","谓","盾","讨","晚","粒","乱","燃","矛","乎","杀","药","宁","鲁","贵","钟","煤","读","班","伯","香","介","迫","句","丰","培","握","兰","担","弦","蛋","沉","假","穿","执","答","乐","谁","顺","烟","缩","征","脸","喜","松","脚","困","异","免","背","星","福","买","染","井","概","慢","怕","磁","倍","祖","皇","促","静","补","评","翻","肉","践","尼","衣","宽","扬","棉","希","伤","操","垂","秋","宜","氢","套","督","振","架","亮","末","宪","庆","编","牛","触","映","雷","销","诗","座","居","抓","裂","胞","呼","娘","景","威","绿","晶","厚","盟","衡","鸡","孙","延","危","胶","屋","乡","临","陆","顾","掉","呀","灯","岁","措","束","耐","剧","玉","赵","跳","哥","季","课","凯","胡","额","款","绍","卷","齐","伟","蒸","殖","永","宗","苗","川","炉","岩","弱","零","杨","奏","沿","露","杆","探","滑","镇","饭","浓","航","怀","赶","库","夺","伊","灵","税","途","灭","赛","归","召","鼓","播","盘","裁","险","康","唯","录","菌","纯","借","糖","盖","横","符","私","努","堂","域","枪","润","幅","哈","竟","熟","虫","泽","脑","壤","碳","欧","遍","侧","寨","敢","彻","虑","斜","薄","庭","纳","弹","饲","伸","折","麦","湿","暗","荷","瓦","塞","床","筑","恶","户","访","塔","奇","透","梁","刀","旋","迹","卡","氯","遇","份","毒","泥","退","洗","摆","灰","彩","卖","耗","夏","择","忙","铜","献","硬","予","繁","圈","雪","函","亦","抽","篇","阵","阴","丁","尺","追","堆","雄","迎","泛","爸","楼","避","谋","吨","野","猪","旗","累","偏","典","馆","索","秦","脂","潮","爷","豆","忽","托","惊","塑","遗","愈","朱","替","纤","粗","倾","尚","痛","楚","谢","奋","购","磨","君","池","旁","碎","骨","监","捕","弟","暴","割","贯","殊","释","词","亡","壁","顿","宝","午","尘","闻","揭","炮","残","冬","桥","妇","警","综","招","吴","付","浮","遭","徐","您","摇","谷","赞","箱","隔","订","男","吹","园","纷","唐","败","宋","玻","巨","耕","坦","荣","闭","湾","键","凡","驻","锅","救","恩","剥","凝","碱","齿","截","炼","麻","纺","禁","废","盛","版","缓","净","睛","昌","婚","涉","筒","嘴","插","岸","朗","庄","街","藏","姑","贸","腐","奴","啦","惯","乘","伙","恢","匀","纱","扎","辩","耳","彪","臣","亿","璃","抵","脉","秀","萨","俄","网","舞","店","喷","纵","寸","汗","挂","洪","贺","闪","柬","爆","烯","津","稻","墙","软","勇","像","滚","厘","蒙","芳","肯","坡","柱","荡","腿","仪","旅","尾","轧","冰","贡","登","黎","削","钻","勒","逃","障","氨","郭","峰","币","港","伏","轨","亩","毕","擦","莫","刺","浪","秘","援","株","健","售","股","岛","甘","泡","睡","童","铸","汤","阀","休","汇","舍","牧","绕","炸","哲","磷","绩","朋","淡","尖","启","陷","柴","呈","徒","颜","泪","稍","忘","泵","蓝","拖","洞","授","镜","辛","壮","锋","贫","虚","弯","摩","泰","幼","廷","尊","窗","纲","弄","隶","疑","氏","宫","姐","震","瑞","怪","尤","琴","循","描","膜","违","夹","腰","缘","珠","穷","森","枝","竹","沟","催","绳","忆","邦","剩","幸","浆","栏","拥","牙","贮","礼","滤","钠","纹","罢","拍","咱","喊","袖","埃","勤","罚","焦","潜","伍","墨","欲","缝","姓","刊","饱","仿","奖","铝","鬼","丽","跨","默","挖","链","扫","喝","袋","炭","污","幕","诸","弧","励","梅","奶","洁","灾","舟","鉴","苯","讼","抱","毁","懂","寒","智","埔","寄","届","跃","渡","挑","丹","艰","贝","碰","拔","爹","戴","码","梦","芽","熔","赤","渔","哭","敬","颗","奔","铅","仲","虎","稀","妹","乏","珍","申","桌","遵","允","隆","螺","仓","魏","锐","晓","氮","兼","隐","碍","赫","拨","忠","肃","缸","牵","抢","博","巧","壳","兄","杜","讯","诚","碧","祥","柯","页","巡","矩","悲","灌","龄","伦","票","寻","桂","铺","圣","恐","恰","郑","趣","抬","荒","腾","贴","柔","滴","猛","阔","辆","妻","填","撤","储","签","闹","扰","紫","砂","递","戏","吊","陶","伐","喂","疗","瓶","婆","抚","臂","摸","忍","虾","蜡","邻","胸","巩","挤","偶","弃","槽","劲","乳","邓","吉","仁","烂","砖","租","乌","舰","伴","瓜","浅","丙","暂","燥","橡","柳","迷","暖","牌","秧","胆","详","簧","踏","瓷","谱","呆","宾","糊","洛","辉","愤","竞","隙","怒","粘","乃","绪","肩","籍","敏","涂","熙","皆","侦","悬","掘","享","纠","醒","狂","锁","淀","恨","牲","霸","爬","赏","逆","玩","陵","祝","秒","浙","貌","役","彼","悉","鸭","趋","凤","晨","畜","辈","秩","卵","署","梯","炎","滩","棋","驱","筛","峡","冒","啥","寿","译","浸","泉","帽","迟","硅","疆","贷","漏","稿","冠","嫩","胁","芯","牢","叛","蚀","奥","鸣","岭","羊","凭","串","塘","绘","酵","融","盆","锡","庙","筹","冻","辅","摄","袭","筋","拒","僚","旱","钾","鸟","漆","沈","眉","疏","添","棒","穗","硝","韩","逼","扭","侨","凉","挺","碗","栽","炒","杯","患","馏","劝","豪","辽","勃","鸿","旦","吏","拜","狗","埋","辊","掩","饮","搬","骂","辞","勾","扣","估","蒋","绒","雾","丈","朵","姆","拟","宇","辑","陕","雕","偿","蓄","崇","剪","倡","厅","咬","驶","薯","刷","斥","番","赋","奉","佛","浇","漫","曼","扇","钙","桃","扶","仔","返","俗","亏","腔","鞋","棱","覆","框","悄","叔","撞","骗","勘","旺","沸","孤","吐","孟","渠","屈","疾","妙","惜","仰","狠","胀","谐","抛","霉","桑","岗","嘛","衰","盗","渗","脏","赖","涌","甜","曹","阅","肌","哩","厉","烃","纬","毅","昨","伪","症","煮","叹","钉","搭","茎","笼","酷","偷","弓","锥","恒","杰","坑","鼻","翼","纶","叙","狱","逮","罐","络","棚","抑","膨","蔬","寺","骤","穆","冶","枯","册","尸","凸","绅","坯","牺","焰","轰","欣","晋","瘦","御","锭","锦","丧","旬","锻","垄","搜","扑","邀","亭","酯","迈","舒","脆","酶","闲","忧","酚","顽","羽","涨","卸","仗","陪","辟","惩","杭","姚","肚","捉","飘","漂","昆","欺","吾","郎","烷","汁","呵","饰","萧","雅","邮","迁","燕","撒","姻","赴","宴","烦","债","帐","斑","铃","旨","醇","董","饼","雏","姿","拌","傅","腹","妥","揉","贤","拆","歪","葡","胺","丢","浩","徽","昂","垫","挡","览","贪","慰","缴","汪","慌","冯","诺","姜","谊","凶","劣","诬","耀","昏","躺","盈","骑","乔","溪","丛","卢","抹","闷","咨","刮","驾","缆","悟","摘","铒","掷","颇","幻","柄","惠","惨","佳","仇","腊","窝","涤","剑","瞧","堡","泼","葱","罩","霍","捞","胎","苍","滨","俩","捅","湘","砍","霞","邵","萄","疯","淮","遂","熊","粪","烘","宿","档","戈","驳","嫂","裕","徙","箭","捐","肠","撑","晒","辨","殿","莲","摊","搅","酱","屏","疫","哀","蔡","堵","沫","皱","畅","叠","阁","莱","敲","辖","钩","痕","坝","巷","饿","祸","丘","玄","溜","曰","逻","彭","尝","卿","妨","艇","吞","韦","怨","矮","歇"]' + ); + }, + 12359: e => { + "use strict"; + e.exports = JSON.parse( + '["的","一","是","在","不","了","有","和","人","這","中","大","為","上","個","國","我","以","要","他","時","來","用","們","生","到","作","地","於","出","就","分","對","成","會","可","主","發","年","動","同","工","也","能","下","過","子","說","產","種","面","而","方","後","多","定","行","學","法","所","民","得","經","十","三","之","進","著","等","部","度","家","電","力","裡","如","水","化","高","自","二","理","起","小","物","現","實","加","量","都","兩","體","制","機","當","使","點","從","業","本","去","把","性","好","應","開","它","合","還","因","由","其","些","然","前","外","天","政","四","日","那","社","義","事","平","形","相","全","表","間","樣","與","關","各","重","新","線","內","數","正","心","反","你","明","看","原","又","麼","利","比","或","但","質","氣","第","向","道","命","此","變","條","只","沒","結","解","問","意","建","月","公","無","系","軍","很","情","者","最","立","代","想","已","通","並","提","直","題","黨","程","展","五","果","料","象","員","革","位","入","常","文","總","次","品","式","活","設","及","管","特","件","長","求","老","頭","基","資","邊","流","路","級","少","圖","山","統","接","知","較","將","組","見","計","別","她","手","角","期","根","論","運","農","指","幾","九","區","強","放","決","西","被","幹","做","必","戰","先","回","則","任","取","據","處","隊","南","給","色","光","門","即","保","治","北","造","百","規","熱","領","七","海","口","東","導","器","壓","志","世","金","增","爭","濟","階","油","思","術","極","交","受","聯","什","認","六","共","權","收","證","改","清","美","再","採","轉","更","單","風","切","打","白","教","速","花","帶","安","場","身","車","例","真","務","具","萬","每","目","至","達","走","積","示","議","聲","報","鬥","完","類","八","離","華","名","確","才","科","張","信","馬","節","話","米","整","空","元","況","今","集","溫","傳","土","許","步","群","廣","石","記","需","段","研","界","拉","林","律","叫","且","究","觀","越","織","裝","影","算","低","持","音","眾","書","布","复","容","兒","須","際","商","非","驗","連","斷","深","難","近","礦","千","週","委","素","技","備","半","辦","青","省","列","習","響","約","支","般","史","感","勞","便","團","往","酸","歷","市","克","何","除","消","構","府","稱","太","準","精","值","號","率","族","維","劃","選","標","寫","存","候","毛","親","快","效","斯","院","查","江","型","眼","王","按","格","養","易","置","派","層","片","始","卻","專","狀","育","廠","京","識","適","屬","圓","包","火","住","調","滿","縣","局","照","參","紅","細","引","聽","該","鐵","價","嚴","首","底","液","官","德","隨","病","蘇","失","爾","死","講","配","女","黃","推","顯","談","罪","神","藝","呢","席","含","企","望","密","批","營","項","防","舉","球","英","氧","勢","告","李","台","落","木","幫","輪","破","亞","師","圍","注","遠","字","材","排","供","河","態","封","另","施","減","樹","溶","怎","止","案","言","士","均","武","固","葉","魚","波","視","僅","費","緊","愛","左","章","早","朝","害","續","輕","服","試","食","充","兵","源","判","護","司","足","某","練","差","致","板","田","降","黑","犯","負","擊","范","繼","興","似","餘","堅","曲","輸","修","故","城","夫","夠","送","筆","船","佔","右","財","吃","富","春","職","覺","漢","畫","功","巴","跟","雖","雜","飛","檢","吸","助","昇","陽","互","初","創","抗","考","投","壞","策","古","徑","換","未","跑","留","鋼","曾","端","責","站","簡","述","錢","副","盡","帝","射","草","衝","承","獨","令","限","阿","宣","環","雙","請","超","微","讓","控","州","良","軸","找","否","紀","益","依","優","頂","礎","載","倒","房","突","坐","粉","敵","略","客","袁","冷","勝","絕","析","塊","劑","測","絲","協","訴","念","陳","仍","羅","鹽","友","洋","錯","苦","夜","刑","移","頻","逐","靠","混","母","短","皮","終","聚","汽","村","雲","哪","既","距","衛","停","烈","央","察","燒","迅","境","若","印","洲","刻","括","激","孔","搞","甚","室","待","核","校","散","侵","吧","甲","遊","久","菜","味","舊","模","湖","貨","損","預","阻","毫","普","穩","乙","媽","植","息","擴","銀","語","揮","酒","守","拿","序","紙","醫","缺","雨","嗎","針","劉","啊","急","唱","誤","訓","願","審","附","獲","茶","鮮","糧","斤","孩","脫","硫","肥","善","龍","演","父","漸","血","歡","械","掌","歌","沙","剛","攻","謂","盾","討","晚","粒","亂","燃","矛","乎","殺","藥","寧","魯","貴","鐘","煤","讀","班","伯","香","介","迫","句","豐","培","握","蘭","擔","弦","蛋","沉","假","穿","執","答","樂","誰","順","煙","縮","徵","臉","喜","松","腳","困","異","免","背","星","福","買","染","井","概","慢","怕","磁","倍","祖","皇","促","靜","補","評","翻","肉","踐","尼","衣","寬","揚","棉","希","傷","操","垂","秋","宜","氫","套","督","振","架","亮","末","憲","慶","編","牛","觸","映","雷","銷","詩","座","居","抓","裂","胞","呼","娘","景","威","綠","晶","厚","盟","衡","雞","孫","延","危","膠","屋","鄉","臨","陸","顧","掉","呀","燈","歲","措","束","耐","劇","玉","趙","跳","哥","季","課","凱","胡","額","款","紹","卷","齊","偉","蒸","殖","永","宗","苗","川","爐","岩","弱","零","楊","奏","沿","露","桿","探","滑","鎮","飯","濃","航","懷","趕","庫","奪","伊","靈","稅","途","滅","賽","歸","召","鼓","播","盤","裁","險","康","唯","錄","菌","純","借","糖","蓋","橫","符","私","努","堂","域","槍","潤","幅","哈","竟","熟","蟲","澤","腦","壤","碳","歐","遍","側","寨","敢","徹","慮","斜","薄","庭","納","彈","飼","伸","折","麥","濕","暗","荷","瓦","塞","床","築","惡","戶","訪","塔","奇","透","梁","刀","旋","跡","卡","氯","遇","份","毒","泥","退","洗","擺","灰","彩","賣","耗","夏","擇","忙","銅","獻","硬","予","繁","圈","雪","函","亦","抽","篇","陣","陰","丁","尺","追","堆","雄","迎","泛","爸","樓","避","謀","噸","野","豬","旗","累","偏","典","館","索","秦","脂","潮","爺","豆","忽","托","驚","塑","遺","愈","朱","替","纖","粗","傾","尚","痛","楚","謝","奮","購","磨","君","池","旁","碎","骨","監","捕","弟","暴","割","貫","殊","釋","詞","亡","壁","頓","寶","午","塵","聞","揭","炮","殘","冬","橋","婦","警","綜","招","吳","付","浮","遭","徐","您","搖","谷","贊","箱","隔","訂","男","吹","園","紛","唐","敗","宋","玻","巨","耕","坦","榮","閉","灣","鍵","凡","駐","鍋","救","恩","剝","凝","鹼","齒","截","煉","麻","紡","禁","廢","盛","版","緩","淨","睛","昌","婚","涉","筒","嘴","插","岸","朗","莊","街","藏","姑","貿","腐","奴","啦","慣","乘","夥","恢","勻","紗","扎","辯","耳","彪","臣","億","璃","抵","脈","秀","薩","俄","網","舞","店","噴","縱","寸","汗","掛","洪","賀","閃","柬","爆","烯","津","稻","牆","軟","勇","像","滾","厘","蒙","芳","肯","坡","柱","盪","腿","儀","旅","尾","軋","冰","貢","登","黎","削","鑽","勒","逃","障","氨","郭","峰","幣","港","伏","軌","畝","畢","擦","莫","刺","浪","秘","援","株","健","售","股","島","甘","泡","睡","童","鑄","湯","閥","休","匯","舍","牧","繞","炸","哲","磷","績","朋","淡","尖","啟","陷","柴","呈","徒","顏","淚","稍","忘","泵","藍","拖","洞","授","鏡","辛","壯","鋒","貧","虛","彎","摩","泰","幼","廷","尊","窗","綱","弄","隸","疑","氏","宮","姐","震","瑞","怪","尤","琴","循","描","膜","違","夾","腰","緣","珠","窮","森","枝","竹","溝","催","繩","憶","邦","剩","幸","漿","欄","擁","牙","貯","禮","濾","鈉","紋","罷","拍","咱","喊","袖","埃","勤","罰","焦","潛","伍","墨","欲","縫","姓","刊","飽","仿","獎","鋁","鬼","麗","跨","默","挖","鏈","掃","喝","袋","炭","污","幕","諸","弧","勵","梅","奶","潔","災","舟","鑑","苯","訟","抱","毀","懂","寒","智","埔","寄","屆","躍","渡","挑","丹","艱","貝","碰","拔","爹","戴","碼","夢","芽","熔","赤","漁","哭","敬","顆","奔","鉛","仲","虎","稀","妹","乏","珍","申","桌","遵","允","隆","螺","倉","魏","銳","曉","氮","兼","隱","礙","赫","撥","忠","肅","缸","牽","搶","博","巧","殼","兄","杜","訊","誠","碧","祥","柯","頁","巡","矩","悲","灌","齡","倫","票","尋","桂","鋪","聖","恐","恰","鄭","趣","抬","荒","騰","貼","柔","滴","猛","闊","輛","妻","填","撤","儲","簽","鬧","擾","紫","砂","遞","戲","吊","陶","伐","餵","療","瓶","婆","撫","臂","摸","忍","蝦","蠟","鄰","胸","鞏","擠","偶","棄","槽","勁","乳","鄧","吉","仁","爛","磚","租","烏","艦","伴","瓜","淺","丙","暫","燥","橡","柳","迷","暖","牌","秧","膽","詳","簧","踏","瓷","譜","呆","賓","糊","洛","輝","憤","競","隙","怒","粘","乃","緒","肩","籍","敏","塗","熙","皆","偵","懸","掘","享","糾","醒","狂","鎖","淀","恨","牲","霸","爬","賞","逆","玩","陵","祝","秒","浙","貌","役","彼","悉","鴨","趨","鳳","晨","畜","輩","秩","卵","署","梯","炎","灘","棋","驅","篩","峽","冒","啥","壽","譯","浸","泉","帽","遲","矽","疆","貸","漏","稿","冠","嫩","脅","芯","牢","叛","蝕","奧","鳴","嶺","羊","憑","串","塘","繪","酵","融","盆","錫","廟","籌","凍","輔","攝","襲","筋","拒","僚","旱","鉀","鳥","漆","沈","眉","疏","添","棒","穗","硝","韓","逼","扭","僑","涼","挺","碗","栽","炒","杯","患","餾","勸","豪","遼","勃","鴻","旦","吏","拜","狗","埋","輥","掩","飲","搬","罵","辭","勾","扣","估","蔣","絨","霧","丈","朵","姆","擬","宇","輯","陝","雕","償","蓄","崇","剪","倡","廳","咬","駛","薯","刷","斥","番","賦","奉","佛","澆","漫","曼","扇","鈣","桃","扶","仔","返","俗","虧","腔","鞋","棱","覆","框","悄","叔","撞","騙","勘","旺","沸","孤","吐","孟","渠","屈","疾","妙","惜","仰","狠","脹","諧","拋","黴","桑","崗","嘛","衰","盜","滲","臟","賴","湧","甜","曹","閱","肌","哩","厲","烴","緯","毅","昨","偽","症","煮","嘆","釘","搭","莖","籠","酷","偷","弓","錐","恆","傑","坑","鼻","翼","綸","敘","獄","逮","罐","絡","棚","抑","膨","蔬","寺","驟","穆","冶","枯","冊","屍","凸","紳","坯","犧","焰","轟","欣","晉","瘦","禦","錠","錦","喪","旬","鍛","壟","搜","撲","邀","亭","酯","邁","舒","脆","酶","閒","憂","酚","頑","羽","漲","卸","仗","陪","闢","懲","杭","姚","肚","捉","飄","漂","昆","欺","吾","郎","烷","汁","呵","飾","蕭","雅","郵","遷","燕","撒","姻","赴","宴","煩","債","帳","斑","鈴","旨","醇","董","餅","雛","姿","拌","傅","腹","妥","揉","賢","拆","歪","葡","胺","丟","浩","徽","昂","墊","擋","覽","貪","慰","繳","汪","慌","馮","諾","姜","誼","兇","劣","誣","耀","昏","躺","盈","騎","喬","溪","叢","盧","抹","悶","諮","刮","駕","纜","悟","摘","鉺","擲","頗","幻","柄","惠","慘","佳","仇","臘","窩","滌","劍","瞧","堡","潑","蔥","罩","霍","撈","胎","蒼","濱","倆","捅","湘","砍","霞","邵","萄","瘋","淮","遂","熊","糞","烘","宿","檔","戈","駁","嫂","裕","徙","箭","捐","腸","撐","曬","辨","殿","蓮","攤","攪","醬","屏","疫","哀","蔡","堵","沫","皺","暢","疊","閣","萊","敲","轄","鉤","痕","壩","巷","餓","禍","丘","玄","溜","曰","邏","彭","嘗","卿","妨","艇","吞","韋","怨","矮","歇"]' + ); + }, + 19170: e => { + "use strict"; + e.exports = JSON.parse( + '["abandon","ability","able","about","above","absent","absorb","abstract","absurd","abuse","access","accident","account","accuse","achieve","acid","acoustic","acquire","across","act","action","actor","actress","actual","adapt","add","addict","address","adjust","admit","adult","advance","advice","aerobic","affair","afford","afraid","again","age","agent","agree","ahead","aim","air","airport","aisle","alarm","album","alcohol","alert","alien","all","alley","allow","almost","alone","alpha","already","also","alter","always","amateur","amazing","among","amount","amused","analyst","anchor","ancient","anger","angle","angry","animal","ankle","announce","annual","another","answer","antenna","antique","anxiety","any","apart","apology","appear","apple","approve","april","arch","arctic","area","arena","argue","arm","armed","armor","army","around","arrange","arrest","arrive","arrow","art","artefact","artist","artwork","ask","aspect","assault","asset","assist","assume","asthma","athlete","atom","attack","attend","attitude","attract","auction","audit","august","aunt","author","auto","autumn","average","avocado","avoid","awake","aware","away","awesome","awful","awkward","axis","baby","bachelor","bacon","badge","bag","balance","balcony","ball","bamboo","banana","banner","bar","barely","bargain","barrel","base","basic","basket","battle","beach","bean","beauty","because","become","beef","before","begin","behave","behind","believe","below","belt","bench","benefit","best","betray","better","between","beyond","bicycle","bid","bike","bind","biology","bird","birth","bitter","black","blade","blame","blanket","blast","bleak","bless","blind","blood","blossom","blouse","blue","blur","blush","board","boat","body","boil","bomb","bone","bonus","book","boost","border","boring","borrow","boss","bottom","bounce","box","boy","bracket","brain","brand","brass","brave","bread","breeze","brick","bridge","brief","bright","bring","brisk","broccoli","broken","bronze","broom","brother","brown","brush","bubble","buddy","budget","buffalo","build","bulb","bulk","bullet","bundle","bunker","burden","burger","burst","bus","business","busy","butter","buyer","buzz","cabbage","cabin","cable","cactus","cage","cake","call","calm","camera","camp","can","canal","cancel","candy","cannon","canoe","canvas","canyon","capable","capital","captain","car","carbon","card","cargo","carpet","carry","cart","case","cash","casino","castle","casual","cat","catalog","catch","category","cattle","caught","cause","caution","cave","ceiling","celery","cement","census","century","cereal","certain","chair","chalk","champion","change","chaos","chapter","charge","chase","chat","cheap","check","cheese","chef","cherry","chest","chicken","chief","child","chimney","choice","choose","chronic","chuckle","chunk","churn","cigar","cinnamon","circle","citizen","city","civil","claim","clap","clarify","claw","clay","clean","clerk","clever","click","client","cliff","climb","clinic","clip","clock","clog","close","cloth","cloud","clown","club","clump","cluster","clutch","coach","coast","coconut","code","coffee","coil","coin","collect","color","column","combine","come","comfort","comic","common","company","concert","conduct","confirm","congress","connect","consider","control","convince","cook","cool","copper","copy","coral","core","corn","correct","cost","cotton","couch","country","couple","course","cousin","cover","coyote","crack","cradle","craft","cram","crane","crash","crater","crawl","crazy","cream","credit","creek","crew","cricket","crime","crisp","critic","crop","cross","crouch","crowd","crucial","cruel","cruise","crumble","crunch","crush","cry","crystal","cube","culture","cup","cupboard","curious","current","curtain","curve","cushion","custom","cute","cycle","dad","damage","damp","dance","danger","daring","dash","daughter","dawn","day","deal","debate","debris","decade","december","decide","decline","decorate","decrease","deer","defense","define","defy","degree","delay","deliver","demand","demise","denial","dentist","deny","depart","depend","deposit","depth","deputy","derive","describe","desert","design","desk","despair","destroy","detail","detect","develop","device","devote","diagram","dial","diamond","diary","dice","diesel","diet","differ","digital","dignity","dilemma","dinner","dinosaur","direct","dirt","disagree","discover","disease","dish","dismiss","disorder","display","distance","divert","divide","divorce","dizzy","doctor","document","dog","doll","dolphin","domain","donate","donkey","donor","door","dose","double","dove","draft","dragon","drama","drastic","draw","dream","dress","drift","drill","drink","drip","drive","drop","drum","dry","duck","dumb","dune","during","dust","dutch","duty","dwarf","dynamic","eager","eagle","early","earn","earth","easily","east","easy","echo","ecology","economy","edge","edit","educate","effort","egg","eight","either","elbow","elder","electric","elegant","element","elephant","elevator","elite","else","embark","embody","embrace","emerge","emotion","employ","empower","empty","enable","enact","end","endless","endorse","enemy","energy","enforce","engage","engine","enhance","enjoy","enlist","enough","enrich","enroll","ensure","enter","entire","entry","envelope","episode","equal","equip","era","erase","erode","erosion","error","erupt","escape","essay","essence","estate","eternal","ethics","evidence","evil","evoke","evolve","exact","example","excess","exchange","excite","exclude","excuse","execute","exercise","exhaust","exhibit","exile","exist","exit","exotic","expand","expect","expire","explain","expose","express","extend","extra","eye","eyebrow","fabric","face","faculty","fade","faint","faith","fall","false","fame","family","famous","fan","fancy","fantasy","farm","fashion","fat","fatal","father","fatigue","fault","favorite","feature","february","federal","fee","feed","feel","female","fence","festival","fetch","fever","few","fiber","fiction","field","figure","file","film","filter","final","find","fine","finger","finish","fire","firm","first","fiscal","fish","fit","fitness","fix","flag","flame","flash","flat","flavor","flee","flight","flip","float","flock","floor","flower","fluid","flush","fly","foam","focus","fog","foil","fold","follow","food","foot","force","forest","forget","fork","fortune","forum","forward","fossil","foster","found","fox","fragile","frame","frequent","fresh","friend","fringe","frog","front","frost","frown","frozen","fruit","fuel","fun","funny","furnace","fury","future","gadget","gain","galaxy","gallery","game","gap","garage","garbage","garden","garlic","garment","gas","gasp","gate","gather","gauge","gaze","general","genius","genre","gentle","genuine","gesture","ghost","giant","gift","giggle","ginger","giraffe","girl","give","glad","glance","glare","glass","glide","glimpse","globe","gloom","glory","glove","glow","glue","goat","goddess","gold","good","goose","gorilla","gospel","gossip","govern","gown","grab","grace","grain","grant","grape","grass","gravity","great","green","grid","grief","grit","grocery","group","grow","grunt","guard","guess","guide","guilt","guitar","gun","gym","habit","hair","half","hammer","hamster","hand","happy","harbor","hard","harsh","harvest","hat","have","hawk","hazard","head","health","heart","heavy","hedgehog","height","hello","helmet","help","hen","hero","hidden","high","hill","hint","hip","hire","history","hobby","hockey","hold","hole","holiday","hollow","home","honey","hood","hope","horn","horror","horse","hospital","host","hotel","hour","hover","hub","huge","human","humble","humor","hundred","hungry","hunt","hurdle","hurry","hurt","husband","hybrid","ice","icon","idea","identify","idle","ignore","ill","illegal","illness","image","imitate","immense","immune","impact","impose","improve","impulse","inch","include","income","increase","index","indicate","indoor","industry","infant","inflict","inform","inhale","inherit","initial","inject","injury","inmate","inner","innocent","input","inquiry","insane","insect","inside","inspire","install","intact","interest","into","invest","invite","involve","iron","island","isolate","issue","item","ivory","jacket","jaguar","jar","jazz","jealous","jeans","jelly","jewel","job","join","joke","journey","joy","judge","juice","jump","jungle","junior","junk","just","kangaroo","keen","keep","ketchup","key","kick","kid","kidney","kind","kingdom","kiss","kit","kitchen","kite","kitten","kiwi","knee","knife","knock","know","lab","label","labor","ladder","lady","lake","lamp","language","laptop","large","later","latin","laugh","laundry","lava","law","lawn","lawsuit","layer","lazy","leader","leaf","learn","leave","lecture","left","leg","legal","legend","leisure","lemon","lend","length","lens","leopard","lesson","letter","level","liar","liberty","library","license","life","lift","light","like","limb","limit","link","lion","liquid","list","little","live","lizard","load","loan","lobster","local","lock","logic","lonely","long","loop","lottery","loud","lounge","love","loyal","lucky","luggage","lumber","lunar","lunch","luxury","lyrics","machine","mad","magic","magnet","maid","mail","main","major","make","mammal","man","manage","mandate","mango","mansion","manual","maple","marble","march","margin","marine","market","marriage","mask","mass","master","match","material","math","matrix","matter","maximum","maze","meadow","mean","measure","meat","mechanic","medal","media","melody","melt","member","memory","mention","menu","mercy","merge","merit","merry","mesh","message","metal","method","middle","midnight","milk","million","mimic","mind","minimum","minor","minute","miracle","mirror","misery","miss","mistake","mix","mixed","mixture","mobile","model","modify","mom","moment","monitor","monkey","monster","month","moon","moral","more","morning","mosquito","mother","motion","motor","mountain","mouse","move","movie","much","muffin","mule","multiply","muscle","museum","mushroom","music","must","mutual","myself","mystery","myth","naive","name","napkin","narrow","nasty","nation","nature","near","neck","need","negative","neglect","neither","nephew","nerve","nest","net","network","neutral","never","news","next","nice","night","noble","noise","nominee","noodle","normal","north","nose","notable","note","nothing","notice","novel","now","nuclear","number","nurse","nut","oak","obey","object","oblige","obscure","observe","obtain","obvious","occur","ocean","october","odor","off","offer","office","often","oil","okay","old","olive","olympic","omit","once","one","onion","online","only","open","opera","opinion","oppose","option","orange","orbit","orchard","order","ordinary","organ","orient","original","orphan","ostrich","other","outdoor","outer","output","outside","oval","oven","over","own","owner","oxygen","oyster","ozone","pact","paddle","page","pair","palace","palm","panda","panel","panic","panther","paper","parade","parent","park","parrot","party","pass","patch","path","patient","patrol","pattern","pause","pave","payment","peace","peanut","pear","peasant","pelican","pen","penalty","pencil","people","pepper","perfect","permit","person","pet","phone","photo","phrase","physical","piano","picnic","picture","piece","pig","pigeon","pill","pilot","pink","pioneer","pipe","pistol","pitch","pizza","place","planet","plastic","plate","play","please","pledge","pluck","plug","plunge","poem","poet","point","polar","pole","police","pond","pony","pool","popular","portion","position","possible","post","potato","pottery","poverty","powder","power","practice","praise","predict","prefer","prepare","present","pretty","prevent","price","pride","primary","print","priority","prison","private","prize","problem","process","produce","profit","program","project","promote","proof","property","prosper","protect","proud","provide","public","pudding","pull","pulp","pulse","pumpkin","punch","pupil","puppy","purchase","purity","purpose","purse","push","put","puzzle","pyramid","quality","quantum","quarter","question","quick","quit","quiz","quote","rabbit","raccoon","race","rack","radar","radio","rail","rain","raise","rally","ramp","ranch","random","range","rapid","rare","rate","rather","raven","raw","razor","ready","real","reason","rebel","rebuild","recall","receive","recipe","record","recycle","reduce","reflect","reform","refuse","region","regret","regular","reject","relax","release","relief","rely","remain","remember","remind","remove","render","renew","rent","reopen","repair","repeat","replace","report","require","rescue","resemble","resist","resource","response","result","retire","retreat","return","reunion","reveal","review","reward","rhythm","rib","ribbon","rice","rich","ride","ridge","rifle","right","rigid","ring","riot","ripple","risk","ritual","rival","river","road","roast","robot","robust","rocket","romance","roof","rookie","room","rose","rotate","rough","round","route","royal","rubber","rude","rug","rule","run","runway","rural","sad","saddle","sadness","safe","sail","salad","salmon","salon","salt","salute","same","sample","sand","satisfy","satoshi","sauce","sausage","save","say","scale","scan","scare","scatter","scene","scheme","school","science","scissors","scorpion","scout","scrap","screen","script","scrub","sea","search","season","seat","second","secret","section","security","seed","seek","segment","select","sell","seminar","senior","sense","sentence","series","service","session","settle","setup","seven","shadow","shaft","shallow","share","shed","shell","sheriff","shield","shift","shine","ship","shiver","shock","shoe","shoot","shop","short","shoulder","shove","shrimp","shrug","shuffle","shy","sibling","sick","side","siege","sight","sign","silent","silk","silly","silver","similar","simple","since","sing","siren","sister","situate","six","size","skate","sketch","ski","skill","skin","skirt","skull","slab","slam","sleep","slender","slice","slide","slight","slim","slogan","slot","slow","slush","small","smart","smile","smoke","smooth","snack","snake","snap","sniff","snow","soap","soccer","social","sock","soda","soft","solar","soldier","solid","solution","solve","someone","song","soon","sorry","sort","soul","sound","soup","source","south","space","spare","spatial","spawn","speak","special","speed","spell","spend","sphere","spice","spider","spike","spin","spirit","split","spoil","sponsor","spoon","sport","spot","spray","spread","spring","spy","square","squeeze","squirrel","stable","stadium","staff","stage","stairs","stamp","stand","start","state","stay","steak","steel","stem","step","stereo","stick","still","sting","stock","stomach","stone","stool","story","stove","strategy","street","strike","strong","struggle","student","stuff","stumble","style","subject","submit","subway","success","such","sudden","suffer","sugar","suggest","suit","summer","sun","sunny","sunset","super","supply","supreme","sure","surface","surge","surprise","surround","survey","suspect","sustain","swallow","swamp","swap","swarm","swear","sweet","swift","swim","swing","switch","sword","symbol","symptom","syrup","system","table","tackle","tag","tail","talent","talk","tank","tape","target","task","taste","tattoo","taxi","teach","team","tell","ten","tenant","tennis","tent","term","test","text","thank","that","theme","then","theory","there","they","thing","this","thought","three","thrive","throw","thumb","thunder","ticket","tide","tiger","tilt","timber","time","tiny","tip","tired","tissue","title","toast","tobacco","today","toddler","toe","together","toilet","token","tomato","tomorrow","tone","tongue","tonight","tool","tooth","top","topic","topple","torch","tornado","tortoise","toss","total","tourist","toward","tower","town","toy","track","trade","traffic","tragic","train","transfer","trap","trash","travel","tray","treat","tree","trend","trial","tribe","trick","trigger","trim","trip","trophy","trouble","truck","true","truly","trumpet","trust","truth","try","tube","tuition","tumble","tuna","tunnel","turkey","turn","turtle","twelve","twenty","twice","twin","twist","two","type","typical","ugly","umbrella","unable","unaware","uncle","uncover","under","undo","unfair","unfold","unhappy","uniform","unique","unit","universe","unknown","unlock","until","unusual","unveil","update","upgrade","uphold","upon","upper","upset","urban","urge","usage","use","used","useful","useless","usual","utility","vacant","vacuum","vague","valid","valley","valve","van","vanish","vapor","various","vast","vault","vehicle","velvet","vendor","venture","venue","verb","verify","version","very","vessel","veteran","viable","vibrant","vicious","victory","video","view","village","vintage","violin","virtual","virus","visa","visit","visual","vital","vivid","vocal","voice","void","volcano","volume","vote","voyage","wage","wagon","wait","walk","wall","walnut","want","warfare","warm","warrior","wash","wasp","waste","water","wave","way","wealth","weapon","wear","weasel","weather","web","wedding","weekend","weird","welcome","west","wet","whale","what","wheat","wheel","when","where","whip","whisper","wide","width","wife","wild","will","win","window","wine","wing","wink","winner","winter","wire","wisdom","wise","wish","witness","wolf","woman","wonder","wood","wool","word","work","world","worry","worth","wrap","wreck","wrestle","wrist","write","wrong","yard","year","yellow","you","young","youth","zebra","zero","zone","zoo"]' + ); + }, + 91949: e => { + "use strict"; + e.exports = JSON.parse( + '["abaisser","abandon","abdiquer","abeille","abolir","aborder","aboutir","aboyer","abrasif","abreuver","abriter","abroger","abrupt","absence","absolu","absurde","abusif","abyssal","académie","acajou","acarien","accabler","accepter","acclamer","accolade","accroche","accuser","acerbe","achat","acheter","aciduler","acier","acompte","acquérir","acronyme","acteur","actif","actuel","adepte","adéquat","adhésif","adjectif","adjuger","admettre","admirer","adopter","adorer","adoucir","adresse","adroit","adulte","adverbe","aérer","aéronef","affaire","affecter","affiche","affreux","affubler","agacer","agencer","agile","agiter","agrafer","agréable","agrume","aider","aiguille","ailier","aimable","aisance","ajouter","ajuster","alarmer","alchimie","alerte","algèbre","algue","aliéner","aliment","alléger","alliage","allouer","allumer","alourdir","alpaga","altesse","alvéole","amateur","ambigu","ambre","aménager","amertume","amidon","amiral","amorcer","amour","amovible","amphibie","ampleur","amusant","analyse","anaphore","anarchie","anatomie","ancien","anéantir","angle","angoisse","anguleux","animal","annexer","annonce","annuel","anodin","anomalie","anonyme","anormal","antenne","antidote","anxieux","apaiser","apéritif","aplanir","apologie","appareil","appeler","apporter","appuyer","aquarium","aqueduc","arbitre","arbuste","ardeur","ardoise","argent","arlequin","armature","armement","armoire","armure","arpenter","arracher","arriver","arroser","arsenic","artériel","article","aspect","asphalte","aspirer","assaut","asservir","assiette","associer","assurer","asticot","astre","astuce","atelier","atome","atrium","atroce","attaque","attentif","attirer","attraper","aubaine","auberge","audace","audible","augurer","aurore","automne","autruche","avaler","avancer","avarice","avenir","averse","aveugle","aviateur","avide","avion","aviser","avoine","avouer","avril","axial","axiome","badge","bafouer","bagage","baguette","baignade","balancer","balcon","baleine","balisage","bambin","bancaire","bandage","banlieue","bannière","banquier","barbier","baril","baron","barque","barrage","bassin","bastion","bataille","bateau","batterie","baudrier","bavarder","belette","bélier","belote","bénéfice","berceau","berger","berline","bermuda","besace","besogne","bétail","beurre","biberon","bicycle","bidule","bijou","bilan","bilingue","billard","binaire","biologie","biopsie","biotype","biscuit","bison","bistouri","bitume","bizarre","blafard","blague","blanchir","blessant","blinder","blond","bloquer","blouson","bobard","bobine","boire","boiser","bolide","bonbon","bondir","bonheur","bonifier","bonus","bordure","borne","botte","boucle","boueux","bougie","boulon","bouquin","bourse","boussole","boutique","boxeur","branche","brasier","brave","brebis","brèche","breuvage","bricoler","brigade","brillant","brioche","brique","brochure","broder","bronzer","brousse","broyeur","brume","brusque","brutal","bruyant","buffle","buisson","bulletin","bureau","burin","bustier","butiner","butoir","buvable","buvette","cabanon","cabine","cachette","cadeau","cadre","caféine","caillou","caisson","calculer","calepin","calibre","calmer","calomnie","calvaire","camarade","caméra","camion","campagne","canal","caneton","canon","cantine","canular","capable","caporal","caprice","capsule","capter","capuche","carabine","carbone","caresser","caribou","carnage","carotte","carreau","carton","cascade","casier","casque","cassure","causer","caution","cavalier","caverne","caviar","cédille","ceinture","céleste","cellule","cendrier","censurer","central","cercle","cérébral","cerise","cerner","cerveau","cesser","chagrin","chaise","chaleur","chambre","chance","chapitre","charbon","chasseur","chaton","chausson","chavirer","chemise","chenille","chéquier","chercher","cheval","chien","chiffre","chignon","chimère","chiot","chlorure","chocolat","choisir","chose","chouette","chrome","chute","cigare","cigogne","cimenter","cinéma","cintrer","circuler","cirer","cirque","citerne","citoyen","citron","civil","clairon","clameur","claquer","classe","clavier","client","cligner","climat","clivage","cloche","clonage","cloporte","cobalt","cobra","cocasse","cocotier","coder","codifier","coffre","cogner","cohésion","coiffer","coincer","colère","colibri","colline","colmater","colonel","combat","comédie","commande","compact","concert","conduire","confier","congeler","connoter","consonne","contact","convexe","copain","copie","corail","corbeau","cordage","corniche","corpus","correct","cortège","cosmique","costume","coton","coude","coupure","courage","couteau","couvrir","coyote","crabe","crainte","cravate","crayon","créature","créditer","crémeux","creuser","crevette","cribler","crier","cristal","critère","croire","croquer","crotale","crucial","cruel","crypter","cubique","cueillir","cuillère","cuisine","cuivre","culminer","cultiver","cumuler","cupide","curatif","curseur","cyanure","cycle","cylindre","cynique","daigner","damier","danger","danseur","dauphin","débattre","débiter","déborder","débrider","débutant","décaler","décembre","déchirer","décider","déclarer","décorer","décrire","décupler","dédale","déductif","déesse","défensif","défiler","défrayer","dégager","dégivrer","déglutir","dégrafer","déjeuner","délice","déloger","demander","demeurer","démolir","dénicher","dénouer","dentelle","dénuder","départ","dépenser","déphaser","déplacer","déposer","déranger","dérober","désastre","descente","désert","désigner","désobéir","dessiner","destrier","détacher","détester","détourer","détresse","devancer","devenir","deviner","devoir","diable","dialogue","diamant","dicter","différer","digérer","digital","digne","diluer","dimanche","diminuer","dioxyde","directif","diriger","discuter","disposer","dissiper","distance","divertir","diviser","docile","docteur","dogme","doigt","domaine","domicile","dompter","donateur","donjon","donner","dopamine","dortoir","dorure","dosage","doseur","dossier","dotation","douanier","double","douceur","douter","doyen","dragon","draper","dresser","dribbler","droiture","duperie","duplexe","durable","durcir","dynastie","éblouir","écarter","écharpe","échelle","éclairer","éclipse","éclore","écluse","école","économie","écorce","écouter","écraser","écrémer","écrivain","écrou","écume","écureuil","édifier","éduquer","effacer","effectif","effigie","effort","effrayer","effusion","égaliser","égarer","éjecter","élaborer","élargir","électron","élégant","éléphant","élève","éligible","élitisme","éloge","élucider","éluder","emballer","embellir","embryon","émeraude","émission","emmener","émotion","émouvoir","empereur","employer","emporter","emprise","émulsion","encadrer","enchère","enclave","encoche","endiguer","endosser","endroit","enduire","énergie","enfance","enfermer","enfouir","engager","engin","englober","énigme","enjamber","enjeu","enlever","ennemi","ennuyeux","enrichir","enrobage","enseigne","entasser","entendre","entier","entourer","entraver","énumérer","envahir","enviable","envoyer","enzyme","éolien","épaissir","épargne","épatant","épaule","épicerie","épidémie","épier","épilogue","épine","épisode","épitaphe","époque","épreuve","éprouver","épuisant","équerre","équipe","ériger","érosion","erreur","éruption","escalier","espadon","espèce","espiègle","espoir","esprit","esquiver","essayer","essence","essieu","essorer","estime","estomac","estrade","étagère","étaler","étanche","étatique","éteindre","étendoir","éternel","éthanol","éthique","ethnie","étirer","étoffer","étoile","étonnant","étourdir","étrange","étroit","étude","euphorie","évaluer","évasion","éventail","évidence","éviter","évolutif","évoquer","exact","exagérer","exaucer","exceller","excitant","exclusif","excuse","exécuter","exemple","exercer","exhaler","exhorter","exigence","exiler","exister","exotique","expédier","explorer","exposer","exprimer","exquis","extensif","extraire","exulter","fable","fabuleux","facette","facile","facture","faiblir","falaise","fameux","famille","farceur","farfelu","farine","farouche","fasciner","fatal","fatigue","faucon","fautif","faveur","favori","fébrile","féconder","fédérer","félin","femme","fémur","fendoir","féodal","fermer","féroce","ferveur","festival","feuille","feutre","février","fiasco","ficeler","fictif","fidèle","figure","filature","filetage","filière","filleul","filmer","filou","filtrer","financer","finir","fiole","firme","fissure","fixer","flairer","flamme","flasque","flatteur","fléau","flèche","fleur","flexion","flocon","flore","fluctuer","fluide","fluvial","folie","fonderie","fongible","fontaine","forcer","forgeron","formuler","fortune","fossile","foudre","fougère","fouiller","foulure","fourmi","fragile","fraise","franchir","frapper","frayeur","frégate","freiner","frelon","frémir","frénésie","frère","friable","friction","frisson","frivole","froid","fromage","frontal","frotter","fruit","fugitif","fuite","fureur","furieux","furtif","fusion","futur","gagner","galaxie","galerie","gambader","garantir","gardien","garnir","garrigue","gazelle","gazon","géant","gélatine","gélule","gendarme","général","génie","genou","gentil","géologie","géomètre","géranium","germe","gestuel","geyser","gibier","gicler","girafe","givre","glace","glaive","glisser","globe","gloire","glorieux","golfeur","gomme","gonfler","gorge","gorille","goudron","gouffre","goulot","goupille","gourmand","goutte","graduel","graffiti","graine","grand","grappin","gratuit","gravir","grenat","griffure","griller","grimper","grogner","gronder","grotte","groupe","gruger","grutier","gruyère","guépard","guerrier","guide","guimauve","guitare","gustatif","gymnaste","gyrostat","habitude","hachoir","halte","hameau","hangar","hanneton","haricot","harmonie","harpon","hasard","hélium","hématome","herbe","hérisson","hermine","héron","hésiter","heureux","hiberner","hibou","hilarant","histoire","hiver","homard","hommage","homogène","honneur","honorer","honteux","horde","horizon","horloge","hormone","horrible","houleux","housse","hublot","huileux","humain","humble","humide","humour","hurler","hydromel","hygiène","hymne","hypnose","idylle","ignorer","iguane","illicite","illusion","image","imbiber","imiter","immense","immobile","immuable","impact","impérial","implorer","imposer","imprimer","imputer","incarner","incendie","incident","incliner","incolore","indexer","indice","inductif","inédit","ineptie","inexact","infini","infliger","informer","infusion","ingérer","inhaler","inhiber","injecter","injure","innocent","inoculer","inonder","inscrire","insecte","insigne","insolite","inspirer","instinct","insulter","intact","intense","intime","intrigue","intuitif","inutile","invasion","inventer","inviter","invoquer","ironique","irradier","irréel","irriter","isoler","ivoire","ivresse","jaguar","jaillir","jambe","janvier","jardin","jauger","jaune","javelot","jetable","jeton","jeudi","jeunesse","joindre","joncher","jongler","joueur","jouissif","journal","jovial","joyau","joyeux","jubiler","jugement","junior","jupon","juriste","justice","juteux","juvénile","kayak","kimono","kiosque","label","labial","labourer","lacérer","lactose","lagune","laine","laisser","laitier","lambeau","lamelle","lampe","lanceur","langage","lanterne","lapin","largeur","larme","laurier","lavabo","lavoir","lecture","légal","léger","légume","lessive","lettre","levier","lexique","lézard","liasse","libérer","libre","licence","licorne","liège","lièvre","ligature","ligoter","ligue","limer","limite","limonade","limpide","linéaire","lingot","lionceau","liquide","lisière","lister","lithium","litige","littoral","livreur","logique","lointain","loisir","lombric","loterie","louer","lourd","loutre","louve","loyal","lubie","lucide","lucratif","lueur","lugubre","luisant","lumière","lunaire","lundi","luron","lutter","luxueux","machine","magasin","magenta","magique","maigre","maillon","maintien","mairie","maison","majorer","malaxer","maléfice","malheur","malice","mallette","mammouth","mandater","maniable","manquant","manteau","manuel","marathon","marbre","marchand","mardi","maritime","marqueur","marron","marteler","mascotte","massif","matériel","matière","matraque","maudire","maussade","mauve","maximal","méchant","méconnu","médaille","médecin","méditer","méduse","meilleur","mélange","mélodie","membre","mémoire","menacer","mener","menhir","mensonge","mentor","mercredi","mérite","merle","messager","mesure","métal","météore","méthode","métier","meuble","miauler","microbe","miette","mignon","migrer","milieu","million","mimique","mince","minéral","minimal","minorer","minute","miracle","miroiter","missile","mixte","mobile","moderne","moelleux","mondial","moniteur","monnaie","monotone","monstre","montagne","monument","moqueur","morceau","morsure","mortier","moteur","motif","mouche","moufle","moulin","mousson","mouton","mouvant","multiple","munition","muraille","murène","murmure","muscle","muséum","musicien","mutation","muter","mutuel","myriade","myrtille","mystère","mythique","nageur","nappe","narquois","narrer","natation","nation","nature","naufrage","nautique","navire","nébuleux","nectar","néfaste","négation","négliger","négocier","neige","nerveux","nettoyer","neurone","neutron","neveu","niche","nickel","nitrate","niveau","noble","nocif","nocturne","noirceur","noisette","nomade","nombreux","nommer","normatif","notable","notifier","notoire","nourrir","nouveau","novateur","novembre","novice","nuage","nuancer","nuire","nuisible","numéro","nuptial","nuque","nutritif","obéir","objectif","obliger","obscur","observer","obstacle","obtenir","obturer","occasion","occuper","océan","octobre","octroyer","octupler","oculaire","odeur","odorant","offenser","officier","offrir","ogive","oiseau","oisillon","olfactif","olivier","ombrage","omettre","onctueux","onduler","onéreux","onirique","opale","opaque","opérer","opinion","opportun","opprimer","opter","optique","orageux","orange","orbite","ordonner","oreille","organe","orgueil","orifice","ornement","orque","ortie","osciller","osmose","ossature","otarie","ouragan","ourson","outil","outrager","ouvrage","ovation","oxyde","oxygène","ozone","paisible","palace","palmarès","palourde","palper","panache","panda","pangolin","paniquer","panneau","panorama","pantalon","papaye","papier","papoter","papyrus","paradoxe","parcelle","paresse","parfumer","parler","parole","parrain","parsemer","partager","parure","parvenir","passion","pastèque","paternel","patience","patron","pavillon","pavoiser","payer","paysage","peigne","peintre","pelage","pélican","pelle","pelouse","peluche","pendule","pénétrer","pénible","pensif","pénurie","pépite","péplum","perdrix","perforer","période","permuter","perplexe","persil","perte","peser","pétale","petit","pétrir","peuple","pharaon","phobie","phoque","photon","phrase","physique","piano","pictural","pièce","pierre","pieuvre","pilote","pinceau","pipette","piquer","pirogue","piscine","piston","pivoter","pixel","pizza","placard","plafond","plaisir","planer","plaque","plastron","plateau","pleurer","plexus","pliage","plomb","plonger","pluie","plumage","pochette","poésie","poète","pointe","poirier","poisson","poivre","polaire","policier","pollen","polygone","pommade","pompier","ponctuel","pondérer","poney","portique","position","posséder","posture","potager","poteau","potion","pouce","poulain","poumon","pourpre","poussin","pouvoir","prairie","pratique","précieux","prédire","préfixe","prélude","prénom","présence","prétexte","prévoir","primitif","prince","prison","priver","problème","procéder","prodige","profond","progrès","proie","projeter","prologue","promener","propre","prospère","protéger","prouesse","proverbe","prudence","pruneau","psychose","public","puceron","puiser","pulpe","pulsar","punaise","punitif","pupitre","purifier","puzzle","pyramide","quasar","querelle","question","quiétude","quitter","quotient","racine","raconter","radieux","ragondin","raideur","raisin","ralentir","rallonge","ramasser","rapide","rasage","ratisser","ravager","ravin","rayonner","réactif","réagir","réaliser","réanimer","recevoir","réciter","réclamer","récolter","recruter","reculer","recycler","rédiger","redouter","refaire","réflexe","réformer","refrain","refuge","régalien","région","réglage","régulier","réitérer","rejeter","rejouer","relatif","relever","relief","remarque","remède","remise","remonter","remplir","remuer","renard","renfort","renifler","renoncer","rentrer","renvoi","replier","reporter","reprise","reptile","requin","réserve","résineux","résoudre","respect","rester","résultat","rétablir","retenir","réticule","retomber","retracer","réunion","réussir","revanche","revivre","révolte","révulsif","richesse","rideau","rieur","rigide","rigoler","rincer","riposter","risible","risque","rituel","rival","rivière","rocheux","romance","rompre","ronce","rondin","roseau","rosier","rotatif","rotor","rotule","rouge","rouille","rouleau","routine","royaume","ruban","rubis","ruche","ruelle","rugueux","ruiner","ruisseau","ruser","rustique","rythme","sabler","saboter","sabre","sacoche","safari","sagesse","saisir","salade","salive","salon","saluer","samedi","sanction","sanglier","sarcasme","sardine","saturer","saugrenu","saumon","sauter","sauvage","savant","savonner","scalpel","scandale","scélérat","scénario","sceptre","schéma","science","scinder","score","scrutin","sculpter","séance","sécable","sécher","secouer","sécréter","sédatif","séduire","seigneur","séjour","sélectif","semaine","sembler","semence","séminal","sénateur","sensible","sentence","séparer","séquence","serein","sergent","sérieux","serrure","sérum","service","sésame","sévir","sevrage","sextuple","sidéral","siècle","siéger","siffler","sigle","signal","silence","silicium","simple","sincère","sinistre","siphon","sirop","sismique","situer","skier","social","socle","sodium","soigneux","soldat","soleil","solitude","soluble","sombre","sommeil","somnoler","sonde","songeur","sonnette","sonore","sorcier","sortir","sosie","sottise","soucieux","soudure","souffle","soulever","soupape","source","soutirer","souvenir","spacieux","spatial","spécial","sphère","spiral","stable","station","sternum","stimulus","stipuler","strict","studieux","stupeur","styliste","sublime","substrat","subtil","subvenir","succès","sucre","suffixe","suggérer","suiveur","sulfate","superbe","supplier","surface","suricate","surmener","surprise","sursaut","survie","suspect","syllabe","symbole","symétrie","synapse","syntaxe","système","tabac","tablier","tactile","tailler","talent","talisman","talonner","tambour","tamiser","tangible","tapis","taquiner","tarder","tarif","tartine","tasse","tatami","tatouage","taupe","taureau","taxer","témoin","temporel","tenaille","tendre","teneur","tenir","tension","terminer","terne","terrible","tétine","texte","thème","théorie","thérapie","thorax","tibia","tiède","timide","tirelire","tiroir","tissu","titane","titre","tituber","toboggan","tolérant","tomate","tonique","tonneau","toponyme","torche","tordre","tornade","torpille","torrent","torse","tortue","totem","toucher","tournage","tousser","toxine","traction","trafic","tragique","trahir","train","trancher","travail","trèfle","tremper","trésor","treuil","triage","tribunal","tricoter","trilogie","triomphe","tripler","triturer","trivial","trombone","tronc","tropical","troupeau","tuile","tulipe","tumulte","tunnel","turbine","tuteur","tutoyer","tuyau","tympan","typhon","typique","tyran","ubuesque","ultime","ultrason","unanime","unifier","union","unique","unitaire","univers","uranium","urbain","urticant","usage","usine","usuel","usure","utile","utopie","vacarme","vaccin","vagabond","vague","vaillant","vaincre","vaisseau","valable","valise","vallon","valve","vampire","vanille","vapeur","varier","vaseux","vassal","vaste","vecteur","vedette","végétal","véhicule","veinard","véloce","vendredi","vénérer","venger","venimeux","ventouse","verdure","vérin","vernir","verrou","verser","vertu","veston","vétéran","vétuste","vexant","vexer","viaduc","viande","victoire","vidange","vidéo","vignette","vigueur","vilain","village","vinaigre","violon","vipère","virement","virtuose","virus","visage","viseur","vision","visqueux","visuel","vital","vitesse","viticole","vitrine","vivace","vivipare","vocation","voguer","voile","voisin","voiture","volaille","volcan","voltiger","volume","vorace","vortex","voter","vouloir","voyage","voyelle","wagon","xénon","yacht","zèbre","zénith","zeste","zoologie"]' + ); + }, + 81981: e => { + "use strict"; + e.exports = JSON.parse( + '["abaco","abbaglio","abbinato","abete","abisso","abolire","abrasivo","abrogato","accadere","accenno","accusato","acetone","achille","acido","acqua","acre","acrilico","acrobata","acuto","adagio","addebito","addome","adeguato","aderire","adipe","adottare","adulare","affabile","affetto","affisso","affranto","aforisma","afoso","africano","agave","agente","agevole","aggancio","agire","agitare","agonismo","agricolo","agrumeto","aguzzo","alabarda","alato","albatro","alberato","albo","albume","alce","alcolico","alettone","alfa","algebra","aliante","alibi","alimento","allagato","allegro","allievo","allodola","allusivo","almeno","alogeno","alpaca","alpestre","altalena","alterno","alticcio","altrove","alunno","alveolo","alzare","amalgama","amanita","amarena","ambito","ambrato","ameba","america","ametista","amico","ammasso","ammenda","ammirare","ammonito","amore","ampio","ampliare","amuleto","anacardo","anagrafe","analista","anarchia","anatra","anca","ancella","ancora","andare","andrea","anello","angelo","angolare","angusto","anima","annegare","annidato","anno","annuncio","anonimo","anticipo","anzi","apatico","apertura","apode","apparire","appetito","appoggio","approdo","appunto","aprile","arabica","arachide","aragosta","araldica","arancio","aratura","arazzo","arbitro","archivio","ardito","arenile","argento","argine","arguto","aria","armonia","arnese","arredato","arringa","arrosto","arsenico","arso","artefice","arzillo","asciutto","ascolto","asepsi","asettico","asfalto","asino","asola","aspirato","aspro","assaggio","asse","assoluto","assurdo","asta","astenuto","astice","astratto","atavico","ateismo","atomico","atono","attesa","attivare","attorno","attrito","attuale","ausilio","austria","autista","autonomo","autunno","avanzato","avere","avvenire","avviso","avvolgere","azione","azoto","azzimo","azzurro","babele","baccano","bacino","baco","badessa","badilata","bagnato","baita","balcone","baldo","balena","ballata","balzano","bambino","bandire","baraonda","barbaro","barca","baritono","barlume","barocco","basilico","basso","batosta","battuto","baule","bava","bavosa","becco","beffa","belgio","belva","benda","benevole","benigno","benzina","bere","berlina","beta","bibita","bici","bidone","bifido","biga","bilancia","bimbo","binocolo","biologo","bipede","bipolare","birbante","birra","biscotto","bisesto","bisnonno","bisonte","bisturi","bizzarro","blando","blatta","bollito","bonifico","bordo","bosco","botanico","bottino","bozzolo","braccio","bradipo","brama","branca","bravura","bretella","brevetto","brezza","briglia","brillante","brindare","broccolo","brodo","bronzina","brullo","bruno","bubbone","buca","budino","buffone","buio","bulbo","buono","burlone","burrasca","bussola","busta","cadetto","caduco","calamaro","calcolo","calesse","calibro","calmo","caloria","cambusa","camerata","camicia","cammino","camola","campale","canapa","candela","cane","canino","canotto","cantina","capace","capello","capitolo","capogiro","cappero","capra","capsula","carapace","carcassa","cardo","carisma","carovana","carretto","cartolina","casaccio","cascata","caserma","caso","cassone","castello","casuale","catasta","catena","catrame","cauto","cavillo","cedibile","cedrata","cefalo","celebre","cellulare","cena","cenone","centesimo","ceramica","cercare","certo","cerume","cervello","cesoia","cespo","ceto","chela","chiaro","chicca","chiedere","chimera","china","chirurgo","chitarra","ciao","ciclismo","cifrare","cigno","cilindro","ciottolo","circa","cirrosi","citrico","cittadino","ciuffo","civetta","civile","classico","clinica","cloro","cocco","codardo","codice","coerente","cognome","collare","colmato","colore","colposo","coltivato","colza","coma","cometa","commando","comodo","computer","comune","conciso","condurre","conferma","congelare","coniuge","connesso","conoscere","consumo","continuo","convegno","coperto","copione","coppia","copricapo","corazza","cordata","coricato","cornice","corolla","corpo","corredo","corsia","cortese","cosmico","costante","cottura","covato","cratere","cravatta","creato","credere","cremoso","crescita","creta","criceto","crinale","crisi","critico","croce","cronaca","crostata","cruciale","crusca","cucire","cuculo","cugino","cullato","cupola","curatore","cursore","curvo","cuscino","custode","dado","daino","dalmata","damerino","daniela","dannoso","danzare","datato","davanti","davvero","debutto","decennio","deciso","declino","decollo","decreto","dedicato","definito","deforme","degno","delegare","delfino","delirio","delta","demenza","denotato","dentro","deposito","derapata","derivare","deroga","descritto","deserto","desiderio","desumere","detersivo","devoto","diametro","dicembre","diedro","difeso","diffuso","digerire","digitale","diluvio","dinamico","dinnanzi","dipinto","diploma","dipolo","diradare","dire","dirotto","dirupo","disagio","discreto","disfare","disgelo","disposto","distanza","disumano","dito","divano","divelto","dividere","divorato","doblone","docente","doganale","dogma","dolce","domato","domenica","dominare","dondolo","dono","dormire","dote","dottore","dovuto","dozzina","drago","druido","dubbio","dubitare","ducale","duna","duomo","duplice","duraturo","ebano","eccesso","ecco","eclissi","economia","edera","edicola","edile","editoria","educare","egemonia","egli","egoismo","egregio","elaborato","elargire","elegante","elencato","eletto","elevare","elfico","elica","elmo","elsa","eluso","emanato","emblema","emesso","emiro","emotivo","emozione","empirico","emulo","endemico","enduro","energia","enfasi","enoteca","entrare","enzima","epatite","epilogo","episodio","epocale","eppure","equatore","erario","erba","erboso","erede","eremita","erigere","ermetico","eroe","erosivo","errante","esagono","esame","esanime","esaudire","esca","esempio","esercito","esibito","esigente","esistere","esito","esofago","esortato","esoso","espanso","espresso","essenza","esso","esteso","estimare","estonia","estroso","esultare","etilico","etnico","etrusco","etto","euclideo","europa","evaso","evidenza","evitato","evoluto","evviva","fabbrica","faccenda","fachiro","falco","famiglia","fanale","fanfara","fango","fantasma","fare","farfalla","farinoso","farmaco","fascia","fastoso","fasullo","faticare","fato","favoloso","febbre","fecola","fede","fegato","felpa","feltro","femmina","fendere","fenomeno","fermento","ferro","fertile","fessura","festivo","fetta","feudo","fiaba","fiducia","fifa","figurato","filo","finanza","finestra","finire","fiore","fiscale","fisico","fiume","flacone","flamenco","flebo","flemma","florido","fluente","fluoro","fobico","focaccia","focoso","foderato","foglio","folata","folclore","folgore","fondente","fonetico","fonia","fontana","forbito","forchetta","foresta","formica","fornaio","foro","fortezza","forzare","fosfato","fosso","fracasso","frana","frassino","fratello","freccetta","frenata","fresco","frigo","frollino","fronde","frugale","frutta","fucilata","fucsia","fuggente","fulmine","fulvo","fumante","fumetto","fumoso","fune","funzione","fuoco","furbo","furgone","furore","fuso","futile","gabbiano","gaffe","galateo","gallina","galoppo","gambero","gamma","garanzia","garbo","garofano","garzone","gasdotto","gasolio","gastrico","gatto","gaudio","gazebo","gazzella","geco","gelatina","gelso","gemello","gemmato","gene","genitore","gennaio","genotipo","gergo","ghepardo","ghiaccio","ghisa","giallo","gilda","ginepro","giocare","gioiello","giorno","giove","girato","girone","gittata","giudizio","giurato","giusto","globulo","glutine","gnomo","gobba","golf","gomito","gommone","gonfio","gonna","governo","gracile","grado","grafico","grammo","grande","grattare","gravoso","grazia","greca","gregge","grifone","grigio","grinza","grotta","gruppo","guadagno","guaio","guanto","guardare","gufo","guidare","ibernato","icona","identico","idillio","idolo","idra","idrico","idrogeno","igiene","ignaro","ignorato","ilare","illeso","illogico","illudere","imballo","imbevuto","imbocco","imbuto","immane","immerso","immolato","impacco","impeto","impiego","importo","impronta","inalare","inarcare","inattivo","incanto","incendio","inchino","incisivo","incluso","incontro","incrocio","incubo","indagine","india","indole","inedito","infatti","infilare","inflitto","ingaggio","ingegno","inglese","ingordo","ingrosso","innesco","inodore","inoltrare","inondato","insano","insetto","insieme","insonnia","insulina","intasato","intero","intonaco","intuito","inumidire","invalido","invece","invito","iperbole","ipnotico","ipotesi","ippica","iride","irlanda","ironico","irrigato","irrorare","isolato","isotopo","isterico","istituto","istrice","italia","iterare","labbro","labirinto","lacca","lacerato","lacrima","lacuna","laddove","lago","lampo","lancetta","lanterna","lardoso","larga","laringe","lastra","latenza","latino","lattuga","lavagna","lavoro","legale","leggero","lembo","lentezza","lenza","leone","lepre","lesivo","lessato","lesto","letterale","leva","levigato","libero","lido","lievito","lilla","limatura","limitare","limpido","lineare","lingua","liquido","lira","lirica","lisca","lite","litigio","livrea","locanda","lode","logica","lombare","londra","longevo","loquace","lorenzo","loto","lotteria","luce","lucidato","lumaca","luminoso","lungo","lupo","luppolo","lusinga","lusso","lutto","macabro","macchina","macero","macinato","madama","magico","maglia","magnete","magro","maiolica","malafede","malgrado","malinteso","malsano","malto","malumore","mana","mancia","mandorla","mangiare","manifesto","mannaro","manovra","mansarda","mantide","manubrio","mappa","maratona","marcire","maretta","marmo","marsupio","maschera","massaia","mastino","materasso","matricola","mattone","maturo","mazurca","meandro","meccanico","mecenate","medesimo","meditare","mega","melassa","melis","melodia","meninge","meno","mensola","mercurio","merenda","merlo","meschino","mese","messere","mestolo","metallo","metodo","mettere","miagolare","mica","micelio","michele","microbo","midollo","miele","migliore","milano","milite","mimosa","minerale","mini","minore","mirino","mirtillo","miscela","missiva","misto","misurare","mitezza","mitigare","mitra","mittente","mnemonico","modello","modifica","modulo","mogano","mogio","mole","molosso","monastero","monco","mondina","monetario","monile","monotono","monsone","montato","monviso","mora","mordere","morsicato","mostro","motivato","motosega","motto","movenza","movimento","mozzo","mucca","mucosa","muffa","mughetto","mugnaio","mulatto","mulinello","multiplo","mummia","munto","muovere","murale","musa","muscolo","musica","mutevole","muto","nababbo","nafta","nanometro","narciso","narice","narrato","nascere","nastrare","naturale","nautica","naviglio","nebulosa","necrosi","negativo","negozio","nemmeno","neofita","neretto","nervo","nessuno","nettuno","neutrale","neve","nevrotico","nicchia","ninfa","nitido","nobile","nocivo","nodo","nome","nomina","nordico","normale","norvegese","nostrano","notare","notizia","notturno","novella","nucleo","nulla","numero","nuovo","nutrire","nuvola","nuziale","oasi","obbedire","obbligo","obelisco","oblio","obolo","obsoleto","occasione","occhio","occidente","occorrere","occultare","ocra","oculato","odierno","odorare","offerta","offrire","offuscato","oggetto","oggi","ognuno","olandese","olfatto","oliato","oliva","ologramma","oltre","omaggio","ombelico","ombra","omega","omissione","ondoso","onere","onice","onnivoro","onorevole","onta","operato","opinione","opposto","oracolo","orafo","ordine","orecchino","orefice","orfano","organico","origine","orizzonte","orma","ormeggio","ornativo","orologio","orrendo","orribile","ortensia","ortica","orzata","orzo","osare","oscurare","osmosi","ospedale","ospite","ossa","ossidare","ostacolo","oste","otite","otre","ottagono","ottimo","ottobre","ovale","ovest","ovino","oviparo","ovocito","ovunque","ovviare","ozio","pacchetto","pace","pacifico","padella","padrone","paese","paga","pagina","palazzina","palesare","pallido","palo","palude","pandoro","pannello","paolo","paonazzo","paprica","parabola","parcella","parere","pargolo","pari","parlato","parola","partire","parvenza","parziale","passivo","pasticca","patacca","patologia","pattume","pavone","peccato","pedalare","pedonale","peggio","peloso","penare","pendice","penisola","pennuto","penombra","pensare","pentola","pepe","pepita","perbene","percorso","perdonato","perforare","pergamena","periodo","permesso","perno","perplesso","persuaso","pertugio","pervaso","pesatore","pesista","peso","pestifero","petalo","pettine","petulante","pezzo","piacere","pianta","piattino","piccino","picozza","piega","pietra","piffero","pigiama","pigolio","pigro","pila","pilifero","pillola","pilota","pimpante","pineta","pinna","pinolo","pioggia","piombo","piramide","piretico","pirite","pirolisi","pitone","pizzico","placebo","planare","plasma","platano","plenario","pochezza","poderoso","podismo","poesia","poggiare","polenta","poligono","pollice","polmonite","polpetta","polso","poltrona","polvere","pomice","pomodoro","ponte","popoloso","porfido","poroso","porpora","porre","portata","posa","positivo","possesso","postulato","potassio","potere","pranzo","prassi","pratica","precluso","predica","prefisso","pregiato","prelievo","premere","prenotare","preparato","presenza","pretesto","prevalso","prima","principe","privato","problema","procura","produrre","profumo","progetto","prolunga","promessa","pronome","proposta","proroga","proteso","prova","prudente","prugna","prurito","psiche","pubblico","pudica","pugilato","pugno","pulce","pulito","pulsante","puntare","pupazzo","pupilla","puro","quadro","qualcosa","quasi","querela","quota","raccolto","raddoppio","radicale","radunato","raffica","ragazzo","ragione","ragno","ramarro","ramingo","ramo","randagio","rantolare","rapato","rapina","rappreso","rasatura","raschiato","rasente","rassegna","rastrello","rata","ravveduto","reale","recepire","recinto","recluta","recondito","recupero","reddito","redimere","regalato","registro","regola","regresso","relazione","remare","remoto","renna","replica","reprimere","reputare","resa","residente","responso","restauro","rete","retina","retorica","rettifica","revocato","riassunto","ribadire","ribelle","ribrezzo","ricarica","ricco","ricevere","riciclato","ricordo","ricreduto","ridicolo","ridurre","rifasare","riflesso","riforma","rifugio","rigare","rigettato","righello","rilassato","rilevato","rimanere","rimbalzo","rimedio","rimorchio","rinascita","rincaro","rinforzo","rinnovo","rinomato","rinsavito","rintocco","rinuncia","rinvenire","riparato","ripetuto","ripieno","riportare","ripresa","ripulire","risata","rischio","riserva","risibile","riso","rispetto","ristoro","risultato","risvolto","ritardo","ritegno","ritmico","ritrovo","riunione","riva","riverso","rivincita","rivolto","rizoma","roba","robotico","robusto","roccia","roco","rodaggio","rodere","roditore","rogito","rollio","romantico","rompere","ronzio","rosolare","rospo","rotante","rotondo","rotula","rovescio","rubizzo","rubrica","ruga","rullino","rumine","rumoroso","ruolo","rupe","russare","rustico","sabato","sabbiare","sabotato","sagoma","salasso","saldatura","salgemma","salivare","salmone","salone","saltare","saluto","salvo","sapere","sapido","saporito","saraceno","sarcasmo","sarto","sassoso","satellite","satira","satollo","saturno","savana","savio","saziato","sbadiglio","sbalzo","sbancato","sbarra","sbattere","sbavare","sbendare","sbirciare","sbloccato","sbocciato","sbrinare","sbruffone","sbuffare","scabroso","scadenza","scala","scambiare","scandalo","scapola","scarso","scatenare","scavato","scelto","scenico","scettro","scheda","schiena","sciarpa","scienza","scindere","scippo","sciroppo","scivolo","sclerare","scodella","scolpito","scomparto","sconforto","scoprire","scorta","scossone","scozzese","scriba","scrollare","scrutinio","scuderia","scultore","scuola","scuro","scusare","sdebitare","sdoganare","seccatura","secondo","sedano","seggiola","segnalato","segregato","seguito","selciato","selettivo","sella","selvaggio","semaforo","sembrare","seme","seminato","sempre","senso","sentire","sepolto","sequenza","serata","serbato","sereno","serio","serpente","serraglio","servire","sestina","setola","settimana","sfacelo","sfaldare","sfamato","sfarzoso","sfaticato","sfera","sfida","sfilato","sfinge","sfocato","sfoderare","sfogo","sfoltire","sforzato","sfratto","sfruttato","sfuggito","sfumare","sfuso","sgabello","sgarbato","sgonfiare","sgorbio","sgrassato","sguardo","sibilo","siccome","sierra","sigla","signore","silenzio","sillaba","simbolo","simpatico","simulato","sinfonia","singolo","sinistro","sino","sintesi","sinusoide","sipario","sisma","sistole","situato","slitta","slogatura","sloveno","smarrito","smemorato","smentito","smeraldo","smilzo","smontare","smottato","smussato","snellire","snervato","snodo","sobbalzo","sobrio","soccorso","sociale","sodale","soffitto","sogno","soldato","solenne","solido","sollazzo","solo","solubile","solvente","somatico","somma","sonda","sonetto","sonnifero","sopire","soppeso","sopra","sorgere","sorpasso","sorriso","sorso","sorteggio","sorvolato","sospiro","sosta","sottile","spada","spalla","spargere","spatola","spavento","spazzola","specie","spedire","spegnere","spelatura","speranza","spessore","spettrale","spezzato","spia","spigoloso","spillato","spinoso","spirale","splendido","sportivo","sposo","spranga","sprecare","spronato","spruzzo","spuntino","squillo","sradicare","srotolato","stabile","stacco","staffa","stagnare","stampato","stantio","starnuto","stasera","statuto","stelo","steppa","sterzo","stiletto","stima","stirpe","stivale","stizzoso","stonato","storico","strappo","stregato","stridulo","strozzare","strutto","stuccare","stufo","stupendo","subentro","succoso","sudore","suggerito","sugo","sultano","suonare","superbo","supporto","surgelato","surrogato","sussurro","sutura","svagare","svedese","sveglio","svelare","svenuto","svezia","sviluppo","svista","svizzera","svolta","svuotare","tabacco","tabulato","tacciare","taciturno","tale","talismano","tampone","tannino","tara","tardivo","targato","tariffa","tarpare","tartaruga","tasto","tattico","taverna","tavolata","tazza","teca","tecnico","telefono","temerario","tempo","temuto","tendone","tenero","tensione","tentacolo","teorema","terme","terrazzo","terzetto","tesi","tesserato","testato","tetro","tettoia","tifare","tigella","timbro","tinto","tipico","tipografo","tiraggio","tiro","titanio","titolo","titubante","tizio","tizzone","toccare","tollerare","tolto","tombola","tomo","tonfo","tonsilla","topazio","topologia","toppa","torba","tornare","torrone","tortora","toscano","tossire","tostatura","totano","trabocco","trachea","trafila","tragedia","tralcio","tramonto","transito","trapano","trarre","trasloco","trattato","trave","treccia","tremolio","trespolo","tributo","tricheco","trifoglio","trillo","trincea","trio","tristezza","triturato","trivella","tromba","trono","troppo","trottola","trovare","truccato","tubatura","tuffato","tulipano","tumulto","tunisia","turbare","turchino","tuta","tutela","ubicato","uccello","uccisore","udire","uditivo","uffa","ufficio","uguale","ulisse","ultimato","umano","umile","umorismo","uncinetto","ungere","ungherese","unicorno","unificato","unisono","unitario","unte","uovo","upupa","uragano","urgenza","urlo","usanza","usato","uscito","usignolo","usuraio","utensile","utilizzo","utopia","vacante","vaccinato","vagabondo","vagliato","valanga","valgo","valico","valletta","valoroso","valutare","valvola","vampata","vangare","vanitoso","vano","vantaggio","vanvera","vapore","varano","varcato","variante","vasca","vedetta","vedova","veduto","vegetale","veicolo","velcro","velina","velluto","veloce","venato","vendemmia","vento","verace","verbale","vergogna","verifica","vero","verruca","verticale","vescica","vessillo","vestale","veterano","vetrina","vetusto","viandante","vibrante","vicenda","vichingo","vicinanza","vidimare","vigilia","vigneto","vigore","vile","villano","vimini","vincitore","viola","vipera","virgola","virologo","virulento","viscoso","visione","vispo","vissuto","visura","vita","vitello","vittima","vivanda","vivido","viziare","voce","voga","volatile","volere","volpe","voragine","vulcano","zampogna","zanna","zappato","zattera","zavorra","zefiro","zelante","zelo","zenzero","zerbino","zibetto","zinco","zircone","zitto","zolla","zotico","zucchero","zufolo","zulu","zuppa"]' + ); + }, + 95751: e => { + "use strict"; + e.exports = JSON.parse( + '["あいこくしん","あいさつ","あいだ","あおぞら","あかちゃん","あきる","あけがた","あける","あこがれる","あさい","あさひ","あしあと","あじわう","あずかる","あずき","あそぶ","あたえる","あたためる","あたりまえ","あたる","あつい","あつかう","あっしゅく","あつまり","あつめる","あてな","あてはまる","あひる","あぶら","あぶる","あふれる","あまい","あまど","あまやかす","あまり","あみもの","あめりか","あやまる","あゆむ","あらいぐま","あらし","あらすじ","あらためる","あらゆる","あらわす","ありがとう","あわせる","あわてる","あんい","あんがい","あんこ","あんぜん","あんてい","あんない","あんまり","いいだす","いおん","いがい","いがく","いきおい","いきなり","いきもの","いきる","いくじ","いくぶん","いけばな","いけん","いこう","いこく","いこつ","いさましい","いさん","いしき","いじゅう","いじょう","いじわる","いずみ","いずれ","いせい","いせえび","いせかい","いせき","いぜん","いそうろう","いそがしい","いだい","いだく","いたずら","いたみ","いたりあ","いちおう","いちじ","いちど","いちば","いちぶ","いちりゅう","いつか","いっしゅん","いっせい","いっそう","いったん","いっち","いってい","いっぽう","いてざ","いてん","いどう","いとこ","いない","いなか","いねむり","いのち","いのる","いはつ","いばる","いはん","いびき","いひん","いふく","いへん","いほう","いみん","いもうと","いもたれ","いもり","いやがる","いやす","いよかん","いよく","いらい","いらすと","いりぐち","いりょう","いれい","いれもの","いれる","いろえんぴつ","いわい","いわう","いわかん","いわば","いわゆる","いんげんまめ","いんさつ","いんしょう","いんよう","うえき","うえる","うおざ","うがい","うかぶ","うかべる","うきわ","うくらいな","うくれれ","うけたまわる","うけつけ","うけとる","うけもつ","うける","うごかす","うごく","うこん","うさぎ","うしなう","うしろがみ","うすい","うすぎ","うすぐらい","うすめる","うせつ","うちあわせ","うちがわ","うちき","うちゅう","うっかり","うつくしい","うったえる","うつる","うどん","うなぎ","うなじ","うなずく","うなる","うねる","うのう","うぶげ","うぶごえ","うまれる","うめる","うもう","うやまう","うよく","うらがえす","うらぐち","うらない","うりあげ","うりきれ","うるさい","うれしい","うれゆき","うれる","うろこ","うわき","うわさ","うんこう","うんちん","うんてん","うんどう","えいえん","えいが","えいきょう","えいご","えいせい","えいぶん","えいよう","えいわ","えおり","えがお","えがく","えきたい","えくせる","えしゃく","えすて","えつらん","えのぐ","えほうまき","えほん","えまき","えもじ","えもの","えらい","えらぶ","えりあ","えんえん","えんかい","えんぎ","えんげき","えんしゅう","えんぜつ","えんそく","えんちょう","えんとつ","おいかける","おいこす","おいしい","おいつく","おうえん","おうさま","おうじ","おうせつ","おうたい","おうふく","おうべい","おうよう","おえる","おおい","おおう","おおどおり","おおや","おおよそ","おかえり","おかず","おがむ","おかわり","おぎなう","おきる","おくさま","おくじょう","おくりがな","おくる","おくれる","おこす","おこなう","おこる","おさえる","おさない","おさめる","おしいれ","おしえる","おじぎ","おじさん","おしゃれ","おそらく","おそわる","おたがい","おたく","おだやか","おちつく","おっと","おつり","おでかけ","おとしもの","おとなしい","おどり","おどろかす","おばさん","おまいり","おめでとう","おもいで","おもう","おもたい","おもちゃ","おやつ","おやゆび","およぼす","おらんだ","おろす","おんがく","おんけい","おんしゃ","おんせん","おんだん","おんちゅう","おんどけい","かあつ","かいが","がいき","がいけん","がいこう","かいさつ","かいしゃ","かいすいよく","かいぜん","かいぞうど","かいつう","かいてん","かいとう","かいふく","がいへき","かいほう","かいよう","がいらい","かいわ","かえる","かおり","かかえる","かがく","かがし","かがみ","かくご","かくとく","かざる","がぞう","かたい","かたち","がちょう","がっきゅう","がっこう","がっさん","がっしょう","かなざわし","かのう","がはく","かぶか","かほう","かほご","かまう","かまぼこ","かめれおん","かゆい","かようび","からい","かるい","かろう","かわく","かわら","がんか","かんけい","かんこう","かんしゃ","かんそう","かんたん","かんち","がんばる","きあい","きあつ","きいろ","ぎいん","きうい","きうん","きえる","きおう","きおく","きおち","きおん","きかい","きかく","きかんしゃ","ききて","きくばり","きくらげ","きけんせい","きこう","きこえる","きこく","きさい","きさく","きさま","きさらぎ","ぎじかがく","ぎしき","ぎじたいけん","ぎじにってい","ぎじゅつしゃ","きすう","きせい","きせき","きせつ","きそう","きぞく","きぞん","きたえる","きちょう","きつえん","ぎっちり","きつつき","きつね","きてい","きどう","きどく","きない","きなが","きなこ","きぬごし","きねん","きのう","きのした","きはく","きびしい","きひん","きふく","きぶん","きぼう","きほん","きまる","きみつ","きむずかしい","きめる","きもだめし","きもち","きもの","きゃく","きやく","ぎゅうにく","きよう","きょうりゅう","きらい","きらく","きりん","きれい","きれつ","きろく","ぎろん","きわめる","ぎんいろ","きんかくじ","きんじょ","きんようび","ぐあい","くいず","くうかん","くうき","くうぐん","くうこう","ぐうせい","くうそう","ぐうたら","くうふく","くうぼ","くかん","くきょう","くげん","ぐこう","くさい","くさき","くさばな","くさる","くしゃみ","くしょう","くすのき","くすりゆび","くせげ","くせん","ぐたいてき","くださる","くたびれる","くちこみ","くちさき","くつした","ぐっすり","くつろぐ","くとうてん","くどく","くなん","くねくね","くのう","くふう","くみあわせ","くみたてる","くめる","くやくしょ","くらす","くらべる","くるま","くれる","くろう","くわしい","ぐんかん","ぐんしょく","ぐんたい","ぐんて","けあな","けいかく","けいけん","けいこ","けいさつ","げいじゅつ","けいたい","げいのうじん","けいれき","けいろ","けおとす","けおりもの","げきか","げきげん","げきだん","げきちん","げきとつ","げきは","げきやく","げこう","げこくじょう","げざい","けさき","げざん","けしき","けしごむ","けしょう","げすと","けたば","けちゃっぷ","けちらす","けつあつ","けつい","けつえき","けっこん","けつじょ","けっせき","けってい","けつまつ","げつようび","げつれい","けつろん","げどく","けとばす","けとる","けなげ","けなす","けなみ","けぬき","げねつ","けねん","けはい","げひん","けぶかい","げぼく","けまり","けみかる","けむし","けむり","けもの","けらい","けろけろ","けわしい","けんい","けんえつ","けんお","けんか","げんき","けんげん","けんこう","けんさく","けんしゅう","けんすう","げんそう","けんちく","けんてい","けんとう","けんない","けんにん","げんぶつ","けんま","けんみん","けんめい","けんらん","けんり","こあくま","こいぬ","こいびと","ごうい","こうえん","こうおん","こうかん","ごうきゅう","ごうけい","こうこう","こうさい","こうじ","こうすい","ごうせい","こうそく","こうたい","こうちゃ","こうつう","こうてい","こうどう","こうない","こうはい","ごうほう","ごうまん","こうもく","こうりつ","こえる","こおり","ごかい","ごがつ","ごかん","こくご","こくさい","こくとう","こくない","こくはく","こぐま","こけい","こける","ここのか","こころ","こさめ","こしつ","こすう","こせい","こせき","こぜん","こそだて","こたい","こたえる","こたつ","こちょう","こっか","こつこつ","こつばん","こつぶ","こてい","こてん","ことがら","ことし","ことば","ことり","こなごな","こねこね","このまま","このみ","このよ","ごはん","こひつじ","こふう","こふん","こぼれる","ごまあぶら","こまかい","ごますり","こまつな","こまる","こむぎこ","こもじ","こもち","こもの","こもん","こやく","こやま","こゆう","こゆび","こよい","こよう","こりる","これくしょん","ころっけ","こわもて","こわれる","こんいん","こんかい","こんき","こんしゅう","こんすい","こんだて","こんとん","こんなん","こんびに","こんぽん","こんまけ","こんや","こんれい","こんわく","ざいえき","さいかい","さいきん","ざいげん","ざいこ","さいしょ","さいせい","ざいたく","ざいちゅう","さいてき","ざいりょう","さうな","さかいし","さがす","さかな","さかみち","さがる","さぎょう","さくし","さくひん","さくら","さこく","さこつ","さずかる","ざせき","さたん","さつえい","ざつおん","ざっか","ざつがく","さっきょく","ざっし","さつじん","ざっそう","さつたば","さつまいも","さてい","さといも","さとう","さとおや","さとし","さとる","さのう","さばく","さびしい","さべつ","さほう","さほど","さます","さみしい","さみだれ","さむけ","さめる","さやえんどう","さゆう","さよう","さよく","さらだ","ざるそば","さわやか","さわる","さんいん","さんか","さんきゃく","さんこう","さんさい","ざんしょ","さんすう","さんせい","さんそ","さんち","さんま","さんみ","さんらん","しあい","しあげ","しあさって","しあわせ","しいく","しいん","しうち","しえい","しおけ","しかい","しかく","じかん","しごと","しすう","じだい","したうけ","したぎ","したて","したみ","しちょう","しちりん","しっかり","しつじ","しつもん","してい","してき","してつ","じてん","じどう","しなぎれ","しなもの","しなん","しねま","しねん","しのぐ","しのぶ","しはい","しばかり","しはつ","しはらい","しはん","しひょう","しふく","じぶん","しへい","しほう","しほん","しまう","しまる","しみん","しむける","じむしょ","しめい","しめる","しもん","しゃいん","しゃうん","しゃおん","じゃがいも","しやくしょ","しゃくほう","しゃけん","しゃこ","しゃざい","しゃしん","しゃせん","しゃそう","しゃたい","しゃちょう","しゃっきん","じゃま","しゃりん","しゃれい","じゆう","じゅうしょ","しゅくはく","じゅしん","しゅっせき","しゅみ","しゅらば","じゅんばん","しょうかい","しょくたく","しょっけん","しょどう","しょもつ","しらせる","しらべる","しんか","しんこう","じんじゃ","しんせいじ","しんちく","しんりん","すあげ","すあし","すあな","ずあん","すいえい","すいか","すいとう","ずいぶん","すいようび","すうがく","すうじつ","すうせん","すおどり","すきま","すくう","すくない","すける","すごい","すこし","ずさん","すずしい","すすむ","すすめる","すっかり","ずっしり","ずっと","すてき","すてる","すねる","すのこ","すはだ","すばらしい","ずひょう","ずぶぬれ","すぶり","すふれ","すべて","すべる","ずほう","すぼん","すまい","すめし","すもう","すやき","すらすら","するめ","すれちがう","すろっと","すわる","すんぜん","すんぽう","せあぶら","せいかつ","せいげん","せいじ","せいよう","せおう","せかいかん","せきにん","せきむ","せきゆ","せきらんうん","せけん","せこう","せすじ","せたい","せたけ","せっかく","せっきゃく","ぜっく","せっけん","せっこつ","せっさたくま","せつぞく","せつだん","せつでん","せっぱん","せつび","せつぶん","せつめい","せつりつ","せなか","せのび","せはば","せびろ","せぼね","せまい","せまる","せめる","せもたれ","せりふ","ぜんあく","せんい","せんえい","せんか","せんきょ","せんく","せんげん","ぜんご","せんさい","せんしゅ","せんすい","せんせい","せんぞ","せんたく","せんちょう","せんてい","せんとう","せんぬき","せんねん","せんぱい","ぜんぶ","ぜんぽう","せんむ","せんめんじょ","せんもん","せんやく","せんゆう","せんよう","ぜんら","ぜんりゃく","せんれい","せんろ","そあく","そいとげる","そいね","そうがんきょう","そうき","そうご","そうしん","そうだん","そうなん","そうび","そうめん","そうり","そえもの","そえん","そがい","そげき","そこう","そこそこ","そざい","そしな","そせい","そせん","そそぐ","そだてる","そつう","そつえん","そっかん","そつぎょう","そっけつ","そっこう","そっせん","そっと","そとがわ","そとづら","そなえる","そなた","そふぼ","そぼく","そぼろ","そまつ","そまる","そむく","そむりえ","そめる","そもそも","そよかぜ","そらまめ","そろう","そんかい","そんけい","そんざい","そんしつ","そんぞく","そんちょう","ぞんび","ぞんぶん","そんみん","たあい","たいいん","たいうん","たいえき","たいおう","だいがく","たいき","たいぐう","たいけん","たいこ","たいざい","だいじょうぶ","だいすき","たいせつ","たいそう","だいたい","たいちょう","たいてい","だいどころ","たいない","たいねつ","たいのう","たいはん","だいひょう","たいふう","たいへん","たいほ","たいまつばな","たいみんぐ","たいむ","たいめん","たいやき","たいよう","たいら","たいりょく","たいる","たいわん","たうえ","たえる","たおす","たおる","たおれる","たかい","たかね","たきび","たくさん","たこく","たこやき","たさい","たしざん","だじゃれ","たすける","たずさわる","たそがれ","たたかう","たたく","ただしい","たたみ","たちばな","だっかい","だっきゃく","だっこ","だっしゅつ","だったい","たてる","たとえる","たなばた","たにん","たぬき","たのしみ","たはつ","たぶん","たべる","たぼう","たまご","たまる","だむる","ためいき","ためす","ためる","たもつ","たやすい","たよる","たらす","たりきほんがん","たりょう","たりる","たると","たれる","たれんと","たろっと","たわむれる","だんあつ","たんい","たんおん","たんか","たんき","たんけん","たんご","たんさん","たんじょうび","だんせい","たんそく","たんたい","だんち","たんてい","たんとう","だんな","たんにん","だんねつ","たんのう","たんぴん","だんぼう","たんまつ","たんめい","だんれつ","だんろ","だんわ","ちあい","ちあん","ちいき","ちいさい","ちえん","ちかい","ちから","ちきゅう","ちきん","ちけいず","ちけん","ちこく","ちさい","ちしき","ちしりょう","ちせい","ちそう","ちたい","ちたん","ちちおや","ちつじょ","ちてき","ちてん","ちぬき","ちぬり","ちのう","ちひょう","ちへいせん","ちほう","ちまた","ちみつ","ちみどろ","ちめいど","ちゃんこなべ","ちゅうい","ちゆりょく","ちょうし","ちょさくけん","ちらし","ちらみ","ちりがみ","ちりょう","ちるど","ちわわ","ちんたい","ちんもく","ついか","ついたち","つうか","つうじょう","つうはん","つうわ","つかう","つかれる","つくね","つくる","つけね","つける","つごう","つたえる","つづく","つつじ","つつむ","つとめる","つながる","つなみ","つねづね","つのる","つぶす","つまらない","つまる","つみき","つめたい","つもり","つもる","つよい","つるぼ","つるみく","つわもの","つわり","てあし","てあて","てあみ","ていおん","ていか","ていき","ていけい","ていこく","ていさつ","ていし","ていせい","ていたい","ていど","ていねい","ていひょう","ていへん","ていぼう","てうち","ておくれ","てきとう","てくび","でこぼこ","てさぎょう","てさげ","てすり","てそう","てちがい","てちょう","てつがく","てつづき","でっぱ","てつぼう","てつや","でぬかえ","てぬき","てぬぐい","てのひら","てはい","てぶくろ","てふだ","てほどき","てほん","てまえ","てまきずし","てみじか","てみやげ","てらす","てれび","てわけ","てわたし","でんあつ","てんいん","てんかい","てんき","てんぐ","てんけん","てんごく","てんさい","てんし","てんすう","でんち","てんてき","てんとう","てんない","てんぷら","てんぼうだい","てんめつ","てんらんかい","でんりょく","でんわ","どあい","といれ","どうかん","とうきゅう","どうぐ","とうし","とうむぎ","とおい","とおか","とおく","とおす","とおる","とかい","とかす","ときおり","ときどき","とくい","とくしゅう","とくてん","とくに","とくべつ","とけい","とける","とこや","とさか","としょかん","とそう","とたん","とちゅう","とっきゅう","とっくん","とつぜん","とつにゅう","とどける","ととのえる","とない","となえる","となり","とのさま","とばす","どぶがわ","とほう","とまる","とめる","ともだち","ともる","どようび","とらえる","とんかつ","どんぶり","ないかく","ないこう","ないしょ","ないす","ないせん","ないそう","なおす","ながい","なくす","なげる","なこうど","なさけ","なたでここ","なっとう","なつやすみ","ななおし","なにごと","なにもの","なにわ","なのか","なふだ","なまいき","なまえ","なまみ","なみだ","なめらか","なめる","なやむ","ならう","ならび","ならぶ","なれる","なわとび","なわばり","にあう","にいがた","にうけ","におい","にかい","にがて","にきび","にくしみ","にくまん","にげる","にさんかたんそ","にしき","にせもの","にちじょう","にちようび","にっか","にっき","にっけい","にっこう","にっさん","にっしょく","にっすう","にっせき","にってい","になう","にほん","にまめ","にもつ","にやり","にゅういん","にりんしゃ","にわとり","にんい","にんか","にんき","にんげん","にんしき","にんずう","にんそう","にんたい","にんち","にんてい","にんにく","にんぷ","にんまり","にんむ","にんめい","にんよう","ぬいくぎ","ぬかす","ぬぐいとる","ぬぐう","ぬくもり","ぬすむ","ぬまえび","ぬめり","ぬらす","ぬんちゃく","ねあげ","ねいき","ねいる","ねいろ","ねぐせ","ねくたい","ねくら","ねこぜ","ねこむ","ねさげ","ねすごす","ねそべる","ねだん","ねつい","ねっしん","ねつぞう","ねったいぎょ","ねぶそく","ねふだ","ねぼう","ねほりはほり","ねまき","ねまわし","ねみみ","ねむい","ねむたい","ねもと","ねらう","ねわざ","ねんいり","ねんおし","ねんかん","ねんきん","ねんぐ","ねんざ","ねんし","ねんちゃく","ねんど","ねんぴ","ねんぶつ","ねんまつ","ねんりょう","ねんれい","のいず","のおづま","のがす","のきなみ","のこぎり","のこす","のこる","のせる","のぞく","のぞむ","のたまう","のちほど","のっく","のばす","のはら","のべる","のぼる","のみもの","のやま","のらいぬ","のらねこ","のりもの","のりゆき","のれん","のんき","ばあい","はあく","ばあさん","ばいか","ばいく","はいけん","はいご","はいしん","はいすい","はいせん","はいそう","はいち","ばいばい","はいれつ","はえる","はおる","はかい","ばかり","はかる","はくしゅ","はけん","はこぶ","はさみ","はさん","はしご","ばしょ","はしる","はせる","ぱそこん","はそん","はたん","はちみつ","はつおん","はっかく","はづき","はっきり","はっくつ","はっけん","はっこう","はっさん","はっしん","はったつ","はっちゅう","はってん","はっぴょう","はっぽう","はなす","はなび","はにかむ","はぶらし","はみがき","はむかう","はめつ","はやい","はやし","はらう","はろうぃん","はわい","はんい","はんえい","はんおん","はんかく","はんきょう","ばんぐみ","はんこ","はんしゃ","はんすう","はんだん","ぱんち","ぱんつ","はんてい","はんとし","はんのう","はんぱ","はんぶん","はんぺん","はんぼうき","はんめい","はんらん","はんろん","ひいき","ひうん","ひえる","ひかく","ひかり","ひかる","ひかん","ひくい","ひけつ","ひこうき","ひこく","ひさい","ひさしぶり","ひさん","びじゅつかん","ひしょ","ひそか","ひそむ","ひたむき","ひだり","ひたる","ひつぎ","ひっこし","ひっし","ひつじゅひん","ひっす","ひつぜん","ぴったり","ぴっちり","ひつよう","ひてい","ひとごみ","ひなまつり","ひなん","ひねる","ひはん","ひびく","ひひょう","ひほう","ひまわり","ひまん","ひみつ","ひめい","ひめじし","ひやけ","ひやす","ひよう","びょうき","ひらがな","ひらく","ひりつ","ひりょう","ひるま","ひるやすみ","ひれい","ひろい","ひろう","ひろき","ひろゆき","ひんかく","ひんけつ","ひんこん","ひんしゅ","ひんそう","ぴんち","ひんぱん","びんぼう","ふあん","ふいうち","ふうけい","ふうせん","ぷうたろう","ふうとう","ふうふ","ふえる","ふおん","ふかい","ふきん","ふくざつ","ふくぶくろ","ふこう","ふさい","ふしぎ","ふじみ","ふすま","ふせい","ふせぐ","ふそく","ぶたにく","ふたん","ふちょう","ふつう","ふつか","ふっかつ","ふっき","ふっこく","ぶどう","ふとる","ふとん","ふのう","ふはい","ふひょう","ふへん","ふまん","ふみん","ふめつ","ふめん","ふよう","ふりこ","ふりる","ふるい","ふんいき","ぶんがく","ぶんぐ","ふんしつ","ぶんせき","ふんそう","ぶんぽう","へいあん","へいおん","へいがい","へいき","へいげん","へいこう","へいさ","へいしゃ","へいせつ","へいそ","へいたく","へいてん","へいねつ","へいわ","へきが","へこむ","べにいろ","べにしょうが","へらす","へんかん","べんきょう","べんごし","へんさい","へんたい","べんり","ほあん","ほいく","ぼうぎょ","ほうこく","ほうそう","ほうほう","ほうもん","ほうりつ","ほえる","ほおん","ほかん","ほきょう","ぼきん","ほくろ","ほけつ","ほけん","ほこう","ほこる","ほしい","ほしつ","ほしゅ","ほしょう","ほせい","ほそい","ほそく","ほたて","ほたる","ぽちぶくろ","ほっきょく","ほっさ","ほったん","ほとんど","ほめる","ほんい","ほんき","ほんけ","ほんしつ","ほんやく","まいにち","まかい","まかせる","まがる","まける","まこと","まさつ","まじめ","ますく","まぜる","まつり","まとめ","まなぶ","まぬけ","まねく","まほう","まもる","まゆげ","まよう","まろやか","まわす","まわり","まわる","まんが","まんきつ","まんぞく","まんなか","みいら","みうち","みえる","みがく","みかた","みかん","みけん","みこん","みじかい","みすい","みすえる","みせる","みっか","みつかる","みつける","みてい","みとめる","みなと","みなみかさい","みねらる","みのう","みのがす","みほん","みもと","みやげ","みらい","みりょく","みわく","みんか","みんぞく","むいか","むえき","むえん","むかい","むかう","むかえ","むかし","むぎちゃ","むける","むげん","むさぼる","むしあつい","むしば","むじゅん","むしろ","むすう","むすこ","むすぶ","むすめ","むせる","むせん","むちゅう","むなしい","むのう","むやみ","むよう","むらさき","むりょう","むろん","めいあん","めいうん","めいえん","めいかく","めいきょく","めいさい","めいし","めいそう","めいぶつ","めいれい","めいわく","めぐまれる","めざす","めした","めずらしい","めだつ","めまい","めやす","めんきょ","めんせき","めんどう","もうしあげる","もうどうけん","もえる","もくし","もくてき","もくようび","もちろん","もどる","もらう","もんく","もんだい","やおや","やける","やさい","やさしい","やすい","やすたろう","やすみ","やせる","やそう","やたい","やちん","やっと","やっぱり","やぶる","やめる","ややこしい","やよい","やわらかい","ゆうき","ゆうびんきょく","ゆうべ","ゆうめい","ゆけつ","ゆしゅつ","ゆせん","ゆそう","ゆたか","ゆちゃく","ゆでる","ゆにゅう","ゆびわ","ゆらい","ゆれる","ようい","ようか","ようきゅう","ようじ","ようす","ようちえん","よかぜ","よかん","よきん","よくせい","よくぼう","よけい","よごれる","よさん","よしゅう","よそう","よそく","よっか","よてい","よどがわく","よねつ","よやく","よゆう","よろこぶ","よろしい","らいう","らくがき","らくご","らくさつ","らくだ","らしんばん","らせん","らぞく","らたい","らっか","られつ","りえき","りかい","りきさく","りきせつ","りくぐん","りくつ","りけん","りこう","りせい","りそう","りそく","りてん","りねん","りゆう","りゅうがく","りよう","りょうり","りょかん","りょくちゃ","りょこう","りりく","りれき","りろん","りんご","るいけい","るいさい","るいじ","るいせき","るすばん","るりがわら","れいかん","れいぎ","れいせい","れいぞうこ","れいとう","れいぼう","れきし","れきだい","れんあい","れんけい","れんこん","れんさい","れんしゅう","れんぞく","れんらく","ろうか","ろうご","ろうじん","ろうそく","ろくが","ろこつ","ろじうら","ろしゅつ","ろせん","ろてん","ろめん","ろれつ","ろんぎ","ろんぱ","ろんぶん","ろんり","わかす","わかめ","わかやま","わかれる","わしつ","わじまし","わすれもの","わらう","われる"]' + ); + }, + 51194: e => { + "use strict"; + e.exports = JSON.parse( + '["가격","가끔","가난","가능","가득","가르침","가뭄","가방","가상","가슴","가운데","가을","가이드","가입","가장","가정","가족","가죽","각오","각자","간격","간부","간섭","간장","간접","간판","갈등","갈비","갈색","갈증","감각","감기","감소","감수성","감자","감정","갑자기","강남","강당","강도","강력히","강변","강북","강사","강수량","강아지","강원도","강의","강제","강조","같이","개구리","개나리","개방","개별","개선","개성","개인","객관적","거실","거액","거울","거짓","거품","걱정","건강","건물","건설","건조","건축","걸음","검사","검토","게시판","게임","겨울","견해","결과","결국","결론","결석","결승","결심","결정","결혼","경계","경고","경기","경력","경복궁","경비","경상도","경영","경우","경쟁","경제","경주","경찰","경치","경향","경험","계곡","계단","계란","계산","계속","계약","계절","계층","계획","고객","고구려","고궁","고급","고등학생","고무신","고민","고양이","고장","고전","고집","고춧가루","고통","고향","곡식","골목","골짜기","골프","공간","공개","공격","공군","공급","공기","공동","공무원","공부","공사","공식","공업","공연","공원","공장","공짜","공책","공통","공포","공항","공휴일","과목","과일","과장","과정","과학","관객","관계","관광","관념","관람","관련","관리","관습","관심","관점","관찰","광경","광고","광장","광주","괴로움","굉장히","교과서","교문","교복","교실","교양","교육","교장","교직","교통","교환","교훈","구경","구름","구멍","구별","구분","구석","구성","구속","구역","구입","구청","구체적","국가","국기","국내","국립","국물","국민","국수","국어","국왕","국적","국제","국회","군대","군사","군인","궁극적","권리","권위","권투","귀국","귀신","규정","규칙","균형","그날","그냥","그늘","그러나","그룹","그릇","그림","그제서야","그토록","극복","극히","근거","근교","근래","근로","근무","근본","근원","근육","근처","글씨","글자","금강산","금고","금년","금메달","금액","금연","금요일","금지","긍정적","기간","기관","기념","기능","기독교","기둥","기록","기름","기법","기본","기분","기쁨","기숙사","기술","기억","기업","기온","기운","기원","기적","기준","기침","기혼","기획","긴급","긴장","길이","김밥","김치","김포공항","깍두기","깜빡","깨달음","깨소금","껍질","꼭대기","꽃잎","나들이","나란히","나머지","나물","나침반","나흘","낙엽","난방","날개","날씨","날짜","남녀","남대문","남매","남산","남자","남편","남학생","낭비","낱말","내년","내용","내일","냄비","냄새","냇물","냉동","냉면","냉방","냉장고","넥타이","넷째","노동","노란색","노력","노인","녹음","녹차","녹화","논리","논문","논쟁","놀이","농구","농담","농민","농부","농업","농장","농촌","높이","눈동자","눈물","눈썹","뉴욕","느낌","늑대","능동적","능력","다방","다양성","다음","다이어트","다행","단계","단골","단독","단맛","단순","단어","단위","단점","단체","단추","단편","단풍","달걀","달러","달력","달리","닭고기","담당","담배","담요","담임","답변","답장","당근","당분간","당연히","당장","대규모","대낮","대단히","대답","대도시","대략","대량","대륙","대문","대부분","대신","대응","대장","대전","대접","대중","대책","대출","대충","대통령","대학","대한민국","대합실","대형","덩어리","데이트","도대체","도덕","도둑","도망","도서관","도심","도움","도입","도자기","도저히","도전","도중","도착","독감","독립","독서","독일","독창적","동화책","뒷모습","뒷산","딸아이","마누라","마늘","마당","마라톤","마련","마무리","마사지","마약","마요네즈","마을","마음","마이크","마중","마지막","마찬가지","마찰","마흔","막걸리","막내","막상","만남","만두","만세","만약","만일","만점","만족","만화","많이","말기","말씀","말투","맘대로","망원경","매년","매달","매력","매번","매스컴","매일","매장","맥주","먹이","먼저","먼지","멀리","메일","며느리","며칠","면담","멸치","명단","명령","명예","명의","명절","명칭","명함","모금","모니터","모델","모든","모범","모습","모양","모임","모조리","모집","모퉁이","목걸이","목록","목사","목소리","목숨","목적","목표","몰래","몸매","몸무게","몸살","몸속","몸짓","몸통","몹시","무관심","무궁화","무더위","무덤","무릎","무슨","무엇","무역","무용","무조건","무지개","무척","문구","문득","문법","문서","문제","문학","문화","물가","물건","물결","물고기","물론","물리학","물음","물질","물체","미국","미디어","미사일","미술","미역","미용실","미움","미인","미팅","미혼","민간","민족","민주","믿음","밀가루","밀리미터","밑바닥","바가지","바구니","바나나","바늘","바닥","바닷가","바람","바이러스","바탕","박물관","박사","박수","반대","반드시","반말","반발","반성","반응","반장","반죽","반지","반찬","받침","발가락","발걸음","발견","발달","발레","발목","발바닥","발생","발음","발자국","발전","발톱","발표","밤하늘","밥그릇","밥맛","밥상","밥솥","방금","방면","방문","방바닥","방법","방송","방식","방안","방울","방지","방학","방해","방향","배경","배꼽","배달","배드민턴","백두산","백색","백성","백인","백제","백화점","버릇","버섯","버튼","번개","번역","번지","번호","벌금","벌레","벌써","범위","범인","범죄","법률","법원","법적","법칙","베이징","벨트","변경","변동","변명","변신","변호사","변화","별도","별명","별일","병실","병아리","병원","보관","보너스","보라색","보람","보름","보상","보안","보자기","보장","보전","보존","보통","보편적","보험","복도","복사","복숭아","복습","볶음","본격적","본래","본부","본사","본성","본인","본질","볼펜","봉사","봉지","봉투","부근","부끄러움","부담","부동산","부문","부분","부산","부상","부엌","부인","부작용","부장","부정","부족","부지런히","부친","부탁","부품","부회장","북부","북한","분노","분량","분리","분명","분석","분야","분위기","분필","분홍색","불고기","불과","불교","불꽃","불만","불법","불빛","불안","불이익","불행","브랜드","비극","비난","비닐","비둘기","비디오","비로소","비만","비명","비밀","비바람","비빔밥","비상","비용","비율","비중","비타민","비판","빌딩","빗물","빗방울","빗줄기","빛깔","빨간색","빨래","빨리","사건","사계절","사나이","사냥","사람","사랑","사립","사모님","사물","사방","사상","사생활","사설","사슴","사실","사업","사용","사월","사장","사전","사진","사촌","사춘기","사탕","사투리","사흘","산길","산부인과","산업","산책","살림","살인","살짝","삼계탕","삼국","삼십","삼월","삼촌","상관","상금","상대","상류","상반기","상상","상식","상업","상인","상자","상점","상처","상추","상태","상표","상품","상황","새벽","색깔","색연필","생각","생명","생물","생방송","생산","생선","생신","생일","생활","서랍","서른","서명","서민","서비스","서양","서울","서적","서점","서쪽","서클","석사","석유","선거","선물","선배","선생","선수","선원","선장","선전","선택","선풍기","설거지","설날","설렁탕","설명","설문","설사","설악산","설치","설탕","섭씨","성공","성당","성명","성별","성인","성장","성적","성질","성함","세금","세미나","세상","세월","세종대왕","세탁","센터","센티미터","셋째","소규모","소극적","소금","소나기","소년","소득","소망","소문","소설","소속","소아과","소용","소원","소음","소중히","소지품","소질","소풍","소형","속담","속도","속옷","손가락","손길","손녀","손님","손등","손목","손뼉","손실","손질","손톱","손해","솔직히","솜씨","송아지","송이","송편","쇠고기","쇼핑","수건","수년","수단","수돗물","수동적","수면","수명","수박","수상","수석","수술","수시로","수업","수염","수영","수입","수준","수집","수출","수컷","수필","수학","수험생","수화기","숙녀","숙소","숙제","순간","순서","순수","순식간","순위","숟가락","술병","술집","숫자","스님","스물","스스로","스승","스웨터","스위치","스케이트","스튜디오","스트레스","스포츠","슬쩍","슬픔","습관","습기","승객","승리","승부","승용차","승진","시각","시간","시골","시금치","시나리오","시댁","시리즈","시멘트","시민","시부모","시선","시설","시스템","시아버지","시어머니","시월","시인","시일","시작","시장","시절","시점","시중","시즌","시집","시청","시합","시험","식구","식기","식당","식량","식료품","식물","식빵","식사","식생활","식초","식탁","식품","신고","신규","신념","신문","신발","신비","신사","신세","신용","신제품","신청","신체","신화","실감","실내","실력","실례","실망","실수","실습","실시","실장","실정","실질적","실천","실체","실컷","실태","실패","실험","실현","심리","심부름","심사","심장","심정","심판","쌍둥이","씨름","씨앗","아가씨","아나운서","아드님","아들","아쉬움","아스팔트","아시아","아울러","아저씨","아줌마","아직","아침","아파트","아프리카","아픔","아홉","아흔","악기","악몽","악수","안개","안경","안과","안내","안녕","안동","안방","안부","안주","알루미늄","알코올","암시","암컷","압력","앞날","앞문","애인","애정","액수","앨범","야간","야단","야옹","약간","약국","약속","약수","약점","약품","약혼녀","양념","양력","양말","양배추","양주","양파","어둠","어려움","어른","어젯밤","어쨌든","어쩌다가","어쩐지","언니","언덕","언론","언어","얼굴","얼른","얼음","얼핏","엄마","업무","업종","업체","엉덩이","엉망","엉터리","엊그제","에너지","에어컨","엔진","여건","여고생","여관","여군","여권","여대생","여덟","여동생","여든","여론","여름","여섯","여성","여왕","여인","여전히","여직원","여학생","여행","역사","역시","역할","연결","연구","연극","연기","연락","연설","연세","연속","연습","연애","연예인","연인","연장","연주","연출","연필","연합","연휴","열기","열매","열쇠","열심히","열정","열차","열흘","염려","엽서","영국","영남","영상","영양","영역","영웅","영원히","영하","영향","영혼","영화","옆구리","옆방","옆집","예감","예금","예방","예산","예상","예선","예술","예습","예식장","예약","예전","예절","예정","예컨대","옛날","오늘","오락","오랫동안","오렌지","오로지","오른발","오븐","오십","오염","오월","오전","오직","오징어","오페라","오피스텔","오히려","옥상","옥수수","온갖","온라인","온몸","온종일","온통","올가을","올림픽","올해","옷차림","와이셔츠","와인","완성","완전","왕비","왕자","왜냐하면","왠지","외갓집","외국","외로움","외삼촌","외출","외침","외할머니","왼발","왼손","왼쪽","요금","요일","요즘","요청","용기","용서","용어","우산","우선","우승","우연히","우정","우체국","우편","운동","운명","운반","운전","운행","울산","울음","움직임","웃어른","웃음","워낙","원고","원래","원서","원숭이","원인","원장","원피스","월급","월드컵","월세","월요일","웨이터","위반","위법","위성","위원","위험","위협","윗사람","유난히","유럽","유명","유물","유산","유적","유치원","유학","유행","유형","육군","육상","육십","육체","은행","음력","음료","음반","음성","음식","음악","음주","의견","의논","의문","의복","의식","의심","의외로","의욕","의원","의학","이것","이곳","이념","이놈","이달","이대로","이동","이렇게","이력서","이론적","이름","이민","이발소","이별","이불","이빨","이상","이성","이슬","이야기","이용","이웃","이월","이윽고","이익","이전","이중","이튿날","이틀","이혼","인간","인격","인공","인구","인근","인기","인도","인류","인물","인생","인쇄","인연","인원","인재","인종","인천","인체","인터넷","인하","인형","일곱","일기","일단","일대","일등","일반","일본","일부","일상","일생","일손","일요일","일월","일정","일종","일주일","일찍","일체","일치","일행","일회용","임금","임무","입대","입력","입맛","입사","입술","입시","입원","입장","입학","자가용","자격","자극","자동","자랑","자부심","자식","자신","자연","자원","자율","자전거","자정","자존심","자판","작가","작년","작성","작업","작용","작은딸","작품","잔디","잔뜩","잔치","잘못","잠깐","잠수함","잠시","잠옷","잠자리","잡지","장관","장군","장기간","장래","장례","장르","장마","장면","장모","장미","장비","장사","장소","장식","장애인","장인","장점","장차","장학금","재능","재빨리","재산","재생","재작년","재정","재채기","재판","재학","재활용","저것","저고리","저곳","저녁","저런","저렇게","저번","저울","저절로","저축","적극","적당히","적성","적용","적응","전개","전공","전기","전달","전라도","전망","전문","전반","전부","전세","전시","전용","전자","전쟁","전주","전철","전체","전통","전혀","전후","절대","절망","절반","절약","절차","점검","점수","점심","점원","점점","점차","접근","접시","접촉","젓가락","정거장","정도","정류장","정리","정말","정면","정문","정반대","정보","정부","정비","정상","정성","정오","정원","정장","정지","정치","정확히","제공","제과점","제대로","제목","제발","제법","제삿날","제안","제일","제작","제주도","제출","제품","제한","조각","조건","조금","조깅","조명","조미료","조상","조선","조용히","조절","조정","조직","존댓말","존재","졸업","졸음","종교","종로","종류","종소리","종업원","종종","종합","좌석","죄인","주관적","주름","주말","주머니","주먹","주문","주민","주방","주변","주식","주인","주일","주장","주전자","주택","준비","줄거리","줄기","줄무늬","중간","중계방송","중국","중년","중단","중독","중반","중부","중세","중소기업","중순","중앙","중요","중학교","즉석","즉시","즐거움","증가","증거","증권","증상","증세","지각","지갑","지경","지극히","지금","지급","지능","지름길","지리산","지방","지붕","지식","지역","지우개","지원","지적","지점","지진","지출","직선","직업","직원","직장","진급","진동","진로","진료","진리","진짜","진찰","진출","진통","진행","질문","질병","질서","짐작","집단","집안","집중","짜증","찌꺼기","차남","차라리","차량","차림","차별","차선","차츰","착각","찬물","찬성","참가","참기름","참새","참석","참여","참외","참조","찻잔","창가","창고","창구","창문","창밖","창작","창조","채널","채점","책가방","책방","책상","책임","챔피언","처벌","처음","천국","천둥","천장","천재","천천히","철도","철저히","철학","첫날","첫째","청년","청바지","청소","청춘","체계","체력","체온","체육","체중","체험","초등학생","초반","초밥","초상화","초순","초여름","초원","초저녁","초점","초청","초콜릿","촛불","총각","총리","총장","촬영","최근","최상","최선","최신","최악","최종","추석","추억","추진","추천","추측","축구","축소","축제","축하","출근","출발","출산","출신","출연","출입","출장","출판","충격","충고","충돌","충분히","충청도","취업","취직","취향","치약","친구","친척","칠십","칠월","칠판","침대","침묵","침실","칫솔","칭찬","카메라","카운터","칼국수","캐릭터","캠퍼스","캠페인","커튼","컨디션","컬러","컴퓨터","코끼리","코미디","콘서트","콜라","콤플렉스","콩나물","쾌감","쿠데타","크림","큰길","큰딸","큰소리","큰아들","큰어머니","큰일","큰절","클래식","클럽","킬로","타입","타자기","탁구","탁자","탄생","태권도","태양","태풍","택시","탤런트","터널","터미널","테니스","테스트","테이블","텔레비전","토론","토마토","토요일","통계","통과","통로","통신","통역","통일","통장","통제","통증","통합","통화","퇴근","퇴원","퇴직금","튀김","트럭","특급","특별","특성","특수","특징","특히","튼튼히","티셔츠","파란색","파일","파출소","판결","판단","판매","판사","팔십","팔월","팝송","패션","팩스","팩시밀리","팬티","퍼센트","페인트","편견","편의","편지","편히","평가","평균","평생","평소","평양","평일","평화","포스터","포인트","포장","포함","표면","표정","표준","표현","품목","품질","풍경","풍속","풍습","프랑스","프린터","플라스틱","피곤","피망","피아노","필름","필수","필요","필자","필통","핑계","하느님","하늘","하드웨어","하룻밤","하반기","하숙집","하순","하여튼","하지만","하천","하품","하필","학과","학교","학급","학기","학년","학력","학번","학부모","학비","학생","학술","학습","학용품","학원","학위","학자","학점","한계","한글","한꺼번에","한낮","한눈","한동안","한때","한라산","한마디","한문","한번","한복","한식","한여름","한쪽","할머니","할아버지","할인","함께","함부로","합격","합리적","항공","항구","항상","항의","해결","해군","해답","해당","해물","해석","해설","해수욕장","해안","핵심","핸드백","햄버거","햇볕","햇살","행동","행복","행사","행운","행위","향기","향상","향수","허락","허용","헬기","현관","현금","현대","현상","현실","현장","현재","현지","혈액","협력","형부","형사","형수","형식","형제","형태","형편","혜택","호기심","호남","호랑이","호박","호텔","호흡","혹시","홀로","홈페이지","홍보","홍수","홍차","화면","화분","화살","화요일","화장","화학","확보","확인","확장","확정","환갑","환경","환영","환율","환자","활기","활동","활발히","활용","활짝","회견","회관","회복","회색","회원","회장","회전","횟수","횡단보도","효율적","후반","후춧가루","훈련","훨씬","휴식","휴일","흉내","흐름","흑백","흑인","흔적","흔히","흥미","흥분","희곡","희망","희생","흰색","힘껏"]' + ); + }, + 8843: e => { + "use strict"; + e.exports = JSON.parse( + '["ábaco","abdomen","abeja","abierto","abogado","abono","aborto","abrazo","abrir","abuelo","abuso","acabar","academia","acceso","acción","aceite","acelga","acento","aceptar","ácido","aclarar","acné","acoger","acoso","activo","acto","actriz","actuar","acudir","acuerdo","acusar","adicto","admitir","adoptar","adorno","aduana","adulto","aéreo","afectar","afición","afinar","afirmar","ágil","agitar","agonía","agosto","agotar","agregar","agrio","agua","agudo","águila","aguja","ahogo","ahorro","aire","aislar","ajedrez","ajeno","ajuste","alacrán","alambre","alarma","alba","álbum","alcalde","aldea","alegre","alejar","alerta","aleta","alfiler","alga","algodón","aliado","aliento","alivio","alma","almeja","almíbar","altar","alteza","altivo","alto","altura","alumno","alzar","amable","amante","amapola","amargo","amasar","ámbar","ámbito","ameno","amigo","amistad","amor","amparo","amplio","ancho","anciano","ancla","andar","andén","anemia","ángulo","anillo","ánimo","anís","anotar","antena","antiguo","antojo","anual","anular","anuncio","añadir","añejo","año","apagar","aparato","apetito","apio","aplicar","apodo","aporte","apoyo","aprender","aprobar","apuesta","apuro","arado","araña","arar","árbitro","árbol","arbusto","archivo","arco","arder","ardilla","arduo","área","árido","aries","armonía","arnés","aroma","arpa","arpón","arreglo","arroz","arruga","arte","artista","asa","asado","asalto","ascenso","asegurar","aseo","asesor","asiento","asilo","asistir","asno","asombro","áspero","astilla","astro","astuto","asumir","asunto","atajo","ataque","atar","atento","ateo","ático","atleta","átomo","atraer","atroz","atún","audaz","audio","auge","aula","aumento","ausente","autor","aval","avance","avaro","ave","avellana","avena","avestruz","avión","aviso","ayer","ayuda","ayuno","azafrán","azar","azote","azúcar","azufre","azul","baba","babor","bache","bahía","baile","bajar","balanza","balcón","balde","bambú","banco","banda","baño","barba","barco","barniz","barro","báscula","bastón","basura","batalla","batería","batir","batuta","baúl","bazar","bebé","bebida","bello","besar","beso","bestia","bicho","bien","bingo","blanco","bloque","blusa","boa","bobina","bobo","boca","bocina","boda","bodega","boina","bola","bolero","bolsa","bomba","bondad","bonito","bono","bonsái","borde","borrar","bosque","bote","botín","bóveda","bozal","bravo","brazo","brecha","breve","brillo","brinco","brisa","broca","broma","bronce","brote","bruja","brusco","bruto","buceo","bucle","bueno","buey","bufanda","bufón","búho","buitre","bulto","burbuja","burla","burro","buscar","butaca","buzón","caballo","cabeza","cabina","cabra","cacao","cadáver","cadena","caer","café","caída","caimán","caja","cajón","cal","calamar","calcio","caldo","calidad","calle","calma","calor","calvo","cama","cambio","camello","camino","campo","cáncer","candil","canela","canguro","canica","canto","caña","cañón","caoba","caos","capaz","capitán","capote","captar","capucha","cara","carbón","cárcel","careta","carga","cariño","carne","carpeta","carro","carta","casa","casco","casero","caspa","castor","catorce","catre","caudal","causa","cazo","cebolla","ceder","cedro","celda","célebre","celoso","célula","cemento","ceniza","centro","cerca","cerdo","cereza","cero","cerrar","certeza","césped","cetro","chacal","chaleco","champú","chancla","chapa","charla","chico","chiste","chivo","choque","choza","chuleta","chupar","ciclón","ciego","cielo","cien","cierto","cifra","cigarro","cima","cinco","cine","cinta","ciprés","circo","ciruela","cisne","cita","ciudad","clamor","clan","claro","clase","clave","cliente","clima","clínica","cobre","cocción","cochino","cocina","coco","código","codo","cofre","coger","cohete","cojín","cojo","cola","colcha","colegio","colgar","colina","collar","colmo","columna","combate","comer","comida","cómodo","compra","conde","conejo","conga","conocer","consejo","contar","copa","copia","corazón","corbata","corcho","cordón","corona","correr","coser","cosmos","costa","cráneo","cráter","crear","crecer","creído","crema","cría","crimen","cripta","crisis","cromo","crónica","croqueta","crudo","cruz","cuadro","cuarto","cuatro","cubo","cubrir","cuchara","cuello","cuento","cuerda","cuesta","cueva","cuidar","culebra","culpa","culto","cumbre","cumplir","cuna","cuneta","cuota","cupón","cúpula","curar","curioso","curso","curva","cutis","dama","danza","dar","dardo","dátil","deber","débil","década","decir","dedo","defensa","definir","dejar","delfín","delgado","delito","demora","denso","dental","deporte","derecho","derrota","desayuno","deseo","desfile","desnudo","destino","desvío","detalle","detener","deuda","día","diablo","diadema","diamante","diana","diario","dibujo","dictar","diente","dieta","diez","difícil","digno","dilema","diluir","dinero","directo","dirigir","disco","diseño","disfraz","diva","divino","doble","doce","dolor","domingo","don","donar","dorado","dormir","dorso","dos","dosis","dragón","droga","ducha","duda","duelo","dueño","dulce","dúo","duque","durar","dureza","duro","ébano","ebrio","echar","eco","ecuador","edad","edición","edificio","editor","educar","efecto","eficaz","eje","ejemplo","elefante","elegir","elemento","elevar","elipse","élite","elixir","elogio","eludir","embudo","emitir","emoción","empate","empeño","empleo","empresa","enano","encargo","enchufe","encía","enemigo","enero","enfado","enfermo","engaño","enigma","enlace","enorme","enredo","ensayo","enseñar","entero","entrar","envase","envío","época","equipo","erizo","escala","escena","escolar","escribir","escudo","esencia","esfera","esfuerzo","espada","espejo","espía","esposa","espuma","esquí","estar","este","estilo","estufa","etapa","eterno","ética","etnia","evadir","evaluar","evento","evitar","exacto","examen","exceso","excusa","exento","exigir","exilio","existir","éxito","experto","explicar","exponer","extremo","fábrica","fábula","fachada","fácil","factor","faena","faja","falda","fallo","falso","faltar","fama","familia","famoso","faraón","farmacia","farol","farsa","fase","fatiga","fauna","favor","fax","febrero","fecha","feliz","feo","feria","feroz","fértil","fervor","festín","fiable","fianza","fiar","fibra","ficción","ficha","fideo","fiebre","fiel","fiera","fiesta","figura","fijar","fijo","fila","filete","filial","filtro","fin","finca","fingir","finito","firma","flaco","flauta","flecha","flor","flota","fluir","flujo","flúor","fobia","foca","fogata","fogón","folio","folleto","fondo","forma","forro","fortuna","forzar","fosa","foto","fracaso","frágil","franja","frase","fraude","freír","freno","fresa","frío","frito","fruta","fuego","fuente","fuerza","fuga","fumar","función","funda","furgón","furia","fusil","fútbol","futuro","gacela","gafas","gaita","gajo","gala","galería","gallo","gamba","ganar","gancho","ganga","ganso","garaje","garza","gasolina","gastar","gato","gavilán","gemelo","gemir","gen","género","genio","gente","geranio","gerente","germen","gesto","gigante","gimnasio","girar","giro","glaciar","globo","gloria","gol","golfo","goloso","golpe","goma","gordo","gorila","gorra","gota","goteo","gozar","grada","gráfico","grano","grasa","gratis","grave","grieta","grillo","gripe","gris","grito","grosor","grúa","grueso","grumo","grupo","guante","guapo","guardia","guerra","guía","guiño","guion","guiso","guitarra","gusano","gustar","haber","hábil","hablar","hacer","hacha","hada","hallar","hamaca","harina","haz","hazaña","hebilla","hebra","hecho","helado","helio","hembra","herir","hermano","héroe","hervir","hielo","hierro","hígado","higiene","hijo","himno","historia","hocico","hogar","hoguera","hoja","hombre","hongo","honor","honra","hora","hormiga","horno","hostil","hoyo","hueco","huelga","huerta","hueso","huevo","huida","huir","humano","húmedo","humilde","humo","hundir","huracán","hurto","icono","ideal","idioma","ídolo","iglesia","iglú","igual","ilegal","ilusión","imagen","imán","imitar","impar","imperio","imponer","impulso","incapaz","índice","inerte","infiel","informe","ingenio","inicio","inmenso","inmune","innato","insecto","instante","interés","íntimo","intuir","inútil","invierno","ira","iris","ironía","isla","islote","jabalí","jabón","jamón","jarabe","jardín","jarra","jaula","jazmín","jefe","jeringa","jinete","jornada","joroba","joven","joya","juerga","jueves","juez","jugador","jugo","juguete","juicio","junco","jungla","junio","juntar","júpiter","jurar","justo","juvenil","juzgar","kilo","koala","labio","lacio","lacra","lado","ladrón","lagarto","lágrima","laguna","laico","lamer","lámina","lámpara","lana","lancha","langosta","lanza","lápiz","largo","larva","lástima","lata","látex","latir","laurel","lavar","lazo","leal","lección","leche","lector","leer","legión","legumbre","lejano","lengua","lento","leña","león","leopardo","lesión","letal","letra","leve","leyenda","libertad","libro","licor","líder","lidiar","lienzo","liga","ligero","lima","límite","limón","limpio","lince","lindo","línea","lingote","lino","linterna","líquido","liso","lista","litera","litio","litro","llaga","llama","llanto","llave","llegar","llenar","llevar","llorar","llover","lluvia","lobo","loción","loco","locura","lógica","logro","lombriz","lomo","lonja","lote","lucha","lucir","lugar","lujo","luna","lunes","lupa","lustro","luto","luz","maceta","macho","madera","madre","maduro","maestro","mafia","magia","mago","maíz","maldad","maleta","malla","malo","mamá","mambo","mamut","manco","mando","manejar","manga","maniquí","manjar","mano","manso","manta","mañana","mapa","máquina","mar","marco","marea","marfil","margen","marido","mármol","marrón","martes","marzo","masa","máscara","masivo","matar","materia","matiz","matriz","máximo","mayor","mazorca","mecha","medalla","medio","médula","mejilla","mejor","melena","melón","memoria","menor","mensaje","mente","menú","mercado","merengue","mérito","mes","mesón","meta","meter","método","metro","mezcla","miedo","miel","miembro","miga","mil","milagro","militar","millón","mimo","mina","minero","mínimo","minuto","miope","mirar","misa","miseria","misil","mismo","mitad","mito","mochila","moción","moda","modelo","moho","mojar","molde","moler","molino","momento","momia","monarca","moneda","monja","monto","moño","morada","morder","moreno","morir","morro","morsa","mortal","mosca","mostrar","motivo","mover","móvil","mozo","mucho","mudar","mueble","muela","muerte","muestra","mugre","mujer","mula","muleta","multa","mundo","muñeca","mural","muro","músculo","museo","musgo","música","muslo","nácar","nación","nadar","naipe","naranja","nariz","narrar","nasal","natal","nativo","natural","náusea","naval","nave","navidad","necio","néctar","negar","negocio","negro","neón","nervio","neto","neutro","nevar","nevera","nicho","nido","niebla","nieto","niñez","niño","nítido","nivel","nobleza","noche","nómina","noria","norma","norte","nota","noticia","novato","novela","novio","nube","nuca","núcleo","nudillo","nudo","nuera","nueve","nuez","nulo","número","nutria","oasis","obeso","obispo","objeto","obra","obrero","observar","obtener","obvio","oca","ocaso","océano","ochenta","ocho","ocio","ocre","octavo","octubre","oculto","ocupar","ocurrir","odiar","odio","odisea","oeste","ofensa","oferta","oficio","ofrecer","ogro","oído","oír","ojo","ola","oleada","olfato","olivo","olla","olmo","olor","olvido","ombligo","onda","onza","opaco","opción","ópera","opinar","oponer","optar","óptica","opuesto","oración","orador","oral","órbita","orca","orden","oreja","órgano","orgía","orgullo","oriente","origen","orilla","oro","orquesta","oruga","osadía","oscuro","osezno","oso","ostra","otoño","otro","oveja","óvulo","óxido","oxígeno","oyente","ozono","pacto","padre","paella","página","pago","país","pájaro","palabra","palco","paleta","pálido","palma","paloma","palpar","pan","panal","pánico","pantera","pañuelo","papá","papel","papilla","paquete","parar","parcela","pared","parir","paro","párpado","parque","párrafo","parte","pasar","paseo","pasión","paso","pasta","pata","patio","patria","pausa","pauta","pavo","payaso","peatón","pecado","pecera","pecho","pedal","pedir","pegar","peine","pelar","peldaño","pelea","peligro","pellejo","pelo","peluca","pena","pensar","peñón","peón","peor","pepino","pequeño","pera","percha","perder","pereza","perfil","perico","perla","permiso","perro","persona","pesa","pesca","pésimo","pestaña","pétalo","petróleo","pez","pezuña","picar","pichón","pie","piedra","pierna","pieza","pijama","pilar","piloto","pimienta","pino","pintor","pinza","piña","piojo","pipa","pirata","pisar","piscina","piso","pista","pitón","pizca","placa","plan","plata","playa","plaza","pleito","pleno","plomo","pluma","plural","pobre","poco","poder","podio","poema","poesía","poeta","polen","policía","pollo","polvo","pomada","pomelo","pomo","pompa","poner","porción","portal","posada","poseer","posible","poste","potencia","potro","pozo","prado","precoz","pregunta","premio","prensa","preso","previo","primo","príncipe","prisión","privar","proa","probar","proceso","producto","proeza","profesor","programa","prole","promesa","pronto","propio","próximo","prueba","público","puchero","pudor","pueblo","puerta","puesto","pulga","pulir","pulmón","pulpo","pulso","puma","punto","puñal","puño","pupa","pupila","puré","quedar","queja","quemar","querer","queso","quieto","química","quince","quitar","rábano","rabia","rabo","ración","radical","raíz","rama","rampa","rancho","rango","rapaz","rápido","rapto","rasgo","raspa","rato","rayo","raza","razón","reacción","realidad","rebaño","rebote","recaer","receta","rechazo","recoger","recreo","recto","recurso","red","redondo","reducir","reflejo","reforma","refrán","refugio","regalo","regir","regla","regreso","rehén","reino","reír","reja","relato","relevo","relieve","relleno","reloj","remar","remedio","remo","rencor","rendir","renta","reparto","repetir","reposo","reptil","res","rescate","resina","respeto","resto","resumen","retiro","retorno","retrato","reunir","revés","revista","rey","rezar","rico","riego","rienda","riesgo","rifa","rígido","rigor","rincón","riñón","río","riqueza","risa","ritmo","rito","rizo","roble","roce","rociar","rodar","rodeo","rodilla","roer","rojizo","rojo","romero","romper","ron","ronco","ronda","ropa","ropero","rosa","rosca","rostro","rotar","rubí","rubor","rudo","rueda","rugir","ruido","ruina","ruleta","rulo","rumbo","rumor","ruptura","ruta","rutina","sábado","saber","sabio","sable","sacar","sagaz","sagrado","sala","saldo","salero","salir","salmón","salón","salsa","salto","salud","salvar","samba","sanción","sandía","sanear","sangre","sanidad","sano","santo","sapo","saque","sardina","sartén","sastre","satán","sauna","saxofón","sección","seco","secreto","secta","sed","seguir","seis","sello","selva","semana","semilla","senda","sensor","señal","señor","separar","sepia","sequía","ser","serie","sermón","servir","sesenta","sesión","seta","setenta","severo","sexo","sexto","sidra","siesta","siete","siglo","signo","sílaba","silbar","silencio","silla","símbolo","simio","sirena","sistema","sitio","situar","sobre","socio","sodio","sol","solapa","soldado","soledad","sólido","soltar","solución","sombra","sondeo","sonido","sonoro","sonrisa","sopa","soplar","soporte","sordo","sorpresa","sorteo","sostén","sótano","suave","subir","suceso","sudor","suegra","suelo","sueño","suerte","sufrir","sujeto","sultán","sumar","superar","suplir","suponer","supremo","sur","surco","sureño","surgir","susto","sutil","tabaco","tabique","tabla","tabú","taco","tacto","tajo","talar","talco","talento","talla","talón","tamaño","tambor","tango","tanque","tapa","tapete","tapia","tapón","taquilla","tarde","tarea","tarifa","tarjeta","tarot","tarro","tarta","tatuaje","tauro","taza","tazón","teatro","techo","tecla","técnica","tejado","tejer","tejido","tela","teléfono","tema","temor","templo","tenaz","tender","tener","tenis","tenso","teoría","terapia","terco","término","ternura","terror","tesis","tesoro","testigo","tetera","texto","tez","tibio","tiburón","tiempo","tienda","tierra","tieso","tigre","tijera","tilde","timbre","tímido","timo","tinta","tío","típico","tipo","tira","tirón","titán","títere","título","tiza","toalla","tobillo","tocar","tocino","todo","toga","toldo","tomar","tono","tonto","topar","tope","toque","tórax","torero","tormenta","torneo","toro","torpedo","torre","torso","tortuga","tos","tosco","toser","tóxico","trabajo","tractor","traer","tráfico","trago","traje","tramo","trance","trato","trauma","trazar","trébol","tregua","treinta","tren","trepar","tres","tribu","trigo","tripa","triste","triunfo","trofeo","trompa","tronco","tropa","trote","trozo","truco","trueno","trufa","tubería","tubo","tuerto","tumba","tumor","túnel","túnica","turbina","turismo","turno","tutor","ubicar","úlcera","umbral","unidad","unir","universo","uno","untar","uña","urbano","urbe","urgente","urna","usar","usuario","útil","utopía","uva","vaca","vacío","vacuna","vagar","vago","vaina","vajilla","vale","válido","valle","valor","válvula","vampiro","vara","variar","varón","vaso","vecino","vector","vehículo","veinte","vejez","vela","velero","veloz","vena","vencer","venda","veneno","vengar","venir","venta","venus","ver","verano","verbo","verde","vereda","verja","verso","verter","vía","viaje","vibrar","vicio","víctima","vida","vídeo","vidrio","viejo","viernes","vigor","vil","villa","vinagre","vino","viñedo","violín","viral","virgo","virtud","visor","víspera","vista","vitamina","viudo","vivaz","vivero","vivir","vivo","volcán","volumen","volver","voraz","votar","voto","voz","vuelo","vulgar","yacer","yate","yegua","yema","yerno","yeso","yodo","yoga","yogur","zafiro","zanja","zapato","zarza","zona","zorro","zumo","zurdo"]' + ); + }, + 36926: (e, t, r) => { + var a = r(62659).Buffer; + e.exports = { + check: function check(e) { + if (e.length < 8) return !1; + if (e.length > 72) return !1; + if (48 !== e[0]) return !1; + if (e[1] !== e.length - 2) return !1; + if (2 !== e[2]) return !1; + var t = e[3]; + if (0 === t) return !1; + if (5 + t >= e.length) return !1; + if (2 !== e[4 + t]) return !1; + var r = e[5 + t]; + return ( + 0 !== r && + 6 + t + r === e.length && + !(128 & e[4]) && + !(t > 1 && 0 === e[4] && !(128 & e[5])) && + !(128 & e[t + 6]) && + !(r > 1 && 0 === e[t + 6] && !(128 & e[t + 7])) + ); + }, + decode: function decode(e) { + if (e.length < 8) + throw new Error("DER sequence length is too short"); + if (e.length > 72) + throw new Error("DER sequence length is too long"); + if (48 !== e[0]) throw new Error("Expected DER sequence"); + if (e[1] !== e.length - 2) + throw new Error("DER sequence length is invalid"); + if (2 !== e[2]) throw new Error("Expected DER integer"); + var t = e[3]; + if (0 === t) throw new Error("R length is zero"); + if (5 + t >= e.length) throw new Error("R length is too long"); + if (2 !== e[4 + t]) throw new Error("Expected DER integer (2)"); + var r = e[5 + t]; + if (0 === r) throw new Error("S length is zero"); + if (6 + t + r !== e.length) + throw new Error("S length is invalid"); + if (128 & e[4]) throw new Error("R value is negative"); + if (t > 1 && 0 === e[4] && !(128 & e[5])) + throw new Error("R value excessively padded"); + if (128 & e[t + 6]) throw new Error("S value is negative"); + if (r > 1 && 0 === e[t + 6] && !(128 & e[t + 7])) + throw new Error("S value excessively padded"); + return { r: e.slice(4, 4 + t), s: e.slice(6 + t) }; + }, + encode: function encode(e, t) { + var r = e.length, + n = t.length; + if (0 === r) throw new Error("R length is zero"); + if (0 === n) throw new Error("S length is zero"); + if (r > 33) throw new Error("R length is too long"); + if (n > 33) throw new Error("S length is too long"); + if (128 & e[0]) throw new Error("R value is negative"); + if (128 & t[0]) throw new Error("S value is negative"); + if (r > 1 && 0 === e[0] && !(128 & e[1])) + throw new Error("R value excessively padded"); + if (n > 1 && 0 === t[0] && !(128 & t[1])) + throw new Error("S value excessively padded"); + var o = a.allocUnsafe(6 + r + n); + return ( + (o[0] = 48), + (o[1] = o.length - 2), + (o[2] = 2), + (o[3] = e.length), + e.copy(o, 4), + (o[4 + r] = 2), + (o[5 + r] = t.length), + t.copy(o, 6 + r), + o + ); + } + }; + }, + 97831: function (e, t, r) { + !(function (e, t) { + "use strict"; + function assert(e, t) { + if (!e) throw new Error(t || "Assertion failed"); + } + function inherits(e, t) { + e.super_ = t; + var TempCtor = function () {}; + (TempCtor.prototype = t.prototype), + (e.prototype = new TempCtor()), + (e.prototype.constructor = e); + } + function BN(e, t, r) { + if (BN.isBN(e)) return e; + (this.negative = 0), + (this.words = null), + (this.length = 0), + (this.red = null), + null !== e && + (("le" !== t && "be" !== t) || ((r = t), (t = 10)), + this._init(e || 0, t || 10, r || "be")); + } + var a; + "object" == typeof e ? (e.exports = BN) : (t.BN = BN), + (BN.BN = BN), + (BN.wordSize = 26); + try { + a = r(32574).Buffer; + } catch (e) {} + function parseHex(e, t, r) { + for (var a = 0, n = Math.min(e.length, r), o = t; o < n; o++) { + var c = e.charCodeAt(o) - 48; + (a <<= 4), + (a |= + c >= 49 && c <= 54 + ? c - 49 + 10 + : c >= 17 && c <= 22 + ? c - 17 + 10 + : 15 & c); + } + return a; + } + function parseBase(e, t, r, a) { + for (var n = 0, o = Math.min(e.length, r), c = t; c < o; c++) { + var d = e.charCodeAt(c) - 48; + (n *= a), + (n += d >= 49 ? d - 49 + 10 : d >= 17 ? d - 17 + 10 : d); + } + return n; + } + (BN.isBN = function isBN(e) { + return ( + e instanceof BN || + (null !== e && + "object" == typeof e && + e.constructor.wordSize === BN.wordSize && + Array.isArray(e.words)) + ); + }), + (BN.max = function max(e, t) { + return e.cmp(t) > 0 ? e : t; + }), + (BN.min = function min(e, t) { + return e.cmp(t) < 0 ? e : t; + }), + (BN.prototype._init = function init(e, t, r) { + if ("number" == typeof e) return this._initNumber(e, t, r); + if ("object" == typeof e) return this._initArray(e, t, r); + "hex" === t && (t = 16), + assert(t === (0 | t) && t >= 2 && t <= 36); + var a = 0; + "-" === (e = e.toString().replace(/\s+/g, ""))[0] && a++, + 16 === t ? this._parseHex(e, a) : this._parseBase(e, t, a), + "-" === e[0] && (this.negative = 1), + this.strip(), + "le" === r && this._initArray(this.toArray(), t, r); + }), + (BN.prototype._initNumber = function _initNumber(e, t, r) { + e < 0 && ((this.negative = 1), (e = -e)), + e < 67108864 + ? ((this.words = [67108863 & e]), (this.length = 1)) + : e < 4503599627370496 + ? ((this.words = [67108863 & e, (e / 67108864) & 67108863]), + (this.length = 2)) + : (assert(e < 9007199254740992), + (this.words = [ + 67108863 & e, + (e / 67108864) & 67108863, + 1 + ]), + (this.length = 3)), + "le" === r && this._initArray(this.toArray(), t, r); + }), + (BN.prototype._initArray = function _initArray(e, t, r) { + if ((assert("number" == typeof e.length), e.length <= 0)) + return (this.words = [0]), (this.length = 1), this; + (this.length = Math.ceil(e.length / 3)), + (this.words = new Array(this.length)); + for (var a = 0; a < this.length; a++) this.words[a] = 0; + var n, + o, + c = 0; + if ("be" === r) + for (a = e.length - 1, n = 0; a >= 0; a -= 3) + (o = e[a] | (e[a - 1] << 8) | (e[a - 2] << 16)), + (this.words[n] |= (o << c) & 67108863), + (this.words[n + 1] = (o >>> (26 - c)) & 67108863), + (c += 24) >= 26 && ((c -= 26), n++); + else if ("le" === r) + for (a = 0, n = 0; a < e.length; a += 3) + (o = e[a] | (e[a + 1] << 8) | (e[a + 2] << 16)), + (this.words[n] |= (o << c) & 67108863), + (this.words[n + 1] = (o >>> (26 - c)) & 67108863), + (c += 24) >= 26 && ((c -= 26), n++); + return this.strip(); + }), + (BN.prototype._parseHex = function _parseHex(e, t) { + (this.length = Math.ceil((e.length - t) / 6)), + (this.words = new Array(this.length)); + for (var r = 0; r < this.length; r++) this.words[r] = 0; + var a, + n, + o = 0; + for (r = e.length - 6, a = 0; r >= t; r -= 6) + (n = parseHex(e, r, r + 6)), + (this.words[a] |= (n << o) & 67108863), + (this.words[a + 1] |= (n >>> (26 - o)) & 4194303), + (o += 24) >= 26 && ((o -= 26), a++); + r + 6 !== t && + ((n = parseHex(e, t, r + 6)), + (this.words[a] |= (n << o) & 67108863), + (this.words[a + 1] |= (n >>> (26 - o)) & 4194303)), + this.strip(); + }), + (BN.prototype._parseBase = function _parseBase(e, t, r) { + (this.words = [0]), (this.length = 1); + for (var a = 0, n = 1; n <= 67108863; n *= t) a++; + a--, (n = (n / t) | 0); + for ( + var o = e.length - r, + c = o % a, + d = Math.min(o, o - c) + r, + s = 0, + u = r; + u < d; + u += a + ) + (s = parseBase(e, u, u + a, t)), + this.imuln(n), + this.words[0] + s < 67108864 + ? (this.words[0] += s) + : this._iaddn(s); + if (0 !== c) { + var b = 1; + for (s = parseBase(e, u, e.length, t), u = 0; u < c; u++) + b *= t; + this.imuln(b), + this.words[0] + s < 67108864 + ? (this.words[0] += s) + : this._iaddn(s); + } + }), + (BN.prototype.copy = function copy(e) { + e.words = new Array(this.length); + for (var t = 0; t < this.length; t++) + e.words[t] = this.words[t]; + (e.length = this.length), + (e.negative = this.negative), + (e.red = this.red); + }), + (BN.prototype.clone = function clone() { + var e = new BN(null); + return this.copy(e), e; + }), + (BN.prototype._expand = function _expand(e) { + for (; this.length < e; ) this.words[this.length++] = 0; + return this; + }), + (BN.prototype.strip = function strip() { + for (; this.length > 1 && 0 === this.words[this.length - 1]; ) + this.length--; + return this._normSign(); + }), + (BN.prototype._normSign = function _normSign() { + return ( + 1 === this.length && + 0 === this.words[0] && + (this.negative = 0), + this + ); + }), + (BN.prototype.inspect = function inspect() { + return ( + (this.red ? "" + ); + }); + var n = [ + "", + "0", + "00", + "000", + "0000", + "00000", + "000000", + "0000000", + "00000000", + "000000000", + "0000000000", + "00000000000", + "000000000000", + "0000000000000", + "00000000000000", + "000000000000000", + "0000000000000000", + "00000000000000000", + "000000000000000000", + "0000000000000000000", + "00000000000000000000", + "000000000000000000000", + "0000000000000000000000", + "00000000000000000000000", + "000000000000000000000000", + "0000000000000000000000000" + ], + o = [ + 0, + 0, + 25, + 16, + 12, + 11, + 10, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ], + c = [ + 0, + 0, + 33554432, + 43046721, + 16777216, + 48828125, + 60466176, + 40353607, + 16777216, + 43046721, + 1e7, + 19487171, + 35831808, + 62748517, + 7529536, + 11390625, + 16777216, + 24137569, + 34012224, + 47045881, + 64e6, + 4084101, + 5153632, + 6436343, + 7962624, + 9765625, + 11881376, + 14348907, + 17210368, + 20511149, + 243e5, + 28629151, + 33554432, + 39135393, + 45435424, + 52521875, + 60466176 + ]; + function smallMulTo(e, t, r) { + r.negative = t.negative ^ e.negative; + var a = (e.length + t.length) | 0; + (r.length = a), (a = (a - 1) | 0); + var n = 0 | e.words[0], + o = 0 | t.words[0], + c = n * o, + d = 67108863 & c, + s = (c / 67108864) | 0; + r.words[0] = d; + for (var u = 1; u < a; u++) { + for ( + var b = s >>> 26, + l = 67108863 & s, + h = Math.min(u, t.length - 1), + p = Math.max(0, u - e.length + 1); + p <= h; + p++ + ) { + var x = (u - p) | 0; + (b += + ((c = (n = 0 | e.words[x]) * (o = 0 | t.words[p]) + l) / + 67108864) | + 0), + (l = 67108863 & c); + } + (r.words[u] = 0 | l), (s = 0 | b); + } + return 0 !== s ? (r.words[u] = 0 | s) : r.length--, r.strip(); + } + (BN.prototype.toString = function toString(e, t) { + var r; + if (((t = 0 | t || 1), 16 === (e = e || 10) || "hex" === e)) { + r = ""; + for (var a = 0, d = 0, s = 0; s < this.length; s++) { + var u = this.words[s], + b = (16777215 & ((u << a) | d)).toString(16); + (r = + 0 !== (d = (u >>> (24 - a)) & 16777215) || + s !== this.length - 1 + ? n[6 - b.length] + b + r + : b + r), + (a += 2) >= 26 && ((a -= 26), s--); + } + for (0 !== d && (r = d.toString(16) + r); r.length % t != 0; ) + r = "0" + r; + return 0 !== this.negative && (r = "-" + r), r; + } + if (e === (0 | e) && e >= 2 && e <= 36) { + var l = o[e], + h = c[e]; + r = ""; + var p = this.clone(); + for (p.negative = 0; !p.isZero(); ) { + var x = p.modn(h).toString(e); + r = (p = p.idivn(h)).isZero() + ? x + r + : n[l - x.length] + x + r; + } + for (this.isZero() && (r = "0" + r); r.length % t != 0; ) + r = "0" + r; + return 0 !== this.negative && (r = "-" + r), r; + } + assert(!1, "Base should be between 2 and 36"); + }), + (BN.prototype.toNumber = function toNumber() { + var e = this.words[0]; + return ( + 2 === this.length + ? (e += 67108864 * this.words[1]) + : 3 === this.length && 1 === this.words[2] + ? (e += 4503599627370496 + 67108864 * this.words[1]) + : this.length > 2 && + assert(!1, "Number can only safely store up to 53 bits"), + 0 !== this.negative ? -e : e + ); + }), + (BN.prototype.toJSON = function toJSON() { + return this.toString(16); + }), + (BN.prototype.toBuffer = function toBuffer(e, t) { + return assert(void 0 !== a), this.toArrayLike(a, e, t); + }), + (BN.prototype.toArray = function toArray(e, t) { + return this.toArrayLike(Array, e, t); + }), + (BN.prototype.toArrayLike = function toArrayLike(e, t, r) { + var a = this.byteLength(), + n = r || Math.max(1, a); + assert(a <= n, "byte array longer than desired length"), + assert(n > 0, "Requested array length <= 0"), + this.strip(); + var o, + c, + d = "le" === t, + s = new e(n), + u = this.clone(); + if (d) { + for (c = 0; !u.isZero(); c++) + (o = u.andln(255)), u.iushrn(8), (s[c] = o); + for (; c < n; c++) s[c] = 0; + } else { + for (c = 0; c < n - a; c++) s[c] = 0; + for (c = 0; !u.isZero(); c++) + (o = u.andln(255)), u.iushrn(8), (s[n - c - 1] = o); + } + return s; + }), + Math.clz32 + ? (BN.prototype._countBits = function _countBits(e) { + return 32 - Math.clz32(e); + }) + : (BN.prototype._countBits = function _countBits(e) { + var t = e, + r = 0; + return ( + t >= 4096 && ((r += 13), (t >>>= 13)), + t >= 64 && ((r += 7), (t >>>= 7)), + t >= 8 && ((r += 4), (t >>>= 4)), + t >= 2 && ((r += 2), (t >>>= 2)), + r + t + ); + }), + (BN.prototype._zeroBits = function _zeroBits(e) { + if (0 === e) return 26; + var t = e, + r = 0; + return ( + 0 == (8191 & t) && ((r += 13), (t >>>= 13)), + 0 == (127 & t) && ((r += 7), (t >>>= 7)), + 0 == (15 & t) && ((r += 4), (t >>>= 4)), + 0 == (3 & t) && ((r += 2), (t >>>= 2)), + 0 == (1 & t) && r++, + r + ); + }), + (BN.prototype.bitLength = function bitLength() { + var e = this.words[this.length - 1], + t = this._countBits(e); + return 26 * (this.length - 1) + t; + }), + (BN.prototype.zeroBits = function zeroBits() { + if (this.isZero()) return 0; + for (var e = 0, t = 0; t < this.length; t++) { + var r = this._zeroBits(this.words[t]); + if (((e += r), 26 !== r)) break; + } + return e; + }), + (BN.prototype.byteLength = function byteLength() { + return Math.ceil(this.bitLength() / 8); + }), + (BN.prototype.toTwos = function toTwos(e) { + return 0 !== this.negative + ? this.abs().inotn(e).iaddn(1) + : this.clone(); + }), + (BN.prototype.fromTwos = function fromTwos(e) { + return this.testn(e - 1) + ? this.notn(e).iaddn(1).ineg() + : this.clone(); + }), + (BN.prototype.isNeg = function isNeg() { + return 0 !== this.negative; + }), + (BN.prototype.neg = function neg() { + return this.clone().ineg(); + }), + (BN.prototype.ineg = function ineg() { + return this.isZero() || (this.negative ^= 1), this; + }), + (BN.prototype.iuor = function iuor(e) { + for (; this.length < e.length; ) this.words[this.length++] = 0; + for (var t = 0; t < e.length; t++) + this.words[t] = this.words[t] | e.words[t]; + return this.strip(); + }), + (BN.prototype.ior = function ior(e) { + return assert(0 == (this.negative | e.negative)), this.iuor(e); + }), + (BN.prototype.or = function or(e) { + return this.length > e.length + ? this.clone().ior(e) + : e.clone().ior(this); + }), + (BN.prototype.uor = function uor(e) { + return this.length > e.length + ? this.clone().iuor(e) + : e.clone().iuor(this); + }), + (BN.prototype.iuand = function iuand(e) { + var t; + t = this.length > e.length ? e : this; + for (var r = 0; r < t.length; r++) + this.words[r] = this.words[r] & e.words[r]; + return (this.length = t.length), this.strip(); + }), + (BN.prototype.iand = function iand(e) { + return assert(0 == (this.negative | e.negative)), this.iuand(e); + }), + (BN.prototype.and = function and(e) { + return this.length > e.length + ? this.clone().iand(e) + : e.clone().iand(this); + }), + (BN.prototype.uand = function uand(e) { + return this.length > e.length + ? this.clone().iuand(e) + : e.clone().iuand(this); + }), + (BN.prototype.iuxor = function iuxor(e) { + var t, r; + this.length > e.length + ? ((t = this), (r = e)) + : ((t = e), (r = this)); + for (var a = 0; a < r.length; a++) + this.words[a] = t.words[a] ^ r.words[a]; + if (this !== t) + for (; a < t.length; a++) this.words[a] = t.words[a]; + return (this.length = t.length), this.strip(); + }), + (BN.prototype.ixor = function ixor(e) { + return assert(0 == (this.negative | e.negative)), this.iuxor(e); + }), + (BN.prototype.xor = function xor(e) { + return this.length > e.length + ? this.clone().ixor(e) + : e.clone().ixor(this); + }), + (BN.prototype.uxor = function uxor(e) { + return this.length > e.length + ? this.clone().iuxor(e) + : e.clone().iuxor(this); + }), + (BN.prototype.inotn = function inotn(e) { + assert("number" == typeof e && e >= 0); + var t = 0 | Math.ceil(e / 26), + r = e % 26; + this._expand(t), r > 0 && t--; + for (var a = 0; a < t; a++) + this.words[a] = 67108863 & ~this.words[a]; + return ( + r > 0 && + (this.words[a] = ~this.words[a] & (67108863 >> (26 - r))), + this.strip() + ); + }), + (BN.prototype.notn = function notn(e) { + return this.clone().inotn(e); + }), + (BN.prototype.setn = function setn(e, t) { + assert("number" == typeof e && e >= 0); + var r = (e / 26) | 0, + a = e % 26; + return ( + this._expand(r + 1), + (this.words[r] = t + ? this.words[r] | (1 << a) + : this.words[r] & ~(1 << a)), + this.strip() + ); + }), + (BN.prototype.iadd = function iadd(e) { + var t, r, a; + if (0 !== this.negative && 0 === e.negative) + return ( + (this.negative = 0), + (t = this.isub(e)), + (this.negative ^= 1), + this._normSign() + ); + if (0 === this.negative && 0 !== e.negative) + return ( + (e.negative = 0), + (t = this.isub(e)), + (e.negative = 1), + t._normSign() + ); + this.length > e.length + ? ((r = this), (a = e)) + : ((r = e), (a = this)); + for (var n = 0, o = 0; o < a.length; o++) + (t = (0 | r.words[o]) + (0 | a.words[o]) + n), + (this.words[o] = 67108863 & t), + (n = t >>> 26); + for (; 0 !== n && o < r.length; o++) + (t = (0 | r.words[o]) + n), + (this.words[o] = 67108863 & t), + (n = t >>> 26); + if (((this.length = r.length), 0 !== n)) + (this.words[this.length] = n), this.length++; + else if (r !== this) + for (; o < r.length; o++) this.words[o] = r.words[o]; + return this; + }), + (BN.prototype.add = function add(e) { + var t; + return 0 !== e.negative && 0 === this.negative + ? ((e.negative = 0), (t = this.sub(e)), (e.negative ^= 1), t) + : 0 === e.negative && 0 !== this.negative + ? ((this.negative = 0), + (t = e.sub(this)), + (this.negative = 1), + t) + : this.length > e.length + ? this.clone().iadd(e) + : e.clone().iadd(this); + }), + (BN.prototype.isub = function isub(e) { + if (0 !== e.negative) { + e.negative = 0; + var t = this.iadd(e); + return (e.negative = 1), t._normSign(); + } + if (0 !== this.negative) + return ( + (this.negative = 0), + this.iadd(e), + (this.negative = 1), + this._normSign() + ); + var r, + a, + n = this.cmp(e); + if (0 === n) + return ( + (this.negative = 0), + (this.length = 1), + (this.words[0] = 0), + this + ); + n > 0 ? ((r = this), (a = e)) : ((r = e), (a = this)); + for (var o = 0, c = 0; c < a.length; c++) + (o = (t = (0 | r.words[c]) - (0 | a.words[c]) + o) >> 26), + (this.words[c] = 67108863 & t); + for (; 0 !== o && c < r.length; c++) + (o = (t = (0 | r.words[c]) + o) >> 26), + (this.words[c] = 67108863 & t); + if (0 === o && c < r.length && r !== this) + for (; c < r.length; c++) this.words[c] = r.words[c]; + return ( + (this.length = Math.max(this.length, c)), + r !== this && (this.negative = 1), + this.strip() + ); + }), + (BN.prototype.sub = function sub(e) { + return this.clone().isub(e); + }); + var d = function comb10MulTo(e, t, r) { + var a, + n, + o, + c = e.words, + d = t.words, + s = r.words, + u = 0, + b = 0 | c[0], + l = 8191 & b, + h = b >>> 13, + p = 0 | c[1], + x = 8191 & p, + m = p >>> 13, + y = 0 | c[2], + g = 8191 & y, + v = y >>> 13, + w = 0 | c[3], + _ = 8191 & w, + k = w >>> 13, + B = 0 | c[4], + N = 8191 & B, + P = B >>> 13, + O = 0 | c[5], + I = 8191 & O, + L = O >>> 13, + C = 0 | c[6], + D = 8191 & C, + j = C >>> 13, + U = 0 | c[7], + z = 8191 & U, + W = U >>> 13, + H = 0 | c[8], + q = 8191 & H, + V = H >>> 13, + G = 0 | c[9], + Y = 8191 & G, + J = G >>> 13, + X = 0 | d[0], + Q = 8191 & X, + $ = X >>> 13, + et = 0 | d[1], + tt = 8191 & et, + rt = et >>> 13, + at = 0 | d[2], + nt = 8191 & at, + it = at >>> 13, + ot = 0 | d[3], + ct = 8191 & ot, + dt = ot >>> 13, + st = 0 | d[4], + ut = 8191 & st, + bt = st >>> 13, + ht = 0 | d[5], + pt = 8191 & ht, + xt = ht >>> 13, + mt = 0 | d[6], + yt = 8191 & mt, + vt = mt >>> 13, + wt = 0 | d[7], + At = 8191 & wt, + _t = wt >>> 13, + Mt = 0 | d[8], + kt = 8191 & Mt, + Et = Mt >>> 13, + St = 0 | d[9], + Bt = 8191 & St, + Nt = St >>> 13; + (r.negative = e.negative ^ t.negative), (r.length = 19); + var Rt = + (((u + (a = Math.imul(l, Q))) | 0) + + ((8191 & + (n = ((n = Math.imul(l, $)) + Math.imul(h, Q)) | 0)) << + 13)) | + 0; + (u = + ((((o = Math.imul(h, $)) + (n >>> 13)) | 0) + (Rt >>> 26)) | 0), + (Rt &= 67108863), + (a = Math.imul(x, Q)), + (n = ((n = Math.imul(x, $)) + Math.imul(m, Q)) | 0), + (o = Math.imul(m, $)); + var Tt = + (((u + (a = (a + Math.imul(l, tt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, rt)) | 0) + Math.imul(h, tt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, rt)) | 0) + (n >>> 13)) | 0) + + (Tt >>> 26)) | + 0), + (Tt &= 67108863), + (a = Math.imul(g, Q)), + (n = ((n = Math.imul(g, $)) + Math.imul(v, Q)) | 0), + (o = Math.imul(v, $)), + (a = (a + Math.imul(x, tt)) | 0), + (n = ((n = (n + Math.imul(x, rt)) | 0) + Math.imul(m, tt)) | 0), + (o = (o + Math.imul(m, rt)) | 0); + var Pt = + (((u + (a = (a + Math.imul(l, nt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, it)) | 0) + Math.imul(h, nt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, it)) | 0) + (n >>> 13)) | 0) + + (Pt >>> 26)) | + 0), + (Pt &= 67108863), + (a = Math.imul(_, Q)), + (n = ((n = Math.imul(_, $)) + Math.imul(k, Q)) | 0), + (o = Math.imul(k, $)), + (a = (a + Math.imul(g, tt)) | 0), + (n = ((n = (n + Math.imul(g, rt)) | 0) + Math.imul(v, tt)) | 0), + (o = (o + Math.imul(v, rt)) | 0), + (a = (a + Math.imul(x, nt)) | 0), + (n = ((n = (n + Math.imul(x, it)) | 0) + Math.imul(m, nt)) | 0), + (o = (o + Math.imul(m, it)) | 0); + var Ot = + (((u + (a = (a + Math.imul(l, ct)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, dt)) | 0) + Math.imul(h, ct)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, dt)) | 0) + (n >>> 13)) | 0) + + (Ot >>> 26)) | + 0), + (Ot &= 67108863), + (a = Math.imul(N, Q)), + (n = ((n = Math.imul(N, $)) + Math.imul(P, Q)) | 0), + (o = Math.imul(P, $)), + (a = (a + Math.imul(_, tt)) | 0), + (n = ((n = (n + Math.imul(_, rt)) | 0) + Math.imul(k, tt)) | 0), + (o = (o + Math.imul(k, rt)) | 0), + (a = (a + Math.imul(g, nt)) | 0), + (n = ((n = (n + Math.imul(g, it)) | 0) + Math.imul(v, nt)) | 0), + (o = (o + Math.imul(v, it)) | 0), + (a = (a + Math.imul(x, ct)) | 0), + (n = ((n = (n + Math.imul(x, dt)) | 0) + Math.imul(m, ct)) | 0), + (o = (o + Math.imul(m, dt)) | 0); + var It = + (((u + (a = (a + Math.imul(l, ut)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, bt)) | 0) + Math.imul(h, ut)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, bt)) | 0) + (n >>> 13)) | 0) + + (It >>> 26)) | + 0), + (It &= 67108863), + (a = Math.imul(I, Q)), + (n = ((n = Math.imul(I, $)) + Math.imul(L, Q)) | 0), + (o = Math.imul(L, $)), + (a = (a + Math.imul(N, tt)) | 0), + (n = ((n = (n + Math.imul(N, rt)) | 0) + Math.imul(P, tt)) | 0), + (o = (o + Math.imul(P, rt)) | 0), + (a = (a + Math.imul(_, nt)) | 0), + (n = ((n = (n + Math.imul(_, it)) | 0) + Math.imul(k, nt)) | 0), + (o = (o + Math.imul(k, it)) | 0), + (a = (a + Math.imul(g, ct)) | 0), + (n = ((n = (n + Math.imul(g, dt)) | 0) + Math.imul(v, ct)) | 0), + (o = (o + Math.imul(v, dt)) | 0), + (a = (a + Math.imul(x, ut)) | 0), + (n = ((n = (n + Math.imul(x, bt)) | 0) + Math.imul(m, ut)) | 0), + (o = (o + Math.imul(m, bt)) | 0); + var Lt = + (((u + (a = (a + Math.imul(l, pt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, xt)) | 0) + Math.imul(h, pt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, xt)) | 0) + (n >>> 13)) | 0) + + (Lt >>> 26)) | + 0), + (Lt &= 67108863), + (a = Math.imul(D, Q)), + (n = ((n = Math.imul(D, $)) + Math.imul(j, Q)) | 0), + (o = Math.imul(j, $)), + (a = (a + Math.imul(I, tt)) | 0), + (n = ((n = (n + Math.imul(I, rt)) | 0) + Math.imul(L, tt)) | 0), + (o = (o + Math.imul(L, rt)) | 0), + (a = (a + Math.imul(N, nt)) | 0), + (n = ((n = (n + Math.imul(N, it)) | 0) + Math.imul(P, nt)) | 0), + (o = (o + Math.imul(P, it)) | 0), + (a = (a + Math.imul(_, ct)) | 0), + (n = ((n = (n + Math.imul(_, dt)) | 0) + Math.imul(k, ct)) | 0), + (o = (o + Math.imul(k, dt)) | 0), + (a = (a + Math.imul(g, ut)) | 0), + (n = ((n = (n + Math.imul(g, bt)) | 0) + Math.imul(v, ut)) | 0), + (o = (o + Math.imul(v, bt)) | 0), + (a = (a + Math.imul(x, pt)) | 0), + (n = ((n = (n + Math.imul(x, xt)) | 0) + Math.imul(m, pt)) | 0), + (o = (o + Math.imul(m, xt)) | 0); + var Ct = + (((u + (a = (a + Math.imul(l, yt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, vt)) | 0) + Math.imul(h, yt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, vt)) | 0) + (n >>> 13)) | 0) + + (Ct >>> 26)) | + 0), + (Ct &= 67108863), + (a = Math.imul(z, Q)), + (n = ((n = Math.imul(z, $)) + Math.imul(W, Q)) | 0), + (o = Math.imul(W, $)), + (a = (a + Math.imul(D, tt)) | 0), + (n = ((n = (n + Math.imul(D, rt)) | 0) + Math.imul(j, tt)) | 0), + (o = (o + Math.imul(j, rt)) | 0), + (a = (a + Math.imul(I, nt)) | 0), + (n = ((n = (n + Math.imul(I, it)) | 0) + Math.imul(L, nt)) | 0), + (o = (o + Math.imul(L, it)) | 0), + (a = (a + Math.imul(N, ct)) | 0), + (n = ((n = (n + Math.imul(N, dt)) | 0) + Math.imul(P, ct)) | 0), + (o = (o + Math.imul(P, dt)) | 0), + (a = (a + Math.imul(_, ut)) | 0), + (n = ((n = (n + Math.imul(_, bt)) | 0) + Math.imul(k, ut)) | 0), + (o = (o + Math.imul(k, bt)) | 0), + (a = (a + Math.imul(g, pt)) | 0), + (n = ((n = (n + Math.imul(g, xt)) | 0) + Math.imul(v, pt)) | 0), + (o = (o + Math.imul(v, xt)) | 0), + (a = (a + Math.imul(x, yt)) | 0), + (n = ((n = (n + Math.imul(x, vt)) | 0) + Math.imul(m, yt)) | 0), + (o = (o + Math.imul(m, vt)) | 0); + var Dt = + (((u + (a = (a + Math.imul(l, At)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, _t)) | 0) + Math.imul(h, At)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, _t)) | 0) + (n >>> 13)) | 0) + + (Dt >>> 26)) | + 0), + (Dt &= 67108863), + (a = Math.imul(q, Q)), + (n = ((n = Math.imul(q, $)) + Math.imul(V, Q)) | 0), + (o = Math.imul(V, $)), + (a = (a + Math.imul(z, tt)) | 0), + (n = ((n = (n + Math.imul(z, rt)) | 0) + Math.imul(W, tt)) | 0), + (o = (o + Math.imul(W, rt)) | 0), + (a = (a + Math.imul(D, nt)) | 0), + (n = ((n = (n + Math.imul(D, it)) | 0) + Math.imul(j, nt)) | 0), + (o = (o + Math.imul(j, it)) | 0), + (a = (a + Math.imul(I, ct)) | 0), + (n = ((n = (n + Math.imul(I, dt)) | 0) + Math.imul(L, ct)) | 0), + (o = (o + Math.imul(L, dt)) | 0), + (a = (a + Math.imul(N, ut)) | 0), + (n = ((n = (n + Math.imul(N, bt)) | 0) + Math.imul(P, ut)) | 0), + (o = (o + Math.imul(P, bt)) | 0), + (a = (a + Math.imul(_, pt)) | 0), + (n = ((n = (n + Math.imul(_, xt)) | 0) + Math.imul(k, pt)) | 0), + (o = (o + Math.imul(k, xt)) | 0), + (a = (a + Math.imul(g, yt)) | 0), + (n = ((n = (n + Math.imul(g, vt)) | 0) + Math.imul(v, yt)) | 0), + (o = (o + Math.imul(v, vt)) | 0), + (a = (a + Math.imul(x, At)) | 0), + (n = ((n = (n + Math.imul(x, _t)) | 0) + Math.imul(m, At)) | 0), + (o = (o + Math.imul(m, _t)) | 0); + var jt = + (((u + (a = (a + Math.imul(l, kt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, Et)) | 0) + Math.imul(h, kt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, Et)) | 0) + (n >>> 13)) | 0) + + (jt >>> 26)) | + 0), + (jt &= 67108863), + (a = Math.imul(Y, Q)), + (n = ((n = Math.imul(Y, $)) + Math.imul(J, Q)) | 0), + (o = Math.imul(J, $)), + (a = (a + Math.imul(q, tt)) | 0), + (n = ((n = (n + Math.imul(q, rt)) | 0) + Math.imul(V, tt)) | 0), + (o = (o + Math.imul(V, rt)) | 0), + (a = (a + Math.imul(z, nt)) | 0), + (n = ((n = (n + Math.imul(z, it)) | 0) + Math.imul(W, nt)) | 0), + (o = (o + Math.imul(W, it)) | 0), + (a = (a + Math.imul(D, ct)) | 0), + (n = ((n = (n + Math.imul(D, dt)) | 0) + Math.imul(j, ct)) | 0), + (o = (o + Math.imul(j, dt)) | 0), + (a = (a + Math.imul(I, ut)) | 0), + (n = ((n = (n + Math.imul(I, bt)) | 0) + Math.imul(L, ut)) | 0), + (o = (o + Math.imul(L, bt)) | 0), + (a = (a + Math.imul(N, pt)) | 0), + (n = ((n = (n + Math.imul(N, xt)) | 0) + Math.imul(P, pt)) | 0), + (o = (o + Math.imul(P, xt)) | 0), + (a = (a + Math.imul(_, yt)) | 0), + (n = ((n = (n + Math.imul(_, vt)) | 0) + Math.imul(k, yt)) | 0), + (o = (o + Math.imul(k, vt)) | 0), + (a = (a + Math.imul(g, At)) | 0), + (n = ((n = (n + Math.imul(g, _t)) | 0) + Math.imul(v, At)) | 0), + (o = (o + Math.imul(v, _t)) | 0), + (a = (a + Math.imul(x, kt)) | 0), + (n = ((n = (n + Math.imul(x, Et)) | 0) + Math.imul(m, kt)) | 0), + (o = (o + Math.imul(m, Et)) | 0); + var Ft = + (((u + (a = (a + Math.imul(l, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(l, Nt)) | 0) + Math.imul(h, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(h, Nt)) | 0) + (n >>> 13)) | 0) + + (Ft >>> 26)) | + 0), + (Ft &= 67108863), + (a = Math.imul(Y, tt)), + (n = ((n = Math.imul(Y, rt)) + Math.imul(J, tt)) | 0), + (o = Math.imul(J, rt)), + (a = (a + Math.imul(q, nt)) | 0), + (n = ((n = (n + Math.imul(q, it)) | 0) + Math.imul(V, nt)) | 0), + (o = (o + Math.imul(V, it)) | 0), + (a = (a + Math.imul(z, ct)) | 0), + (n = ((n = (n + Math.imul(z, dt)) | 0) + Math.imul(W, ct)) | 0), + (o = (o + Math.imul(W, dt)) | 0), + (a = (a + Math.imul(D, ut)) | 0), + (n = ((n = (n + Math.imul(D, bt)) | 0) + Math.imul(j, ut)) | 0), + (o = (o + Math.imul(j, bt)) | 0), + (a = (a + Math.imul(I, pt)) | 0), + (n = ((n = (n + Math.imul(I, xt)) | 0) + Math.imul(L, pt)) | 0), + (o = (o + Math.imul(L, xt)) | 0), + (a = (a + Math.imul(N, yt)) | 0), + (n = ((n = (n + Math.imul(N, vt)) | 0) + Math.imul(P, yt)) | 0), + (o = (o + Math.imul(P, vt)) | 0), + (a = (a + Math.imul(_, At)) | 0), + (n = ((n = (n + Math.imul(_, _t)) | 0) + Math.imul(k, At)) | 0), + (o = (o + Math.imul(k, _t)) | 0), + (a = (a + Math.imul(g, kt)) | 0), + (n = ((n = (n + Math.imul(g, Et)) | 0) + Math.imul(v, kt)) | 0), + (o = (o + Math.imul(v, Et)) | 0); + var Ut = + (((u + (a = (a + Math.imul(x, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(x, Nt)) | 0) + Math.imul(m, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(m, Nt)) | 0) + (n >>> 13)) | 0) + + (Ut >>> 26)) | + 0), + (Ut &= 67108863), + (a = Math.imul(Y, nt)), + (n = ((n = Math.imul(Y, it)) + Math.imul(J, nt)) | 0), + (o = Math.imul(J, it)), + (a = (a + Math.imul(q, ct)) | 0), + (n = ((n = (n + Math.imul(q, dt)) | 0) + Math.imul(V, ct)) | 0), + (o = (o + Math.imul(V, dt)) | 0), + (a = (a + Math.imul(z, ut)) | 0), + (n = ((n = (n + Math.imul(z, bt)) | 0) + Math.imul(W, ut)) | 0), + (o = (o + Math.imul(W, bt)) | 0), + (a = (a + Math.imul(D, pt)) | 0), + (n = ((n = (n + Math.imul(D, xt)) | 0) + Math.imul(j, pt)) | 0), + (o = (o + Math.imul(j, xt)) | 0), + (a = (a + Math.imul(I, yt)) | 0), + (n = ((n = (n + Math.imul(I, vt)) | 0) + Math.imul(L, yt)) | 0), + (o = (o + Math.imul(L, vt)) | 0), + (a = (a + Math.imul(N, At)) | 0), + (n = ((n = (n + Math.imul(N, _t)) | 0) + Math.imul(P, At)) | 0), + (o = (o + Math.imul(P, _t)) | 0), + (a = (a + Math.imul(_, kt)) | 0), + (n = ((n = (n + Math.imul(_, Et)) | 0) + Math.imul(k, kt)) | 0), + (o = (o + Math.imul(k, Et)) | 0); + var zt = + (((u + (a = (a + Math.imul(g, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(g, Nt)) | 0) + Math.imul(v, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(v, Nt)) | 0) + (n >>> 13)) | 0) + + (zt >>> 26)) | + 0), + (zt &= 67108863), + (a = Math.imul(Y, ct)), + (n = ((n = Math.imul(Y, dt)) + Math.imul(J, ct)) | 0), + (o = Math.imul(J, dt)), + (a = (a + Math.imul(q, ut)) | 0), + (n = ((n = (n + Math.imul(q, bt)) | 0) + Math.imul(V, ut)) | 0), + (o = (o + Math.imul(V, bt)) | 0), + (a = (a + Math.imul(z, pt)) | 0), + (n = ((n = (n + Math.imul(z, xt)) | 0) + Math.imul(W, pt)) | 0), + (o = (o + Math.imul(W, xt)) | 0), + (a = (a + Math.imul(D, yt)) | 0), + (n = ((n = (n + Math.imul(D, vt)) | 0) + Math.imul(j, yt)) | 0), + (o = (o + Math.imul(j, vt)) | 0), + (a = (a + Math.imul(I, At)) | 0), + (n = ((n = (n + Math.imul(I, _t)) | 0) + Math.imul(L, At)) | 0), + (o = (o + Math.imul(L, _t)) | 0), + (a = (a + Math.imul(N, kt)) | 0), + (n = ((n = (n + Math.imul(N, Et)) | 0) + Math.imul(P, kt)) | 0), + (o = (o + Math.imul(P, Et)) | 0); + var Kt = + (((u + (a = (a + Math.imul(_, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(_, Nt)) | 0) + Math.imul(k, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(k, Nt)) | 0) + (n >>> 13)) | 0) + + (Kt >>> 26)) | + 0), + (Kt &= 67108863), + (a = Math.imul(Y, ut)), + (n = ((n = Math.imul(Y, bt)) + Math.imul(J, ut)) | 0), + (o = Math.imul(J, bt)), + (a = (a + Math.imul(q, pt)) | 0), + (n = ((n = (n + Math.imul(q, xt)) | 0) + Math.imul(V, pt)) | 0), + (o = (o + Math.imul(V, xt)) | 0), + (a = (a + Math.imul(z, yt)) | 0), + (n = ((n = (n + Math.imul(z, vt)) | 0) + Math.imul(W, yt)) | 0), + (o = (o + Math.imul(W, vt)) | 0), + (a = (a + Math.imul(D, At)) | 0), + (n = ((n = (n + Math.imul(D, _t)) | 0) + Math.imul(j, At)) | 0), + (o = (o + Math.imul(j, _t)) | 0), + (a = (a + Math.imul(I, kt)) | 0), + (n = ((n = (n + Math.imul(I, Et)) | 0) + Math.imul(L, kt)) | 0), + (o = (o + Math.imul(L, Et)) | 0); + var Wt = + (((u + (a = (a + Math.imul(N, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(N, Nt)) | 0) + Math.imul(P, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(P, Nt)) | 0) + (n >>> 13)) | 0) + + (Wt >>> 26)) | + 0), + (Wt &= 67108863), + (a = Math.imul(Y, pt)), + (n = ((n = Math.imul(Y, xt)) + Math.imul(J, pt)) | 0), + (o = Math.imul(J, xt)), + (a = (a + Math.imul(q, yt)) | 0), + (n = ((n = (n + Math.imul(q, vt)) | 0) + Math.imul(V, yt)) | 0), + (o = (o + Math.imul(V, vt)) | 0), + (a = (a + Math.imul(z, At)) | 0), + (n = ((n = (n + Math.imul(z, _t)) | 0) + Math.imul(W, At)) | 0), + (o = (o + Math.imul(W, _t)) | 0), + (a = (a + Math.imul(D, kt)) | 0), + (n = ((n = (n + Math.imul(D, Et)) | 0) + Math.imul(j, kt)) | 0), + (o = (o + Math.imul(j, Et)) | 0); + var Ht = + (((u + (a = (a + Math.imul(I, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(I, Nt)) | 0) + Math.imul(L, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(L, Nt)) | 0) + (n >>> 13)) | 0) + + (Ht >>> 26)) | + 0), + (Ht &= 67108863), + (a = Math.imul(Y, yt)), + (n = ((n = Math.imul(Y, vt)) + Math.imul(J, yt)) | 0), + (o = Math.imul(J, vt)), + (a = (a + Math.imul(q, At)) | 0), + (n = ((n = (n + Math.imul(q, _t)) | 0) + Math.imul(V, At)) | 0), + (o = (o + Math.imul(V, _t)) | 0), + (a = (a + Math.imul(z, kt)) | 0), + (n = ((n = (n + Math.imul(z, Et)) | 0) + Math.imul(W, kt)) | 0), + (o = (o + Math.imul(W, Et)) | 0); + var qt = + (((u + (a = (a + Math.imul(D, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(D, Nt)) | 0) + Math.imul(j, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(j, Nt)) | 0) + (n >>> 13)) | 0) + + (qt >>> 26)) | + 0), + (qt &= 67108863), + (a = Math.imul(Y, At)), + (n = ((n = Math.imul(Y, _t)) + Math.imul(J, At)) | 0), + (o = Math.imul(J, _t)), + (a = (a + Math.imul(q, kt)) | 0), + (n = ((n = (n + Math.imul(q, Et)) | 0) + Math.imul(V, kt)) | 0), + (o = (o + Math.imul(V, Et)) | 0); + var Vt = + (((u + (a = (a + Math.imul(z, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(z, Nt)) | 0) + Math.imul(W, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(W, Nt)) | 0) + (n >>> 13)) | 0) + + (Vt >>> 26)) | + 0), + (Vt &= 67108863), + (a = Math.imul(Y, kt)), + (n = ((n = Math.imul(Y, Et)) + Math.imul(J, kt)) | 0), + (o = Math.imul(J, Et)); + var Gt = + (((u + (a = (a + Math.imul(q, Bt)) | 0)) | 0) + + ((8191 & + (n = + ((n = (n + Math.imul(q, Nt)) | 0) + Math.imul(V, Bt)) | + 0)) << + 13)) | + 0; + (u = + ((((o = (o + Math.imul(V, Nt)) | 0) + (n >>> 13)) | 0) + + (Gt >>> 26)) | + 0), + (Gt &= 67108863); + var Zt = + (((u + (a = Math.imul(Y, Bt))) | 0) + + ((8191 & + (n = ((n = Math.imul(Y, Nt)) + Math.imul(J, Bt)) | 0)) << + 13)) | + 0; + return ( + (u = + ((((o = Math.imul(J, Nt)) + (n >>> 13)) | 0) + (Zt >>> 26)) | + 0), + (Zt &= 67108863), + (s[0] = Rt), + (s[1] = Tt), + (s[2] = Pt), + (s[3] = Ot), + (s[4] = It), + (s[5] = Lt), + (s[6] = Ct), + (s[7] = Dt), + (s[8] = jt), + (s[9] = Ft), + (s[10] = Ut), + (s[11] = zt), + (s[12] = Kt), + (s[13] = Wt), + (s[14] = Ht), + (s[15] = qt), + (s[16] = Vt), + (s[17] = Gt), + (s[18] = Zt), + 0 !== u && ((s[19] = u), r.length++), + r + ); + }; + function jumboMulTo(e, t, r) { + return new FFTM().mulp(e, t, r); + } + function FFTM(e, t) { + (this.x = e), (this.y = t); + } + Math.imul || (d = smallMulTo), + (BN.prototype.mulTo = function mulTo(e, t) { + var r = this.length + e.length; + return 10 === this.length && 10 === e.length + ? d(this, e, t) + : r < 63 + ? smallMulTo(this, e, t) + : r < 1024 + ? (function bigMulTo(e, t, r) { + (r.negative = t.negative ^ e.negative), + (r.length = e.length + t.length); + for (var a = 0, n = 0, o = 0; o < r.length - 1; o++) { + var c = n; + n = 0; + for ( + var d = 67108863 & a, + s = Math.min(o, t.length - 1), + u = Math.max(0, o - e.length + 1); + u <= s; + u++ + ) { + var b = o - u, + l = (0 | e.words[b]) * (0 | t.words[u]), + h = 67108863 & l; + (d = 67108863 & (h = (h + d) | 0)), + (n += + (c = + ((c = (c + ((l / 67108864) | 0)) | 0) + + (h >>> 26)) | + 0) >>> 26), + (c &= 67108863); + } + (r.words[o] = d), (a = c), (c = n); + } + return 0 !== a ? (r.words[o] = a) : r.length--, r.strip(); + })(this, e, t) + : jumboMulTo(this, e, t); + }), + (FFTM.prototype.makeRBT = function makeRBT(e) { + for ( + var t = new Array(e), + r = BN.prototype._countBits(e) - 1, + a = 0; + a < e; + a++ + ) + t[a] = this.revBin(a, r, e); + return t; + }), + (FFTM.prototype.revBin = function revBin(e, t, r) { + if (0 === e || e === r - 1) return e; + for (var a = 0, n = 0; n < t; n++) + (a |= (1 & e) << (t - n - 1)), (e >>= 1); + return a; + }), + (FFTM.prototype.permute = function permute(e, t, r, a, n, o) { + for (var c = 0; c < o; c++) (a[c] = t[e[c]]), (n[c] = r[e[c]]); + }), + (FFTM.prototype.transform = function transform(e, t, r, a, n, o) { + this.permute(o, e, t, r, a, n); + for (var c = 1; c < n; c <<= 1) + for ( + var d = c << 1, + s = Math.cos((2 * Math.PI) / d), + u = Math.sin((2 * Math.PI) / d), + b = 0; + b < n; + b += d + ) + for (var l = s, h = u, p = 0; p < c; p++) { + var x = r[b + p], + m = a[b + p], + y = r[b + p + c], + g = a[b + p + c], + v = l * y - h * g; + (g = l * g + h * y), + (y = v), + (r[b + p] = x + y), + (a[b + p] = m + g), + (r[b + p + c] = x - y), + (a[b + p + c] = m - g), + p !== d && + ((v = s * l - u * h), (h = s * h + u * l), (l = v)); + } + }), + (FFTM.prototype.guessLen13b = function guessLen13b(e, t) { + var r = 1 | Math.max(t, e), + a = 1 & r, + n = 0; + for (r = (r / 2) | 0; r; r >>>= 1) n++; + return 1 << (n + 1 + a); + }), + (FFTM.prototype.conjugate = function conjugate(e, t, r) { + if (!(r <= 1)) + for (var a = 0; a < r / 2; a++) { + var n = e[a]; + (e[a] = e[r - a - 1]), + (e[r - a - 1] = n), + (n = t[a]), + (t[a] = -t[r - a - 1]), + (t[r - a - 1] = -n); + } + }), + (FFTM.prototype.normalize13b = function normalize13b(e, t) { + for (var r = 0, a = 0; a < t / 2; a++) { + var n = + 8192 * Math.round(e[2 * a + 1] / t) + + Math.round(e[2 * a] / t) + + r; + (e[a] = 67108863 & n), + (r = n < 67108864 ? 0 : (n / 67108864) | 0); + } + return e; + }), + (FFTM.prototype.convert13b = function convert13b(e, t, r, a) { + for (var n = 0, o = 0; o < t; o++) + (n += 0 | e[o]), + (r[2 * o] = 8191 & n), + (n >>>= 13), + (r[2 * o + 1] = 8191 & n), + (n >>>= 13); + for (o = 2 * t; o < a; ++o) r[o] = 0; + assert(0 === n), assert(0 == (-8192 & n)); + }), + (FFTM.prototype.stub = function stub(e) { + for (var t = new Array(e), r = 0; r < e; r++) t[r] = 0; + return t; + }), + (FFTM.prototype.mulp = function mulp(e, t, r) { + var a = 2 * this.guessLen13b(e.length, t.length), + n = this.makeRBT(a), + o = this.stub(a), + c = new Array(a), + d = new Array(a), + s = new Array(a), + u = new Array(a), + b = new Array(a), + l = new Array(a), + h = r.words; + (h.length = a), + this.convert13b(e.words, e.length, c, a), + this.convert13b(t.words, t.length, u, a), + this.transform(c, o, d, s, a, n), + this.transform(u, o, b, l, a, n); + for (var p = 0; p < a; p++) { + var x = d[p] * b[p] - s[p] * l[p]; + (s[p] = d[p] * l[p] + s[p] * b[p]), (d[p] = x); + } + return ( + this.conjugate(d, s, a), + this.transform(d, s, h, o, a, n), + this.conjugate(h, o, a), + this.normalize13b(h, a), + (r.negative = e.negative ^ t.negative), + (r.length = e.length + t.length), + r.strip() + ); + }), + (BN.prototype.mul = function mul(e) { + var t = new BN(null); + return ( + (t.words = new Array(this.length + e.length)), + this.mulTo(e, t) + ); + }), + (BN.prototype.mulf = function mulf(e) { + var t = new BN(null); + return ( + (t.words = new Array(this.length + e.length)), + jumboMulTo(this, e, t) + ); + }), + (BN.prototype.imul = function imul(e) { + return this.clone().mulTo(e, this); + }), + (BN.prototype.imuln = function imuln(e) { + assert("number" == typeof e), assert(e < 67108864); + for (var t = 0, r = 0; r < this.length; r++) { + var a = (0 | this.words[r]) * e, + n = (67108863 & a) + (67108863 & t); + (t >>= 26), + (t += (a / 67108864) | 0), + (t += n >>> 26), + (this.words[r] = 67108863 & n); + } + return 0 !== t && ((this.words[r] = t), this.length++), this; + }), + (BN.prototype.muln = function muln(e) { + return this.clone().imuln(e); + }), + (BN.prototype.sqr = function sqr() { + return this.mul(this); + }), + (BN.prototype.isqr = function isqr() { + return this.imul(this.clone()); + }), + (BN.prototype.pow = function pow(e) { + var t = (function toBitArray(e) { + for ( + var t = new Array(e.bitLength()), r = 0; + r < t.length; + r++ + ) { + var a = (r / 26) | 0, + n = r % 26; + t[r] = (e.words[a] & (1 << n)) >>> n; + } + return t; + })(e); + if (0 === t.length) return new BN(1); + for ( + var r = this, a = 0; + a < t.length && 0 === t[a]; + a++, r = r.sqr() + ); + if (++a < t.length) + for (var n = r.sqr(); a < t.length; a++, n = n.sqr()) + 0 !== t[a] && (r = r.mul(n)); + return r; + }), + (BN.prototype.iushln = function iushln(e) { + assert("number" == typeof e && e >= 0); + var t, + r = e % 26, + a = (e - r) / 26, + n = (67108863 >>> (26 - r)) << (26 - r); + if (0 !== r) { + var o = 0; + for (t = 0; t < this.length; t++) { + var c = this.words[t] & n, + d = ((0 | this.words[t]) - c) << r; + (this.words[t] = d | o), (o = c >>> (26 - r)); + } + o && ((this.words[t] = o), this.length++); + } + if (0 !== a) { + for (t = this.length - 1; t >= 0; t--) + this.words[t + a] = this.words[t]; + for (t = 0; t < a; t++) this.words[t] = 0; + this.length += a; + } + return this.strip(); + }), + (BN.prototype.ishln = function ishln(e) { + return assert(0 === this.negative), this.iushln(e); + }), + (BN.prototype.iushrn = function iushrn(e, t, r) { + var a; + assert("number" == typeof e && e >= 0), + (a = t ? (t - (t % 26)) / 26 : 0); + var n = e % 26, + o = Math.min((e - n) / 26, this.length), + c = 67108863 ^ ((67108863 >>> n) << n), + d = r; + if (((a -= o), (a = Math.max(0, a)), d)) { + for (var s = 0; s < o; s++) d.words[s] = this.words[s]; + d.length = o; + } + if (0 === o); + else if (this.length > o) + for (this.length -= o, s = 0; s < this.length; s++) + this.words[s] = this.words[s + o]; + else (this.words[0] = 0), (this.length = 1); + var u = 0; + for (s = this.length - 1; s >= 0 && (0 !== u || s >= a); s--) { + var b = 0 | this.words[s]; + (this.words[s] = (u << (26 - n)) | (b >>> n)), (u = b & c); + } + return ( + d && 0 !== u && (d.words[d.length++] = u), + 0 === this.length && ((this.words[0] = 0), (this.length = 1)), + this.strip() + ); + }), + (BN.prototype.ishrn = function ishrn(e, t, r) { + return assert(0 === this.negative), this.iushrn(e, t, r); + }), + (BN.prototype.shln = function shln(e) { + return this.clone().ishln(e); + }), + (BN.prototype.ushln = function ushln(e) { + return this.clone().iushln(e); + }), + (BN.prototype.shrn = function shrn(e) { + return this.clone().ishrn(e); + }), + (BN.prototype.ushrn = function ushrn(e) { + return this.clone().iushrn(e); + }), + (BN.prototype.testn = function testn(e) { + assert("number" == typeof e && e >= 0); + var t = e % 26, + r = (e - t) / 26, + a = 1 << t; + return !(this.length <= r) && !!(this.words[r] & a); + }), + (BN.prototype.imaskn = function imaskn(e) { + assert("number" == typeof e && e >= 0); + var t = e % 26, + r = (e - t) / 26; + if ( + (assert( + 0 === this.negative, + "imaskn works only with positive numbers" + ), + this.length <= r) + ) + return this; + if ( + (0 !== t && r++, + (this.length = Math.min(r, this.length)), + 0 !== t) + ) { + var a = 67108863 ^ ((67108863 >>> t) << t); + this.words[this.length - 1] &= a; + } + return this.strip(); + }), + (BN.prototype.maskn = function maskn(e) { + return this.clone().imaskn(e); + }), + (BN.prototype.iaddn = function iaddn(e) { + return ( + assert("number" == typeof e), + assert(e < 67108864), + e < 0 + ? this.isubn(-e) + : 0 !== this.negative + ? 1 === this.length && (0 | this.words[0]) < e + ? ((this.words[0] = e - (0 | this.words[0])), + (this.negative = 0), + this) + : ((this.negative = 0), + this.isubn(e), + (this.negative = 1), + this) + : this._iaddn(e) + ); + }), + (BN.prototype._iaddn = function _iaddn(e) { + this.words[0] += e; + for ( + var t = 0; + t < this.length && this.words[t] >= 67108864; + t++ + ) + (this.words[t] -= 67108864), + t === this.length - 1 + ? (this.words[t + 1] = 1) + : this.words[t + 1]++; + return (this.length = Math.max(this.length, t + 1)), this; + }), + (BN.prototype.isubn = function isubn(e) { + if ((assert("number" == typeof e), assert(e < 67108864), e < 0)) + return this.iaddn(-e); + if (0 !== this.negative) + return ( + (this.negative = 0), + this.iaddn(e), + (this.negative = 1), + this + ); + if ( + ((this.words[0] -= e), 1 === this.length && this.words[0] < 0) + ) + (this.words[0] = -this.words[0]), (this.negative = 1); + else + for (var t = 0; t < this.length && this.words[t] < 0; t++) + (this.words[t] += 67108864), (this.words[t + 1] -= 1); + return this.strip(); + }), + (BN.prototype.addn = function addn(e) { + return this.clone().iaddn(e); + }), + (BN.prototype.subn = function subn(e) { + return this.clone().isubn(e); + }), + (BN.prototype.iabs = function iabs() { + return (this.negative = 0), this; + }), + (BN.prototype.abs = function abs() { + return this.clone().iabs(); + }), + (BN.prototype._ishlnsubmul = function _ishlnsubmul(e, t, r) { + var a, + n, + o = e.length + r; + this._expand(o); + var c = 0; + for (a = 0; a < e.length; a++) { + n = (0 | this.words[a + r]) + c; + var d = (0 | e.words[a]) * t; + (c = ((n -= 67108863 & d) >> 26) - ((d / 67108864) | 0)), + (this.words[a + r] = 67108863 & n); + } + for (; a < this.length - r; a++) + (c = (n = (0 | this.words[a + r]) + c) >> 26), + (this.words[a + r] = 67108863 & n); + if (0 === c) return this.strip(); + for (assert(-1 === c), c = 0, a = 0; a < this.length; a++) + (c = (n = -(0 | this.words[a]) + c) >> 26), + (this.words[a] = 67108863 & n); + return (this.negative = 1), this.strip(); + }), + (BN.prototype._wordDiv = function _wordDiv(e, t) { + var r = (this.length, e.length), + a = this.clone(), + n = e, + o = 0 | n.words[n.length - 1]; + 0 !== (r = 26 - this._countBits(o)) && + ((n = n.ushln(r)), + a.iushln(r), + (o = 0 | n.words[n.length - 1])); + var c, + d = a.length - n.length; + if ("mod" !== t) { + ((c = new BN(null)).length = d + 1), + (c.words = new Array(c.length)); + for (var s = 0; s < c.length; s++) c.words[s] = 0; + } + var u = a.clone()._ishlnsubmul(n, 1, d); + 0 === u.negative && ((a = u), c && (c.words[d] = 1)); + for (var b = d - 1; b >= 0; b--) { + var l = + 67108864 * (0 | a.words[n.length + b]) + + (0 | a.words[n.length + b - 1]); + for ( + l = Math.min((l / o) | 0, 67108863), + a._ishlnsubmul(n, l, b); + 0 !== a.negative; + + ) + l--, + (a.negative = 0), + a._ishlnsubmul(n, 1, b), + a.isZero() || (a.negative ^= 1); + c && (c.words[b] = l); + } + return ( + c && c.strip(), + a.strip(), + "div" !== t && 0 !== r && a.iushrn(r), + { div: c || null, mod: a } + ); + }), + (BN.prototype.divmod = function divmod(e, t, r) { + return ( + assert(!e.isZero()), + this.isZero() + ? { div: new BN(0), mod: new BN(0) } + : 0 !== this.negative && 0 === e.negative + ? ((o = this.neg().divmod(e, t)), + "mod" !== t && (a = o.div.neg()), + "div" !== t && + ((n = o.mod.neg()), r && 0 !== n.negative && n.iadd(e)), + { div: a, mod: n }) + : 0 === this.negative && 0 !== e.negative + ? ((o = this.divmod(e.neg(), t)), + "mod" !== t && (a = o.div.neg()), + { div: a, mod: o.mod }) + : 0 != (this.negative & e.negative) + ? ((o = this.neg().divmod(e.neg(), t)), + "div" !== t && + ((n = o.mod.neg()), r && 0 !== n.negative && n.isub(e)), + { div: o.div, mod: n }) + : e.length > this.length || this.cmp(e) < 0 + ? { div: new BN(0), mod: this } + : 1 === e.length + ? "div" === t + ? { div: this.divn(e.words[0]), mod: null } + : "mod" === t + ? { div: null, mod: new BN(this.modn(e.words[0])) } + : { + div: this.divn(e.words[0]), + mod: new BN(this.modn(e.words[0])) + } + : this._wordDiv(e, t) + ); + var a, n, o; + }), + (BN.prototype.div = function div(e) { + return this.divmod(e, "div", !1).div; + }), + (BN.prototype.mod = function mod(e) { + return this.divmod(e, "mod", !1).mod; + }), + (BN.prototype.umod = function umod(e) { + return this.divmod(e, "mod", !0).mod; + }), + (BN.prototype.divRound = function divRound(e) { + var t = this.divmod(e); + if (t.mod.isZero()) return t.div; + var r = 0 !== t.div.negative ? t.mod.isub(e) : t.mod, + a = e.ushrn(1), + n = e.andln(1), + o = r.cmp(a); + return o < 0 || (1 === n && 0 === o) + ? t.div + : 0 !== t.div.negative + ? t.div.isubn(1) + : t.div.iaddn(1); + }), + (BN.prototype.modn = function modn(e) { + assert(e <= 67108863); + for ( + var t = (1 << 26) % e, r = 0, a = this.length - 1; + a >= 0; + a-- + ) + r = (t * r + (0 | this.words[a])) % e; + return r; + }), + (BN.prototype.idivn = function idivn(e) { + assert(e <= 67108863); + for (var t = 0, r = this.length - 1; r >= 0; r--) { + var a = (0 | this.words[r]) + 67108864 * t; + (this.words[r] = (a / e) | 0), (t = a % e); + } + return this.strip(); + }), + (BN.prototype.divn = function divn(e) { + return this.clone().idivn(e); + }), + (BN.prototype.egcd = function egcd(e) { + assert(0 === e.negative), assert(!e.isZero()); + var t = this, + r = e.clone(); + t = 0 !== t.negative ? t.umod(e) : t.clone(); + for ( + var a = new BN(1), + n = new BN(0), + o = new BN(0), + c = new BN(1), + d = 0; + t.isEven() && r.isEven(); + + ) + t.iushrn(1), r.iushrn(1), ++d; + for (var s = r.clone(), u = t.clone(); !t.isZero(); ) { + for ( + var b = 0, l = 1; + 0 == (t.words[0] & l) && b < 26; + ++b, l <<= 1 + ); + if (b > 0) + for (t.iushrn(b); b-- > 0; ) + (a.isOdd() || n.isOdd()) && (a.iadd(s), n.isub(u)), + a.iushrn(1), + n.iushrn(1); + for ( + var h = 0, p = 1; + 0 == (r.words[0] & p) && h < 26; + ++h, p <<= 1 + ); + if (h > 0) + for (r.iushrn(h); h-- > 0; ) + (o.isOdd() || c.isOdd()) && (o.iadd(s), c.isub(u)), + o.iushrn(1), + c.iushrn(1); + t.cmp(r) >= 0 + ? (t.isub(r), a.isub(o), n.isub(c)) + : (r.isub(t), o.isub(a), c.isub(n)); + } + return { a: o, b: c, gcd: r.iushln(d) }; + }), + (BN.prototype._invmp = function _invmp(e) { + assert(0 === e.negative), assert(!e.isZero()); + var t = this, + r = e.clone(); + t = 0 !== t.negative ? t.umod(e) : t.clone(); + for ( + var a, n = new BN(1), o = new BN(0), c = r.clone(); + t.cmpn(1) > 0 && r.cmpn(1) > 0; + + ) { + for ( + var d = 0, s = 1; + 0 == (t.words[0] & s) && d < 26; + ++d, s <<= 1 + ); + if (d > 0) + for (t.iushrn(d); d-- > 0; ) + n.isOdd() && n.iadd(c), n.iushrn(1); + for ( + var u = 0, b = 1; + 0 == (r.words[0] & b) && u < 26; + ++u, b <<= 1 + ); + if (u > 0) + for (r.iushrn(u); u-- > 0; ) + o.isOdd() && o.iadd(c), o.iushrn(1); + t.cmp(r) >= 0 + ? (t.isub(r), n.isub(o)) + : (r.isub(t), o.isub(n)); + } + return ( + (a = 0 === t.cmpn(1) ? n : o).cmpn(0) < 0 && a.iadd(e), a + ); + }), + (BN.prototype.gcd = function gcd(e) { + if (this.isZero()) return e.abs(); + if (e.isZero()) return this.abs(); + var t = this.clone(), + r = e.clone(); + (t.negative = 0), (r.negative = 0); + for (var a = 0; t.isEven() && r.isEven(); a++) + t.iushrn(1), r.iushrn(1); + for (;;) { + for (; t.isEven(); ) t.iushrn(1); + for (; r.isEven(); ) r.iushrn(1); + var n = t.cmp(r); + if (n < 0) { + var o = t; + (t = r), (r = o); + } else if (0 === n || 0 === r.cmpn(1)) break; + t.isub(r); + } + return r.iushln(a); + }), + (BN.prototype.invm = function invm(e) { + return this.egcd(e).a.umod(e); + }), + (BN.prototype.isEven = function isEven() { + return 0 == (1 & this.words[0]); + }), + (BN.prototype.isOdd = function isOdd() { + return 1 == (1 & this.words[0]); + }), + (BN.prototype.andln = function andln(e) { + return this.words[0] & e; + }), + (BN.prototype.bincn = function bincn(e) { + assert("number" == typeof e); + var t = e % 26, + r = (e - t) / 26, + a = 1 << t; + if (this.length <= r) + return this._expand(r + 1), (this.words[r] |= a), this; + for (var n = a, o = r; 0 !== n && o < this.length; o++) { + var c = 0 | this.words[o]; + (n = (c += n) >>> 26), (c &= 67108863), (this.words[o] = c); + } + return 0 !== n && ((this.words[o] = n), this.length++), this; + }), + (BN.prototype.isZero = function isZero() { + return 1 === this.length && 0 === this.words[0]; + }), + (BN.prototype.cmpn = function cmpn(e) { + var t, + r = e < 0; + if (0 !== this.negative && !r) return -1; + if (0 === this.negative && r) return 1; + if ((this.strip(), this.length > 1)) t = 1; + else { + r && (e = -e), assert(e <= 67108863, "Number is too big"); + var a = 0 | this.words[0]; + t = a === e ? 0 : a < e ? -1 : 1; + } + return 0 !== this.negative ? 0 | -t : t; + }), + (BN.prototype.cmp = function cmp(e) { + if (0 !== this.negative && 0 === e.negative) return -1; + if (0 === this.negative && 0 !== e.negative) return 1; + var t = this.ucmp(e); + return 0 !== this.negative ? 0 | -t : t; + }), + (BN.prototype.ucmp = function ucmp(e) { + if (this.length > e.length) return 1; + if (this.length < e.length) return -1; + for (var t = 0, r = this.length - 1; r >= 0; r--) { + var a = 0 | this.words[r], + n = 0 | e.words[r]; + if (a !== n) { + a < n ? (t = -1) : a > n && (t = 1); + break; + } + } + return t; + }), + (BN.prototype.gtn = function gtn(e) { + return 1 === this.cmpn(e); + }), + (BN.prototype.gt = function gt(e) { + return 1 === this.cmp(e); + }), + (BN.prototype.gten = function gten(e) { + return this.cmpn(e) >= 0; + }), + (BN.prototype.gte = function gte(e) { + return this.cmp(e) >= 0; + }), + (BN.prototype.ltn = function ltn(e) { + return -1 === this.cmpn(e); + }), + (BN.prototype.lt = function lt(e) { + return -1 === this.cmp(e); + }), + (BN.prototype.lten = function lten(e) { + return this.cmpn(e) <= 0; + }), + (BN.prototype.lte = function lte(e) { + return this.cmp(e) <= 0; + }), + (BN.prototype.eqn = function eqn(e) { + return 0 === this.cmpn(e); + }), + (BN.prototype.eq = function eq(e) { + return 0 === this.cmp(e); + }), + (BN.red = function red(e) { + return new Red(e); + }), + (BN.prototype.toRed = function toRed(e) { + return ( + assert(!this.red, "Already a number in reduction context"), + assert(0 === this.negative, "red works only with positives"), + e.convertTo(this)._forceRed(e) + ); + }), + (BN.prototype.fromRed = function fromRed() { + return ( + assert( + this.red, + "fromRed works only with numbers in reduction context" + ), + this.red.convertFrom(this) + ); + }), + (BN.prototype._forceRed = function _forceRed(e) { + return (this.red = e), this; + }), + (BN.prototype.forceRed = function forceRed(e) { + return ( + assert(!this.red, "Already a number in reduction context"), + this._forceRed(e) + ); + }), + (BN.prototype.redAdd = function redAdd(e) { + return ( + assert(this.red, "redAdd works only with red numbers"), + this.red.add(this, e) + ); + }), + (BN.prototype.redIAdd = function redIAdd(e) { + return ( + assert(this.red, "redIAdd works only with red numbers"), + this.red.iadd(this, e) + ); + }), + (BN.prototype.redSub = function redSub(e) { + return ( + assert(this.red, "redSub works only with red numbers"), + this.red.sub(this, e) + ); + }), + (BN.prototype.redISub = function redISub(e) { + return ( + assert(this.red, "redISub works only with red numbers"), + this.red.isub(this, e) + ); + }), + (BN.prototype.redShl = function redShl(e) { + return ( + assert(this.red, "redShl works only with red numbers"), + this.red.shl(this, e) + ); + }), + (BN.prototype.redMul = function redMul(e) { + return ( + assert(this.red, "redMul works only with red numbers"), + this.red._verify2(this, e), + this.red.mul(this, e) + ); + }), + (BN.prototype.redIMul = function redIMul(e) { + return ( + assert(this.red, "redMul works only with red numbers"), + this.red._verify2(this, e), + this.red.imul(this, e) + ); + }), + (BN.prototype.redSqr = function redSqr() { + return ( + assert(this.red, "redSqr works only with red numbers"), + this.red._verify1(this), + this.red.sqr(this) + ); + }), + (BN.prototype.redISqr = function redISqr() { + return ( + assert(this.red, "redISqr works only with red numbers"), + this.red._verify1(this), + this.red.isqr(this) + ); + }), + (BN.prototype.redSqrt = function redSqrt() { + return ( + assert(this.red, "redSqrt works only with red numbers"), + this.red._verify1(this), + this.red.sqrt(this) + ); + }), + (BN.prototype.redInvm = function redInvm() { + return ( + assert(this.red, "redInvm works only with red numbers"), + this.red._verify1(this), + this.red.invm(this) + ); + }), + (BN.prototype.redNeg = function redNeg() { + return ( + assert(this.red, "redNeg works only with red numbers"), + this.red._verify1(this), + this.red.neg(this) + ); + }), + (BN.prototype.redPow = function redPow(e) { + return ( + assert(this.red && !e.red, "redPow(normalNum)"), + this.red._verify1(this), + this.red.pow(this, e) + ); + }); + var s = { k256: null, p224: null, p192: null, p25519: null }; + function MPrime(e, t) { + (this.name = e), + (this.p = new BN(t, 16)), + (this.n = this.p.bitLength()), + (this.k = new BN(1).iushln(this.n).isub(this.p)), + (this.tmp = this._tmp()); + } + function K256() { + MPrime.call( + this, + "k256", + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" + ); + } + function P224() { + MPrime.call( + this, + "p224", + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" + ); + } + function P192() { + MPrime.call( + this, + "p192", + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" + ); + } + function P25519() { + MPrime.call( + this, + "25519", + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" + ); + } + function Red(e) { + if ("string" == typeof e) { + var t = BN._prime(e); + (this.m = t.p), (this.prime = t); + } else + assert(e.gtn(1), "modulus must be greater than 1"), + (this.m = e), + (this.prime = null); + } + function Mont(e) { + Red.call(this, e), + (this.shift = this.m.bitLength()), + this.shift % 26 != 0 && (this.shift += 26 - (this.shift % 26)), + (this.r = new BN(1).iushln(this.shift)), + (this.r2 = this.imod(this.r.sqr())), + (this.rinv = this.r._invmp(this.m)), + (this.minv = this.rinv.mul(this.r).isubn(1).div(this.m)), + (this.minv = this.minv.umod(this.r)), + (this.minv = this.r.sub(this.minv)); + } + (MPrime.prototype._tmp = function _tmp() { + var e = new BN(null); + return (e.words = new Array(Math.ceil(this.n / 13))), e; + }), + (MPrime.prototype.ireduce = function ireduce(e) { + var t, + r = e; + do { + this.split(r, this.tmp), + (t = (r = (r = this.imulK(r)).iadd(this.tmp)).bitLength()); + } while (t > this.n); + var a = t < this.n ? -1 : r.ucmp(this.p); + return ( + 0 === a + ? ((r.words[0] = 0), (r.length = 1)) + : a > 0 + ? r.isub(this.p) + : void 0 !== r.strip + ? r.strip() + : r._strip(), + r + ); + }), + (MPrime.prototype.split = function split(e, t) { + e.iushrn(this.n, 0, t); + }), + (MPrime.prototype.imulK = function imulK(e) { + return e.imul(this.k); + }), + inherits(K256, MPrime), + (K256.prototype.split = function split(e, t) { + for ( + var r = 4194303, a = Math.min(e.length, 9), n = 0; + n < a; + n++ + ) + t.words[n] = e.words[n]; + if (((t.length = a), e.length <= 9)) + return (e.words[0] = 0), void (e.length = 1); + var o = e.words[9]; + for (t.words[t.length++] = o & r, n = 10; n < e.length; n++) { + var c = 0 | e.words[n]; + (e.words[n - 10] = ((c & r) << 4) | (o >>> 22)), (o = c); + } + (o >>>= 22), + (e.words[n - 10] = o), + 0 === o && e.length > 10 ? (e.length -= 10) : (e.length -= 9); + }), + (K256.prototype.imulK = function imulK(e) { + (e.words[e.length] = 0), + (e.words[e.length + 1] = 0), + (e.length += 2); + for (var t = 0, r = 0; r < e.length; r++) { + var a = 0 | e.words[r]; + (t += 977 * a), + (e.words[r] = 67108863 & t), + (t = 64 * a + ((t / 67108864) | 0)); + } + return ( + 0 === e.words[e.length - 1] && + (e.length--, 0 === e.words[e.length - 1] && e.length--), + e + ); + }), + inherits(P224, MPrime), + inherits(P192, MPrime), + inherits(P25519, MPrime), + (P25519.prototype.imulK = function imulK(e) { + for (var t = 0, r = 0; r < e.length; r++) { + var a = 19 * (0 | e.words[r]) + t, + n = 67108863 & a; + (a >>>= 26), (e.words[r] = n), (t = a); + } + return 0 !== t && (e.words[e.length++] = t), e; + }), + (BN._prime = function prime(e) { + if (s[e]) return s[e]; + var prime; + if ("k256" === e) prime = new K256(); + else if ("p224" === e) prime = new P224(); + else if ("p192" === e) prime = new P192(); + else { + if ("p25519" !== e) throw new Error("Unknown prime " + e); + prime = new P25519(); + } + return (s[e] = prime), prime; + }), + (Red.prototype._verify1 = function _verify1(e) { + assert(0 === e.negative, "red works only with positives"), + assert(e.red, "red works only with red numbers"); + }), + (Red.prototype._verify2 = function _verify2(e, t) { + assert( + 0 == (e.negative | t.negative), + "red works only with positives" + ), + assert( + e.red && e.red === t.red, + "red works only with red numbers" + ); + }), + (Red.prototype.imod = function imod(e) { + return this.prime + ? this.prime.ireduce(e)._forceRed(this) + : e.umod(this.m)._forceRed(this); + }), + (Red.prototype.neg = function neg(e) { + return e.isZero() ? e.clone() : this.m.sub(e)._forceRed(this); + }), + (Red.prototype.add = function add(e, t) { + this._verify2(e, t); + var r = e.add(t); + return r.cmp(this.m) >= 0 && r.isub(this.m), r._forceRed(this); + }), + (Red.prototype.iadd = function iadd(e, t) { + this._verify2(e, t); + var r = e.iadd(t); + return r.cmp(this.m) >= 0 && r.isub(this.m), r; + }), + (Red.prototype.sub = function sub(e, t) { + this._verify2(e, t); + var r = e.sub(t); + return r.cmpn(0) < 0 && r.iadd(this.m), r._forceRed(this); + }), + (Red.prototype.isub = function isub(e, t) { + this._verify2(e, t); + var r = e.isub(t); + return r.cmpn(0) < 0 && r.iadd(this.m), r; + }), + (Red.prototype.shl = function shl(e, t) { + return this._verify1(e), this.imod(e.ushln(t)); + }), + (Red.prototype.imul = function imul(e, t) { + return this._verify2(e, t), this.imod(e.imul(t)); + }), + (Red.prototype.mul = function mul(e, t) { + return this._verify2(e, t), this.imod(e.mul(t)); + }), + (Red.prototype.isqr = function isqr(e) { + return this.imul(e, e.clone()); + }), + (Red.prototype.sqr = function sqr(e) { + return this.mul(e, e); + }), + (Red.prototype.sqrt = function sqrt(e) { + if (e.isZero()) return e.clone(); + var t = this.m.andln(3); + if ((assert(t % 2 == 1), 3 === t)) { + var r = this.m.add(new BN(1)).iushrn(2); + return this.pow(e, r); + } + for ( + var a = this.m.subn(1), n = 0; + !a.isZero() && 0 === a.andln(1); + + ) + n++, a.iushrn(1); + assert(!a.isZero()); + var o = new BN(1).toRed(this), + c = o.redNeg(), + d = this.m.subn(1).iushrn(1), + s = this.m.bitLength(); + for ( + s = new BN(2 * s * s).toRed(this); + 0 !== this.pow(s, d).cmp(c); + + ) + s.redIAdd(c); + for ( + var u = this.pow(s, a), + b = this.pow(e, a.addn(1).iushrn(1)), + l = this.pow(e, a), + h = n; + 0 !== l.cmp(o); + + ) { + for (var p = l, x = 0; 0 !== p.cmp(o); x++) p = p.redSqr(); + assert(x < h); + var m = this.pow(u, new BN(1).iushln(h - x - 1)); + (b = b.redMul(m)), + (u = m.redSqr()), + (l = l.redMul(u)), + (h = x); + } + return b; + }), + (Red.prototype.invm = function invm(e) { + var t = e._invmp(this.m); + return 0 !== t.negative + ? ((t.negative = 0), this.imod(t).redNeg()) + : this.imod(t); + }), + (Red.prototype.pow = function pow(e, t) { + if (t.isZero()) return new BN(1).toRed(this); + if (0 === t.cmpn(1)) return e.clone(); + var r = new Array(16); + (r[0] = new BN(1).toRed(this)), (r[1] = e); + for (var a = 2; a < r.length; a++) r[a] = this.mul(r[a - 1], e); + var n = r[0], + o = 0, + c = 0, + d = t.bitLength() % 26; + for (0 === d && (d = 26), a = t.length - 1; a >= 0; a--) { + for (var s = t.words[a], u = d - 1; u >= 0; u--) { + var b = (s >> u) & 1; + n !== r[0] && (n = this.sqr(n)), + 0 !== b || 0 !== o + ? ((o <<= 1), + (o |= b), + (4 === ++c || (0 === a && 0 === u)) && + ((n = this.mul(n, r[o])), (c = 0), (o = 0))) + : (c = 0); + } + d = 26; + } + return n; + }), + (Red.prototype.convertTo = function convertTo(e) { + var t = e.umod(this.m); + return t === e ? t.clone() : t; + }), + (Red.prototype.convertFrom = function convertFrom(e) { + var t = e.clone(); + return (t.red = null), t; + }), + (BN.mont = function mont(e) { + return new Mont(e); + }), + inherits(Mont, Red), + (Mont.prototype.convertTo = function convertTo(e) { + return this.imod(e.ushln(this.shift)); + }), + (Mont.prototype.convertFrom = function convertFrom(e) { + var t = this.imod(e.mul(this.rinv)); + return (t.red = null), t; + }), + (Mont.prototype.imul = function imul(e, t) { + if (e.isZero() || t.isZero()) + return (e.words[0] = 0), (e.length = 1), e; + var r = e.imul(t), + a = r + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m), + n = r.isub(a).iushrn(this.shift), + o = n; + return ( + n.cmp(this.m) >= 0 + ? (o = n.isub(this.m)) + : n.cmpn(0) < 0 && (o = n.iadd(this.m)), + o._forceRed(this) + ); + }), + (Mont.prototype.mul = function mul(e, t) { + if (e.isZero() || t.isZero()) return new BN(0)._forceRed(this); + var r = e.mul(t), + a = r + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m), + n = r.isub(a).iushrn(this.shift), + o = n; + return ( + n.cmp(this.m) >= 0 + ? (o = n.isub(this.m)) + : n.cmpn(0) < 0 && (o = n.iadd(this.m)), + o._forceRed(this) + ); + }), + (Mont.prototype.invm = function invm(e) { + return this.imod(e._invmp(this.m).mul(this.r2))._forceRed(this); + }); + })((e = r.nmd(e)), this); + }, + 5834: (e, t, r) => { + var a; + function Rand(e) { + this.rand = e; + } + if ( + ((e.exports = function rand(e) { + return a || (a = new Rand(null)), a.generate(e); + }), + (e.exports.Rand = Rand), + (Rand.prototype.generate = function generate(e) { + return this._rand(e); + }), + (Rand.prototype._rand = function _rand(e) { + if (this.rand.getBytes) return this.rand.getBytes(e); + for (var t = new Uint8Array(e), r = 0; r < t.length; r++) + t[r] = this.rand.getByte(); + return t; + }), + "object" == typeof self) + ) + self.crypto && self.crypto.getRandomValues + ? (Rand.prototype._rand = function _rand(e) { + var t = new Uint8Array(e); + return self.crypto.getRandomValues(t), t; + }) + : self.msCrypto && self.msCrypto.getRandomValues + ? (Rand.prototype._rand = function _rand(e) { + var t = new Uint8Array(e); + return self.msCrypto.getRandomValues(t), t; + }) + : "object" == typeof window && + (Rand.prototype._rand = function () { + throw new Error("Not implemented yet"); + }); + else + try { + var n = r(63906); + if ("function" != typeof n.randomBytes) + throw new Error("Not supported"); + Rand.prototype._rand = function _rand(e) { + return n.randomBytes(e); + }; + } catch (e) {} + }, + 15936: (e, t, r) => { + var a = r(81435); + e.exports = a( + "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" + ); + }, + 40612: (e, t, r) => { + "use strict"; + var a = r(15936), + n = r(62659).Buffer; + e.exports = function (e) { + function decodeRaw(t) { + var r = t.slice(0, -4), + a = t.slice(-4), + n = e(r); + if ( + !((a[0] ^ n[0]) | (a[1] ^ n[1]) | (a[2] ^ n[2]) | (a[3] ^ n[3])) + ) + return r; + } + return { + encode: function encode(t) { + var r = e(t); + return a.encode(n.concat([t, r], t.length + 4)); + }, + decode: function decode(e) { + var t = decodeRaw(a.decode(e)); + if (!t) throw new Error("Invalid checksum"); + return t; + }, + decodeUnsafe: function decodeUnsafe(e) { + var t = a.decodeUnsafe(e); + if (t) return decodeRaw(t); + } + }; + }; + }, + 71975: (e, t, r) => { + "use strict"; + var a = r(38492), + n = r(40612); + e.exports = n(function sha256x2(e) { + var t = a("sha256").update(e).digest(); + return a("sha256").update(t).digest(); + }); + }, + 98188: (e, t, r) => { + "use strict"; + var a = r(62226), + n = r(31820), + o = + "function" == typeof Symbol && "function" == typeof Symbol.for + ? Symbol.for("nodejs.util.inspect.custom") + : null; + (t.Buffer = Buffer), + (t.SlowBuffer = function SlowBuffer(e) { + +e != e && (e = 0); + return Buffer.alloc(+e); + }), + (t.INSPECT_MAX_BYTES = 50); + var c = 2147483647; + function createBuffer(e) { + if (e > c) + throw new RangeError( + 'The value "' + e + '" is invalid for option "size"' + ); + var t = new Uint8Array(e); + return Object.setPrototypeOf(t, Buffer.prototype), t; + } + function Buffer(e, t, r) { + if ("number" == typeof e) { + if ("string" == typeof t) + throw new TypeError( + 'The "string" argument must be of type string. Received type number' + ); + return allocUnsafe(e); + } + return from(e, t, r); + } + function from(e, t, r) { + if ("string" == typeof e) + return (function fromString(e, t) { + ("string" == typeof t && "" !== t) || (t = "utf8"); + if (!Buffer.isEncoding(t)) + throw new TypeError("Unknown encoding: " + t); + var r = 0 | byteLength(e, t), + a = createBuffer(r), + n = a.write(e, t); + n !== r && (a = a.slice(0, n)); + return a; + })(e, t); + if (ArrayBuffer.isView(e)) return fromArrayLike(e); + if (null == e) + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + + typeof e + ); + if ( + isInstance(e, ArrayBuffer) || + (e && isInstance(e.buffer, ArrayBuffer)) + ) + return fromArrayBuffer(e, t, r); + if ( + "undefined" != typeof SharedArrayBuffer && + (isInstance(e, SharedArrayBuffer) || + (e && isInstance(e.buffer, SharedArrayBuffer))) + ) + return fromArrayBuffer(e, t, r); + if ("number" == typeof e) + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ); + var a = e.valueOf && e.valueOf(); + if (null != a && a !== e) return Buffer.from(a, t, r); + var n = (function fromObject(e) { + if (Buffer.isBuffer(e)) { + var t = 0 | checked(e.length), + r = createBuffer(t); + return 0 === r.length || e.copy(r, 0, 0, t), r; + } + if (void 0 !== e.length) + return "number" != typeof e.length || numberIsNaN(e.length) + ? createBuffer(0) + : fromArrayLike(e); + if ("Buffer" === e.type && Array.isArray(e.data)) + return fromArrayLike(e.data); + })(e); + if (n) return n; + if ( + "undefined" != typeof Symbol && + null != Symbol.toPrimitive && + "function" == typeof e[Symbol.toPrimitive] + ) + return Buffer.from(e[Symbol.toPrimitive]("string"), t, r); + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + + typeof e + ); + } + function assertSize(e) { + if ("number" != typeof e) + throw new TypeError('"size" argument must be of type number'); + if (e < 0) + throw new RangeError( + 'The value "' + e + '" is invalid for option "size"' + ); + } + function allocUnsafe(e) { + return assertSize(e), createBuffer(e < 0 ? 0 : 0 | checked(e)); + } + function fromArrayLike(e) { + for ( + var t = e.length < 0 ? 0 : 0 | checked(e.length), + r = createBuffer(t), + a = 0; + a < t; + a += 1 + ) + r[a] = 255 & e[a]; + return r; + } + function fromArrayBuffer(e, t, r) { + if (t < 0 || e.byteLength < t) + throw new RangeError('"offset" is outside of buffer bounds'); + if (e.byteLength < t + (r || 0)) + throw new RangeError('"length" is outside of buffer bounds'); + var a; + return ( + (a = + void 0 === t && void 0 === r + ? new Uint8Array(e) + : void 0 === r + ? new Uint8Array(e, t) + : new Uint8Array(e, t, r)), + Object.setPrototypeOf(a, Buffer.prototype), + a + ); + } + function checked(e) { + if (e >= c) + throw new RangeError( + "Attempt to allocate Buffer larger than maximum size: 0x" + + c.toString(16) + + " bytes" + ); + return 0 | e; + } + function byteLength(e, t) { + if (Buffer.isBuffer(e)) return e.length; + if (ArrayBuffer.isView(e) || isInstance(e, ArrayBuffer)) + return e.byteLength; + if ("string" != typeof e) + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + + typeof e + ); + var r = e.length, + a = arguments.length > 2 && !0 === arguments[2]; + if (!a && 0 === r) return 0; + for (var n = !1; ; ) + switch (t) { + case "ascii": + case "latin1": + case "binary": + return r; + case "utf8": + case "utf-8": + return utf8ToBytes(e).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return 2 * r; + case "hex": + return r >>> 1; + case "base64": + return base64ToBytes(e).length; + default: + if (n) return a ? -1 : utf8ToBytes(e).length; + (t = ("" + t).toLowerCase()), (n = !0); + } + } + function slowToString(e, t, r) { + var a = !1; + if (((void 0 === t || t < 0) && (t = 0), t > this.length)) + return ""; + if ( + ((void 0 === r || r > this.length) && (r = this.length), r <= 0) + ) + return ""; + if ((r >>>= 0) <= (t >>>= 0)) return ""; + for (e || (e = "utf8"); ; ) + switch (e) { + case "hex": + return hexSlice(this, t, r); + case "utf8": + case "utf-8": + return utf8Slice(this, t, r); + case "ascii": + return asciiSlice(this, t, r); + case "latin1": + case "binary": + return latin1Slice(this, t, r); + case "base64": + return base64Slice(this, t, r); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, t, r); + default: + if (a) throw new TypeError("Unknown encoding: " + e); + (e = (e + "").toLowerCase()), (a = !0); + } + } + function swap(e, t, r) { + var a = e[t]; + (e[t] = e[r]), (e[r] = a); + } + function bidirectionalIndexOf(e, t, r, a, n) { + if (0 === e.length) return -1; + if ( + ("string" == typeof r + ? ((a = r), (r = 0)) + : r > 2147483647 + ? (r = 2147483647) + : r < -2147483648 && (r = -2147483648), + numberIsNaN((r = +r)) && (r = n ? 0 : e.length - 1), + r < 0 && (r = e.length + r), + r >= e.length) + ) { + if (n) return -1; + r = e.length - 1; + } else if (r < 0) { + if (!n) return -1; + r = 0; + } + if ( + ("string" == typeof t && (t = Buffer.from(t, a)), + Buffer.isBuffer(t)) + ) + return 0 === t.length ? -1 : arrayIndexOf(e, t, r, a, n); + if ("number" == typeof t) + return ( + (t &= 255), + "function" == typeof Uint8Array.prototype.indexOf + ? n + ? Uint8Array.prototype.indexOf.call(e, t, r) + : Uint8Array.prototype.lastIndexOf.call(e, t, r) + : arrayIndexOf(e, [t], r, a, n) + ); + throw new TypeError("val must be string, number or Buffer"); + } + function arrayIndexOf(e, t, r, a, n) { + var o, + c = 1, + d = e.length, + s = t.length; + if ( + void 0 !== a && + ("ucs2" === (a = String(a).toLowerCase()) || + "ucs-2" === a || + "utf16le" === a || + "utf-16le" === a) + ) { + if (e.length < 2 || t.length < 2) return -1; + (c = 2), (d /= 2), (s /= 2), (r /= 2); + } + function read(e, t) { + return 1 === c ? e[t] : e.readUInt16BE(t * c); + } + if (n) { + var u = -1; + for (o = r; o < d; o++) + if (read(e, o) === read(t, -1 === u ? 0 : o - u)) { + if ((-1 === u && (u = o), o - u + 1 === s)) return u * c; + } else -1 !== u && (o -= o - u), (u = -1); + } else + for (r + s > d && (r = d - s), o = r; o >= 0; o--) { + for (var b = !0, l = 0; l < s; l++) + if (read(e, o + l) !== read(t, l)) { + b = !1; + break; + } + if (b) return o; + } + return -1; + } + function hexWrite(e, t, r, a) { + r = Number(r) || 0; + var n = e.length - r; + a ? (a = Number(a)) > n && (a = n) : (a = n); + var o = t.length; + a > o / 2 && (a = o / 2); + for (var c = 0; c < a; ++c) { + var d = parseInt(t.substr(2 * c, 2), 16); + if (numberIsNaN(d)) return c; + e[r + c] = d; + } + return c; + } + function utf8Write(e, t, r, a) { + return blitBuffer(utf8ToBytes(t, e.length - r), e, r, a); + } + function asciiWrite(e, t, r, a) { + return blitBuffer( + (function asciiToBytes(e) { + for (var t = [], r = 0; r < e.length; ++r) + t.push(255 & e.charCodeAt(r)); + return t; + })(t), + e, + r, + a + ); + } + function latin1Write(e, t, r, a) { + return asciiWrite(e, t, r, a); + } + function base64Write(e, t, r, a) { + return blitBuffer(base64ToBytes(t), e, r, a); + } + function ucs2Write(e, t, r, a) { + return blitBuffer( + (function utf16leToBytes(e, t) { + for ( + var r, a, n, o = [], c = 0; + c < e.length && !((t -= 2) < 0); + ++c + ) + (a = (r = e.charCodeAt(c)) >> 8), + (n = r % 256), + o.push(n), + o.push(a); + return o; + })(t, e.length - r), + e, + r, + a + ); + } + function base64Slice(e, t, r) { + return 0 === t && r === e.length + ? a.fromByteArray(e) + : a.fromByteArray(e.slice(t, r)); + } + function utf8Slice(e, t, r) { + r = Math.min(e.length, r); + for (var a = [], n = t; n < r; ) { + var o, + c, + s, + u, + b = e[n], + l = null, + h = b > 239 ? 4 : b > 223 ? 3 : b > 191 ? 2 : 1; + if (n + h <= r) + switch (h) { + case 1: + b < 128 && (l = b); + break; + case 2: + 128 == (192 & (o = e[n + 1])) && + (u = ((31 & b) << 6) | (63 & o)) > 127 && + (l = u); + break; + case 3: + (o = e[n + 1]), + (c = e[n + 2]), + 128 == (192 & o) && + 128 == (192 & c) && + (u = ((15 & b) << 12) | ((63 & o) << 6) | (63 & c)) > + 2047 && + (u < 55296 || u > 57343) && + (l = u); + break; + case 4: + (o = e[n + 1]), + (c = e[n + 2]), + (s = e[n + 3]), + 128 == (192 & o) && + 128 == (192 & c) && + 128 == (192 & s) && + (u = + ((15 & b) << 18) | + ((63 & o) << 12) | + ((63 & c) << 6) | + (63 & s)) > 65535 && + u < 1114112 && + (l = u); + } + null === l + ? ((l = 65533), (h = 1)) + : l > 65535 && + ((l -= 65536), + a.push(((l >>> 10) & 1023) | 55296), + (l = 56320 | (1023 & l))), + a.push(l), + (n += h); + } + return (function decodeCodePointsArray(e) { + var t = e.length; + if (t <= d) return String.fromCharCode.apply(String, e); + var r = "", + a = 0; + for (; a < t; ) + r += String.fromCharCode.apply(String, e.slice(a, (a += d))); + return r; + })(a); + } + (t.kMaxLength = c), + (Buffer.TYPED_ARRAY_SUPPORT = (function typedArraySupport() { + try { + var e = new Uint8Array(1), + t = { + foo: function () { + return 42; + } + }; + return ( + Object.setPrototypeOf(t, Uint8Array.prototype), + Object.setPrototypeOf(e, t), + 42 === e.foo() + ); + } catch (e) { + return !1; + } + })()), + Buffer.TYPED_ARRAY_SUPPORT || + "undefined" == typeof console || + "function" != typeof console.error || + console.error( + "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support." + ), + Object.defineProperty(Buffer.prototype, "parent", { + enumerable: !0, + get: function () { + if (Buffer.isBuffer(this)) return this.buffer; + } + }), + Object.defineProperty(Buffer.prototype, "offset", { + enumerable: !0, + get: function () { + if (Buffer.isBuffer(this)) return this.byteOffset; + } + }), + (Buffer.poolSize = 8192), + (Buffer.from = function (e, t, r) { + return from(e, t, r); + }), + Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype), + Object.setPrototypeOf(Buffer, Uint8Array), + (Buffer.alloc = function (e, t, r) { + return (function alloc(e, t, r) { + return ( + assertSize(e), + e <= 0 + ? createBuffer(e) + : void 0 !== t + ? "string" == typeof r + ? createBuffer(e).fill(t, r) + : createBuffer(e).fill(t) + : createBuffer(e) + ); + })(e, t, r); + }), + (Buffer.allocUnsafe = function (e) { + return allocUnsafe(e); + }), + (Buffer.allocUnsafeSlow = function (e) { + return allocUnsafe(e); + }), + (Buffer.isBuffer = function isBuffer(e) { + return null != e && !0 === e._isBuffer && e !== Buffer.prototype; + }), + (Buffer.compare = function compare(e, t) { + if ( + (isInstance(e, Uint8Array) && + (e = Buffer.from(e, e.offset, e.byteLength)), + isInstance(t, Uint8Array) && + (t = Buffer.from(t, t.offset, t.byteLength)), + !Buffer.isBuffer(e) || !Buffer.isBuffer(t)) + ) + throw new TypeError( + 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' + ); + if (e === t) return 0; + for ( + var r = e.length, a = t.length, n = 0, o = Math.min(r, a); + n < o; + ++n + ) + if (e[n] !== t[n]) { + (r = e[n]), (a = t[n]); + break; + } + return r < a ? -1 : a < r ? 1 : 0; + }), + (Buffer.isEncoding = function isEncoding(e) { + switch (String(e).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return !0; + default: + return !1; + } + }), + (Buffer.concat = function concat(e, t) { + if (!Array.isArray(e)) + throw new TypeError( + '"list" argument must be an Array of Buffers' + ); + if (0 === e.length) return Buffer.alloc(0); + var r; + if (void 0 === t) + for (t = 0, r = 0; r < e.length; ++r) t += e[r].length; + var a = Buffer.allocUnsafe(t), + n = 0; + for (r = 0; r < e.length; ++r) { + var o = e[r]; + if ( + (isInstance(o, Uint8Array) && (o = Buffer.from(o)), + !Buffer.isBuffer(o)) + ) + throw new TypeError( + '"list" argument must be an Array of Buffers' + ); + o.copy(a, n), (n += o.length); + } + return a; + }), + (Buffer.byteLength = byteLength), + (Buffer.prototype._isBuffer = !0), + (Buffer.prototype.swap16 = function swap16() { + var e = this.length; + if (e % 2 != 0) + throw new RangeError( + "Buffer size must be a multiple of 16-bits" + ); + for (var t = 0; t < e; t += 2) swap(this, t, t + 1); + return this; + }), + (Buffer.prototype.swap32 = function swap32() { + var e = this.length; + if (e % 4 != 0) + throw new RangeError( + "Buffer size must be a multiple of 32-bits" + ); + for (var t = 0; t < e; t += 4) + swap(this, t, t + 3), swap(this, t + 1, t + 2); + return this; + }), + (Buffer.prototype.swap64 = function swap64() { + var e = this.length; + if (e % 8 != 0) + throw new RangeError( + "Buffer size must be a multiple of 64-bits" + ); + for (var t = 0; t < e; t += 8) + swap(this, t, t + 7), + swap(this, t + 1, t + 6), + swap(this, t + 2, t + 5), + swap(this, t + 3, t + 4); + return this; + }), + (Buffer.prototype.toString = function toString() { + var e = this.length; + return 0 === e + ? "" + : 0 === arguments.length + ? utf8Slice(this, 0, e) + : slowToString.apply(this, arguments); + }), + (Buffer.prototype.toLocaleString = Buffer.prototype.toString), + (Buffer.prototype.equals = function equals(e) { + if (!Buffer.isBuffer(e)) + throw new TypeError("Argument must be a Buffer"); + return this === e || 0 === Buffer.compare(this, e); + }), + (Buffer.prototype.inspect = function inspect() { + var e = "", + r = t.INSPECT_MAX_BYTES; + return ( + (e = this.toString("hex", 0, r) + .replace(/(.{2})/g, "$1 ") + .trim()), + this.length > r && (e += " ... "), + "" + ); + }), + o && (Buffer.prototype[o] = Buffer.prototype.inspect), + (Buffer.prototype.compare = function compare(e, t, r, a, n) { + if ( + (isInstance(e, Uint8Array) && + (e = Buffer.from(e, e.offset, e.byteLength)), + !Buffer.isBuffer(e)) + ) + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + + typeof e + ); + if ( + (void 0 === t && (t = 0), + void 0 === r && (r = e ? e.length : 0), + void 0 === a && (a = 0), + void 0 === n && (n = this.length), + t < 0 || r > e.length || a < 0 || n > this.length) + ) + throw new RangeError("out of range index"); + if (a >= n && t >= r) return 0; + if (a >= n) return -1; + if (t >= r) return 1; + if (this === e) return 0; + for ( + var o = (n >>>= 0) - (a >>>= 0), + c = (r >>>= 0) - (t >>>= 0), + d = Math.min(o, c), + s = this.slice(a, n), + u = e.slice(t, r), + b = 0; + b < d; + ++b + ) + if (s[b] !== u[b]) { + (o = s[b]), (c = u[b]); + break; + } + return o < c ? -1 : c < o ? 1 : 0; + }), + (Buffer.prototype.includes = function includes(e, t, r) { + return -1 !== this.indexOf(e, t, r); + }), + (Buffer.prototype.indexOf = function indexOf(e, t, r) { + return bidirectionalIndexOf(this, e, t, r, !0); + }), + (Buffer.prototype.lastIndexOf = function lastIndexOf(e, t, r) { + return bidirectionalIndexOf(this, e, t, r, !1); + }), + (Buffer.prototype.write = function write(e, t, r, a) { + if (void 0 === t) (a = "utf8"), (r = this.length), (t = 0); + else if (void 0 === r && "string" == typeof t) + (a = t), (r = this.length), (t = 0); + else { + if (!isFinite(t)) + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + (t >>>= 0), + isFinite(r) + ? ((r >>>= 0), void 0 === a && (a = "utf8")) + : ((a = r), (r = void 0)); + } + var n = this.length - t; + if ( + ((void 0 === r || r > n) && (r = n), + (e.length > 0 && (r < 0 || t < 0)) || t > this.length) + ) + throw new RangeError("Attempt to write outside buffer bounds"); + a || (a = "utf8"); + for (var o = !1; ; ) + switch (a) { + case "hex": + return hexWrite(this, e, t, r); + case "utf8": + case "utf-8": + return utf8Write(this, e, t, r); + case "ascii": + return asciiWrite(this, e, t, r); + case "latin1": + case "binary": + return latin1Write(this, e, t, r); + case "base64": + return base64Write(this, e, t, r); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return ucs2Write(this, e, t, r); + default: + if (o) throw new TypeError("Unknown encoding: " + a); + (a = ("" + a).toLowerCase()), (o = !0); + } + }), + (Buffer.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0) + }; + }); + var d = 4096; + function asciiSlice(e, t, r) { + var a = ""; + r = Math.min(e.length, r); + for (var n = t; n < r; ++n) a += String.fromCharCode(127 & e[n]); + return a; + } + function latin1Slice(e, t, r) { + var a = ""; + r = Math.min(e.length, r); + for (var n = t; n < r; ++n) a += String.fromCharCode(e[n]); + return a; + } + function hexSlice(e, t, r) { + var a = e.length; + (!t || t < 0) && (t = 0), (!r || r < 0 || r > a) && (r = a); + for (var n = "", o = t; o < r; ++o) n += u[e[o]]; + return n; + } + function utf16leSlice(e, t, r) { + for (var a = e.slice(t, r), n = "", o = 0; o < a.length; o += 2) + n += String.fromCharCode(a[o] + 256 * a[o + 1]); + return n; + } + function checkOffset(e, t, r) { + if (e % 1 != 0 || e < 0) throw new RangeError("offset is not uint"); + if (e + t > r) + throw new RangeError("Trying to access beyond buffer length"); + } + function checkInt(e, t, r, a, n, o) { + if (!Buffer.isBuffer(e)) + throw new TypeError( + '"buffer" argument must be a Buffer instance' + ); + if (t > n || t < o) + throw new RangeError('"value" argument is out of bounds'); + if (r + a > e.length) throw new RangeError("Index out of range"); + } + function checkIEEE754(e, t, r, a, n, o) { + if (r + a > e.length) throw new RangeError("Index out of range"); + if (r < 0) throw new RangeError("Index out of range"); + } + function writeFloat(e, t, r, a, o) { + return ( + (t = +t), + (r >>>= 0), + o || checkIEEE754(e, 0, r, 4), + n.write(e, t, r, a, 23, 4), + r + 4 + ); + } + function writeDouble(e, t, r, a, o) { + return ( + (t = +t), + (r >>>= 0), + o || checkIEEE754(e, 0, r, 8), + n.write(e, t, r, a, 52, 8), + r + 8 + ); + } + (Buffer.prototype.slice = function slice(e, t) { + var r = this.length; + (e = ~~e) < 0 ? (e += r) < 0 && (e = 0) : e > r && (e = r), + (t = void 0 === t ? r : ~~t) < 0 + ? (t += r) < 0 && (t = 0) + : t > r && (t = r), + t < e && (t = e); + var a = this.subarray(e, t); + return Object.setPrototypeOf(a, Buffer.prototype), a; + }), + (Buffer.prototype.readUIntLE = function readUIntLE(e, t, r) { + (e >>>= 0), (t >>>= 0), r || checkOffset(e, t, this.length); + for (var a = this[e], n = 1, o = 0; ++o < t && (n *= 256); ) + a += this[e + o] * n; + return a; + }), + (Buffer.prototype.readUIntBE = function readUIntBE(e, t, r) { + (e >>>= 0), (t >>>= 0), r || checkOffset(e, t, this.length); + for (var a = this[e + --t], n = 1; t > 0 && (n *= 256); ) + a += this[e + --t] * n; + return a; + }), + (Buffer.prototype.readUInt8 = function readUInt8(e, t) { + return (e >>>= 0), t || checkOffset(e, 1, this.length), this[e]; + }), + (Buffer.prototype.readUInt16LE = function readUInt16LE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 2, this.length), + this[e] | (this[e + 1] << 8) + ); + }), + (Buffer.prototype.readUInt16BE = function readUInt16BE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 2, this.length), + (this[e] << 8) | this[e + 1] + ); + }), + (Buffer.prototype.readUInt32LE = function readUInt32LE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 4, this.length), + (this[e] | (this[e + 1] << 8) | (this[e + 2] << 16)) + + 16777216 * this[e + 3] + ); + }), + (Buffer.prototype.readUInt32BE = function readUInt32BE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 4, this.length), + 16777216 * this[e] + + ((this[e + 1] << 16) | (this[e + 2] << 8) | this[e + 3]) + ); + }), + (Buffer.prototype.readIntLE = function readIntLE(e, t, r) { + (e >>>= 0), (t >>>= 0), r || checkOffset(e, t, this.length); + for (var a = this[e], n = 1, o = 0; ++o < t && (n *= 256); ) + a += this[e + o] * n; + return a >= (n *= 128) && (a -= Math.pow(2, 8 * t)), a; + }), + (Buffer.prototype.readIntBE = function readIntBE(e, t, r) { + (e >>>= 0), (t >>>= 0), r || checkOffset(e, t, this.length); + for (var a = t, n = 1, o = this[e + --a]; a > 0 && (n *= 256); ) + o += this[e + --a] * n; + return o >= (n *= 128) && (o -= Math.pow(2, 8 * t)), o; + }), + (Buffer.prototype.readInt8 = function readInt8(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 1, this.length), + 128 & this[e] ? -1 * (255 - this[e] + 1) : this[e] + ); + }), + (Buffer.prototype.readInt16LE = function readInt16LE(e, t) { + (e >>>= 0), t || checkOffset(e, 2, this.length); + var r = this[e] | (this[e + 1] << 8); + return 32768 & r ? 4294901760 | r : r; + }), + (Buffer.prototype.readInt16BE = function readInt16BE(e, t) { + (e >>>= 0), t || checkOffset(e, 2, this.length); + var r = this[e + 1] | (this[e] << 8); + return 32768 & r ? 4294901760 | r : r; + }), + (Buffer.prototype.readInt32LE = function readInt32LE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 4, this.length), + this[e] | + (this[e + 1] << 8) | + (this[e + 2] << 16) | + (this[e + 3] << 24) + ); + }), + (Buffer.prototype.readInt32BE = function readInt32BE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 4, this.length), + (this[e] << 24) | + (this[e + 1] << 16) | + (this[e + 2] << 8) | + this[e + 3] + ); + }), + (Buffer.prototype.readFloatLE = function readFloatLE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 4, this.length), + n.read(this, e, !0, 23, 4) + ); + }), + (Buffer.prototype.readFloatBE = function readFloatBE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 4, this.length), + n.read(this, e, !1, 23, 4) + ); + }), + (Buffer.prototype.readDoubleLE = function readDoubleLE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 8, this.length), + n.read(this, e, !0, 52, 8) + ); + }), + (Buffer.prototype.readDoubleBE = function readDoubleBE(e, t) { + return ( + (e >>>= 0), + t || checkOffset(e, 8, this.length), + n.read(this, e, !1, 52, 8) + ); + }), + (Buffer.prototype.writeUIntLE = function writeUIntLE(e, t, r, a) { + ((e = +e), (t >>>= 0), (r >>>= 0), a) || + checkInt(this, e, t, r, Math.pow(2, 8 * r) - 1, 0); + var n = 1, + o = 0; + for (this[t] = 255 & e; ++o < r && (n *= 256); ) + this[t + o] = (e / n) & 255; + return t + r; + }), + (Buffer.prototype.writeUIntBE = function writeUIntBE(e, t, r, a) { + ((e = +e), (t >>>= 0), (r >>>= 0), a) || + checkInt(this, e, t, r, Math.pow(2, 8 * r) - 1, 0); + var n = r - 1, + o = 1; + for (this[t + n] = 255 & e; --n >= 0 && (o *= 256); ) + this[t + n] = (e / o) & 255; + return t + r; + }), + (Buffer.prototype.writeUInt8 = function writeUInt8(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 1, 255, 0), + (this[t] = 255 & e), + t + 1 + ); + }), + (Buffer.prototype.writeUInt16LE = function writeUInt16LE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 2, 65535, 0), + (this[t] = 255 & e), + (this[t + 1] = e >>> 8), + t + 2 + ); + }), + (Buffer.prototype.writeUInt16BE = function writeUInt16BE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 2, 65535, 0), + (this[t] = e >>> 8), + (this[t + 1] = 255 & e), + t + 2 + ); + }), + (Buffer.prototype.writeUInt32LE = function writeUInt32LE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 4, 4294967295, 0), + (this[t + 3] = e >>> 24), + (this[t + 2] = e >>> 16), + (this[t + 1] = e >>> 8), + (this[t] = 255 & e), + t + 4 + ); + }), + (Buffer.prototype.writeUInt32BE = function writeUInt32BE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 4, 4294967295, 0), + (this[t] = e >>> 24), + (this[t + 1] = e >>> 16), + (this[t + 2] = e >>> 8), + (this[t + 3] = 255 & e), + t + 4 + ); + }), + (Buffer.prototype.writeIntLE = function writeIntLE(e, t, r, a) { + if (((e = +e), (t >>>= 0), !a)) { + var n = Math.pow(2, 8 * r - 1); + checkInt(this, e, t, r, n - 1, -n); + } + var o = 0, + c = 1, + d = 0; + for (this[t] = 255 & e; ++o < r && (c *= 256); ) + e < 0 && 0 === d && 0 !== this[t + o - 1] && (d = 1), + (this[t + o] = (((e / c) >> 0) - d) & 255); + return t + r; + }), + (Buffer.prototype.writeIntBE = function writeIntBE(e, t, r, a) { + if (((e = +e), (t >>>= 0), !a)) { + var n = Math.pow(2, 8 * r - 1); + checkInt(this, e, t, r, n - 1, -n); + } + var o = r - 1, + c = 1, + d = 0; + for (this[t + o] = 255 & e; --o >= 0 && (c *= 256); ) + e < 0 && 0 === d && 0 !== this[t + o + 1] && (d = 1), + (this[t + o] = (((e / c) >> 0) - d) & 255); + return t + r; + }), + (Buffer.prototype.writeInt8 = function writeInt8(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 1, 127, -128), + e < 0 && (e = 255 + e + 1), + (this[t] = 255 & e), + t + 1 + ); + }), + (Buffer.prototype.writeInt16LE = function writeInt16LE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 2, 32767, -32768), + (this[t] = 255 & e), + (this[t + 1] = e >>> 8), + t + 2 + ); + }), + (Buffer.prototype.writeInt16BE = function writeInt16BE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 2, 32767, -32768), + (this[t] = e >>> 8), + (this[t + 1] = 255 & e), + t + 2 + ); + }), + (Buffer.prototype.writeInt32LE = function writeInt32LE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 4, 2147483647, -2147483648), + (this[t] = 255 & e), + (this[t + 1] = e >>> 8), + (this[t + 2] = e >>> 16), + (this[t + 3] = e >>> 24), + t + 4 + ); + }), + (Buffer.prototype.writeInt32BE = function writeInt32BE(e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || checkInt(this, e, t, 4, 2147483647, -2147483648), + e < 0 && (e = 4294967295 + e + 1), + (this[t] = e >>> 24), + (this[t + 1] = e >>> 16), + (this[t + 2] = e >>> 8), + (this[t + 3] = 255 & e), + t + 4 + ); + }), + (Buffer.prototype.writeFloatLE = function writeFloatLE(e, t, r) { + return writeFloat(this, e, t, !0, r); + }), + (Buffer.prototype.writeFloatBE = function writeFloatBE(e, t, r) { + return writeFloat(this, e, t, !1, r); + }), + (Buffer.prototype.writeDoubleLE = function writeDoubleLE(e, t, r) { + return writeDouble(this, e, t, !0, r); + }), + (Buffer.prototype.writeDoubleBE = function writeDoubleBE(e, t, r) { + return writeDouble(this, e, t, !1, r); + }), + (Buffer.prototype.copy = function copy(e, t, r, a) { + if (!Buffer.isBuffer(e)) + throw new TypeError("argument should be a Buffer"); + if ( + (r || (r = 0), + a || 0 === a || (a = this.length), + t >= e.length && (t = e.length), + t || (t = 0), + a > 0 && a < r && (a = r), + a === r) + ) + return 0; + if (0 === e.length || 0 === this.length) return 0; + if (t < 0) throw new RangeError("targetStart out of bounds"); + if (r < 0 || r >= this.length) + throw new RangeError("Index out of range"); + if (a < 0) throw new RangeError("sourceEnd out of bounds"); + a > this.length && (a = this.length), + e.length - t < a - r && (a = e.length - t + r); + var n = a - r; + if ( + this === e && + "function" == typeof Uint8Array.prototype.copyWithin + ) + this.copyWithin(t, r, a); + else if (this === e && r < t && t < a) + for (var o = n - 1; o >= 0; --o) e[o + t] = this[o + r]; + else Uint8Array.prototype.set.call(e, this.subarray(r, a), t); + return n; + }), + (Buffer.prototype.fill = function fill(e, t, r, a) { + if ("string" == typeof e) { + if ( + ("string" == typeof t + ? ((a = t), (t = 0), (r = this.length)) + : "string" == typeof r && ((a = r), (r = this.length)), + void 0 !== a && "string" != typeof a) + ) + throw new TypeError("encoding must be a string"); + if ("string" == typeof a && !Buffer.isEncoding(a)) + throw new TypeError("Unknown encoding: " + a); + if (1 === e.length) { + var n = e.charCodeAt(0); + (("utf8" === a && n < 128) || "latin1" === a) && (e = n); + } + } else + "number" == typeof e + ? (e &= 255) + : "boolean" == typeof e && (e = Number(e)); + if (t < 0 || this.length < t || this.length < r) + throw new RangeError("Out of range index"); + if (r <= t) return this; + var o; + if ( + ((t >>>= 0), + (r = void 0 === r ? this.length : r >>> 0), + e || (e = 0), + "number" == typeof e) + ) + for (o = t; o < r; ++o) this[o] = e; + else { + var c = Buffer.isBuffer(e) ? e : Buffer.from(e, a), + d = c.length; + if (0 === d) + throw new TypeError( + 'The value "' + e + '" is invalid for argument "value"' + ); + for (o = 0; o < r - t; ++o) this[o + t] = c[o % d]; + } + return this; + }); + var s = /[^+/0-9A-Za-z-_]/g; + function utf8ToBytes(e, t) { + var r; + t = t || 1 / 0; + for (var a = e.length, n = null, o = [], c = 0; c < a; ++c) { + if ((r = e.charCodeAt(c)) > 55295 && r < 57344) { + if (!n) { + if (r > 56319) { + (t -= 3) > -1 && o.push(239, 191, 189); + continue; + } + if (c + 1 === a) { + (t -= 3) > -1 && o.push(239, 191, 189); + continue; + } + n = r; + continue; + } + if (r < 56320) { + (t -= 3) > -1 && o.push(239, 191, 189), (n = r); + continue; + } + r = 65536 + (((n - 55296) << 10) | (r - 56320)); + } else n && (t -= 3) > -1 && o.push(239, 191, 189); + if (((n = null), r < 128)) { + if ((t -= 1) < 0) break; + o.push(r); + } else if (r < 2048) { + if ((t -= 2) < 0) break; + o.push((r >> 6) | 192, (63 & r) | 128); + } else if (r < 65536) { + if ((t -= 3) < 0) break; + o.push((r >> 12) | 224, ((r >> 6) & 63) | 128, (63 & r) | 128); + } else { + if (!(r < 1114112)) throw new Error("Invalid code point"); + if ((t -= 4) < 0) break; + o.push( + (r >> 18) | 240, + ((r >> 12) & 63) | 128, + ((r >> 6) & 63) | 128, + (63 & r) | 128 + ); + } + } + return o; + } + function base64ToBytes(e) { + return a.toByteArray( + (function base64clean(e) { + if ( + (e = (e = e.split("=")[0]).trim().replace(s, "")).length < 2 + ) + return ""; + for (; e.length % 4 != 0; ) e += "="; + return e; + })(e) + ); + } + function blitBuffer(e, t, r, a) { + for (var n = 0; n < a && !(n + r >= t.length || n >= e.length); ++n) + t[n + r] = e[n]; + return n; + } + function isInstance(e, t) { + return ( + e instanceof t || + (null != e && + null != e.constructor && + null != e.constructor.name && + e.constructor.name === t.name) + ); + } + function numberIsNaN(e) { + return e != e; + } + var u = (function () { + for ( + var e = "0123456789abcdef", t = new Array(256), r = 0; + r < 16; + ++r + ) + for (var a = 16 * r, n = 0; n < 16; ++n) t[a + n] = e[r] + e[n]; + return t; + })(); + }, + 2910: (e, t, r) => { + var a = r(62659).Buffer, + n = r(42830).Transform, + o = r(66866).s; + function CipherBase(e) { + n.call(this), + (this.hashMode = "string" == typeof e), + this.hashMode + ? (this[e] = this._finalOrDigest) + : (this.final = this._finalOrDigest), + this._final && + ((this.__final = this._final), (this._final = null)), + (this._decoder = null), + (this._encoding = null); + } + r(29496)(CipherBase, n), + (CipherBase.prototype.update = function (e, t, r) { + "string" == typeof e && (e = a.from(e, t)); + var n = this._update(e); + return this.hashMode + ? this + : (r && (n = this._toString(n, r)), n); + }), + (CipherBase.prototype.setAutoPadding = function () {}), + (CipherBase.prototype.getAuthTag = function () { + throw new Error("trying to get auth tag in unsupported state"); + }), + (CipherBase.prototype.setAuthTag = function () { + throw new Error("trying to set auth tag in unsupported state"); + }), + (CipherBase.prototype.setAAD = function () { + throw new Error("trying to set aad in unsupported state"); + }), + (CipherBase.prototype._transform = function (e, t, r) { + var a; + try { + this.hashMode ? this._update(e) : this.push(this._update(e)); + } catch (e) { + a = e; + } finally { + r(a); + } + }), + (CipherBase.prototype._flush = function (e) { + var t; + try { + this.push(this.__final()); + } catch (e) { + t = e; + } + e(t); + }), + (CipherBase.prototype._finalOrDigest = function (e) { + var t = this.__final() || a.alloc(0); + return e && (t = this._toString(t, e, !0)), t; + }), + (CipherBase.prototype._toString = function (e, t, r) { + if ( + (this._decoder || + ((this._decoder = new o(t)), (this._encoding = t)), + this._encoding !== t) + ) + throw new Error("can't switch encodings"); + var a = this._decoder.write(e); + return r && (a += this._decoder.end()), a; + }), + (e.exports = CipherBase); + }, + 53750: (e, t, r) => { + r(83735), r(12599), r(39802), r(45128); + var a = r(59569); + e.exports = a.Set; + }, + 67440: e => { + e.exports = function (e) { + if ("function" != typeof e) + throw TypeError(String(e) + " is not a function"); + return e; + }; + }, + 50613: (e, t, r) => { + var a = r(10382); + e.exports = function (e) { + if (!a(e) && null !== e) + throw TypeError("Can't set " + String(e) + " as a prototype"); + return e; + }; + }, + 39281: e => { + e.exports = function () {}; + }, + 7549: e => { + e.exports = function (e, t, r) { + if (!(e instanceof t)) + throw TypeError("Incorrect " + (r ? r + " " : "") + "invocation"); + return e; + }; + }, + 82518: (e, t, r) => { + var a = r(10382); + e.exports = function (e) { + if (!a(e)) throw TypeError(String(e) + " is not an object"); + return e; + }; + }, + 52801: (e, t, r) => { + var a = r(39061), + n = r(985), + o = r(75801), + createMethod = function (e) { + return function (t, r, c) { + var d, + s = a(t), + u = n(s.length), + b = o(c, u); + if (e && r != r) { + for (; u > b; ) if ((d = s[b++]) != d) return !0; + } else + for (; u > b; b++) + if ((e || b in s) && s[b] === r) return e || b || 0; + return !e && -1; + }; + }; + e.exports = { includes: createMethod(!0), indexOf: createMethod(!1) }; + }, + 88698: (e, t, r) => { + var a = r(8320), + n = r(93077), + o = r(95961), + c = r(985), + d = r(60985), + s = [].push, + createMethod = function (e) { + var t = 1 == e, + r = 2 == e, + u = 3 == e, + b = 4 == e, + l = 6 == e, + h = 5 == e || l; + return function (p, x, m, y) { + for ( + var g, + v, + w = o(p), + _ = n(w), + k = a(x, m, 3), + B = c(_.length), + N = 0, + P = y || d, + O = t ? P(p, B) : r ? P(p, 0) : void 0; + B > N; + N++ + ) + if ((h || N in _) && ((v = k((g = _[N]), N, w)), e)) + if (t) O[N] = v; + else if (v) + switch (e) { + case 3: + return !0; + case 5: + return g; + case 6: + return N; + case 2: + s.call(O, g); + } + else if (b) return !1; + return l ? -1 : u || b ? b : O; + }; + }; + e.exports = { + forEach: createMethod(0), + map: createMethod(1), + filter: createMethod(2), + some: createMethod(3), + every: createMethod(4), + find: createMethod(5), + findIndex: createMethod(6) + }; + }, + 60985: (e, t, r) => { + var a = r(10382), + n = r(51661), + o = r(99427)("species"); + e.exports = function (e, t) { + var r; + return ( + n(e) && + ("function" != typeof (r = e.constructor) || + (r !== Array && !n(r.prototype)) + ? a(r) && null === (r = r[o]) && (r = void 0) + : (r = void 0)), + new (void 0 === r ? Array : r)(0 === t ? 0 : t) + ); + }; + }, + 54896: (e, t, r) => { + var a = r(82518); + e.exports = function (e, t, r, n) { + try { + return n ? t(a(r)[0], r[1]) : t(r); + } catch (t) { + var o = e.return; + throw (void 0 !== o && a(o.call(e)), t); + } + }; + }, + 31808: e => { + var t = {}.toString; + e.exports = function (e) { + return t.call(e).slice(8, -1); + }; + }, + 27018: (e, t, r) => { + var a = r(95249), + n = r(31808), + o = r(99427)("toStringTag"), + c = + "Arguments" == + n( + (function () { + return arguments; + })() + ); + e.exports = a + ? n + : function (e) { + var t, r, a; + return void 0 === e + ? "Undefined" + : null === e + ? "Null" + : "string" == + typeof (r = (function (e, t) { + try { + return e[t]; + } catch (e) {} + })((t = Object(e)), o)) + ? r + : c + ? n(t) + : "Object" == (a = n(t)) && "function" == typeof t.callee + ? "Arguments" + : a; + }; + }, + 60616: (e, t, r) => { + "use strict"; + var a = r(40204).f, + n = r(44272), + o = r(16649), + c = r(8320), + d = r(7549), + s = r(67489), + u = r(88149), + b = r(50785), + l = r(9324), + h = r(8481).fastKey, + p = r(898), + x = p.set, + m = p.getterFor; + e.exports = { + getConstructor: function (e, t, r, u) { + var b = e(function (e, a) { + d(e, b, t), + x(e, { + type: t, + index: n(null), + first: void 0, + last: void 0, + size: 0 + }), + l || (e.size = 0), + null != a && s(a, e[u], e, r); + }), + p = m(t), + define = function (e, t, r) { + var a, + n, + o = p(e), + c = getEntry(e, t); + return ( + c + ? (c.value = r) + : ((o.last = c = { + index: (n = h(t, !0)), + key: t, + value: r, + previous: (a = o.last), + next: void 0, + removed: !1 + }), + o.first || (o.first = c), + a && (a.next = c), + l ? o.size++ : e.size++, + "F" !== n && (o.index[n] = c)), + e + ); + }, + getEntry = function (e, t) { + var r, + a = p(e), + n = h(t); + if ("F" !== n) return a.index[n]; + for (r = a.first; r; r = r.next) if (r.key == t) return r; + }; + return ( + o(b.prototype, { + clear: function clear() { + for (var e = p(this), t = e.index, r = e.first; r; ) + (r.removed = !0), + r.previous && (r.previous = r.previous.next = void 0), + delete t[r.index], + (r = r.next); + (e.first = e.last = void 0), + l ? (e.size = 0) : (this.size = 0); + }, + delete: function (e) { + var t = this, + r = p(t), + a = getEntry(t, e); + if (a) { + var n = a.next, + o = a.previous; + delete r.index[a.index], + (a.removed = !0), + o && (o.next = n), + n && (n.previous = o), + r.first == a && (r.first = n), + r.last == a && (r.last = o), + l ? r.size-- : t.size--; + } + return !!a; + }, + forEach: function forEach(e) { + for ( + var t, + r = p(this), + a = c( + e, + arguments.length > 1 ? arguments[1] : void 0, + 3 + ); + (t = t ? t.next : r.first); + + ) + for (a(t.value, t.key, this); t && t.removed; ) + t = t.previous; + }, + has: function has(e) { + return !!getEntry(this, e); + } + }), + o( + b.prototype, + r + ? { + get: function get(e) { + var t = getEntry(this, e); + return t && t.value; + }, + set: function set(e, t) { + return define(this, 0 === e ? 0 : e, t); + } + } + : { + add: function add(e) { + return define(this, (e = 0 === e ? 0 : e), e); + } + } + ), + l && + a(b.prototype, "size", { + get: function () { + return p(this).size; + } + }), + b + ); + }, + setStrong: function (e, t, r) { + var a = t + " Iterator", + n = m(t), + o = m(a); + u( + e, + t, + function (e, t) { + x(this, { + type: a, + target: e, + state: n(e), + kind: t, + last: void 0 + }); + }, + function () { + for ( + var e = o(this), t = e.kind, r = e.last; + r && r.removed; + + ) + r = r.previous; + return e.target && (e.last = r = r ? r.next : e.state.first) + ? "keys" == t + ? { value: r.key, done: !1 } + : "values" == t + ? { value: r.value, done: !1 } + : { value: [r.key, r.value], done: !1 } + : ((e.target = void 0), { value: void 0, done: !0 }); + }, + r ? "entries" : "values", + !r, + !0 + ), + b(t); + } + }; + }, + 81607: (e, t, r) => { + "use strict"; + var a = r(76346), + n = r(39522), + o = r(8481), + c = r(63709), + d = r(98459), + s = r(67489), + u = r(7549), + b = r(10382), + l = r(81850), + h = r(40204).f, + p = r(88698).forEach, + x = r(9324), + m = r(898), + y = m.set, + g = m.getterFor; + e.exports = function (e, t, r) { + var m, + v = -1 !== e.indexOf("Map"), + w = -1 !== e.indexOf("Weak"), + _ = v ? "set" : "add", + k = n[e], + B = k && k.prototype, + N = {}; + if ( + x && + "function" == typeof k && + (w || + (B.forEach && + !c(function () { + new k().entries().next(); + }))) + ) { + m = t(function (t, r) { + y(u(t, m, e), { type: e, collection: new k() }), + null != r && s(r, t[_], t, v); + }); + var P = g(e); + p( + [ + "add", + "clear", + "delete", + "forEach", + "get", + "has", + "set", + "keys", + "values", + "entries" + ], + function (e) { + var t = "add" == e || "set" == e; + !(e in B) || + (w && "clear" == e) || + d(m.prototype, e, function (r, a) { + var n = P(this).collection; + if (!t && w && !b(r)) return "get" == e && void 0; + var o = n[e](0 === r ? 0 : r, a); + return t ? this : o; + }); + } + ), + w || + h(m.prototype, "size", { + configurable: !0, + get: function () { + return P(this).collection.size; + } + }); + } else (m = r.getConstructor(t, e, v, _)), (o.REQUIRED = !0); + return ( + l(m, e, !1, !0), + (N[e] = m), + a({ global: !0, forced: !0 }, N), + w || r.setStrong(m, e, v), + m + ); + }; + }, + 60515: (e, t, r) => { + var a = r(63709); + e.exports = !a(function () { + function F() {} + return ( + (F.prototype.constructor = null), + Object.getPrototypeOf(new F()) !== F.prototype + ); + }); + }, + 90724: (e, t, r) => { + "use strict"; + var a = r(43736).IteratorPrototype, + n = r(44272), + o = r(70307), + c = r(81850), + d = r(60527), + returnThis = function () { + return this; + }; + e.exports = function (e, t, r) { + var s = t + " Iterator"; + return ( + (e.prototype = n(a, { next: o(1, r) })), + c(e, s, !1, !0), + (d[s] = returnThis), + e + ); + }; + }, + 98459: (e, t, r) => { + var a = r(9324), + n = r(40204), + o = r(70307); + e.exports = a + ? function (e, t, r) { + return n.f(e, t, o(1, r)); + } + : function (e, t, r) { + return (e[t] = r), e; + }; + }, + 70307: e => { + e.exports = function (e, t) { + return { + enumerable: !(1 & e), + configurable: !(2 & e), + writable: !(4 & e), + value: t + }; + }; + }, + 88149: (e, t, r) => { + "use strict"; + var a = r(76346), + n = r(90724), + o = r(81482), + c = r(78907), + d = r(81850), + s = r(98459), + u = r(96825), + b = r(99427), + l = r(85672), + h = r(60527), + p = r(43736), + x = p.IteratorPrototype, + m = p.BUGGY_SAFARI_ITERATORS, + y = b("iterator"), + g = "keys", + v = "values", + w = "entries", + returnThis = function () { + return this; + }; + e.exports = function (e, t, r, b, p, _, k) { + n(r, t, b); + var B, + N, + P, + getIterationMethod = function (e) { + if (e === p && D) return D; + if (!m && e in L) return L[e]; + switch (e) { + case g: + return function keys() { + return new r(this, e); + }; + case v: + return function values() { + return new r(this, e); + }; + case w: + return function entries() { + return new r(this, e); + }; + } + return function () { + return new r(this); + }; + }, + O = t + " Iterator", + I = !1, + L = e.prototype, + C = L[y] || L["@@iterator"] || (p && L[p]), + D = (!m && C) || getIterationMethod(p), + j = ("Array" == t && L.entries) || C; + if ( + (j && + ((B = o(j.call(new e()))), + x !== Object.prototype && + B.next && + (l || + o(B) === x || + (c + ? c(B, x) + : "function" != typeof B[y] && s(B, y, returnThis)), + d(B, O, !0, !0), + l && (h[O] = returnThis))), + p == v && + C && + C.name !== v && + ((I = !0), + (D = function values() { + return C.call(this); + })), + (l && !k) || L[y] === D || s(L, y, D), + (h[t] = D), + p) + ) + if ( + ((N = { + values: getIterationMethod(v), + keys: _ ? D : getIterationMethod(g), + entries: getIterationMethod(w) + }), + k) + ) + for (P in N) (m || I || !(P in L)) && u(L, P, N[P]); + else a({ target: t, proto: !0, forced: m || I }, N); + return N; + }; + }, + 9324: (e, t, r) => { + var a = r(63709); + e.exports = !a(function () { + return ( + 7 != + Object.defineProperty({}, 1, { + get: function () { + return 7; + } + })[1] + ); + }); + }, + 58833: (e, t, r) => { + var a = r(39522), + n = r(10382), + o = a.document, + c = n(o) && n(o.createElement); + e.exports = function (e) { + return c ? o.createElement(e) : {}; + }; + }, + 96469: e => { + e.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 + }; + }, + 86588: e => { + e.exports = [ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf" + ]; + }, + 76346: (e, t, r) => { + "use strict"; + var a = r(39522), + n = r(11613).f, + o = r(80434), + c = r(59569), + d = r(8320), + s = r(98459), + u = r(73698), + wrapConstructor = function (e) { + var Wrapper = function (t, r, a) { + if (this instanceof e) { + switch (arguments.length) { + case 0: + return new e(); + case 1: + return new e(t); + case 2: + return new e(t, r); + } + return new e(t, r, a); + } + return e.apply(this, arguments); + }; + return (Wrapper.prototype = e.prototype), Wrapper; + }; + e.exports = function (e, t) { + var r, + b, + l, + h, + p, + x, + m, + y, + g = e.target, + v = e.global, + w = e.stat, + _ = e.proto, + k = v ? a : w ? a[g] : (a[g] || {}).prototype, + B = v ? c : c[g] || (c[g] = {}), + N = B.prototype; + for (l in t) + (r = + !o(v ? l : g + (w ? "." : "#") + l, e.forced) && k && u(k, l)), + (p = B[l]), + r && (x = e.noTargetGet ? (y = n(k, l)) && y.value : k[l]), + (h = r && x ? x : t[l]), + (r && typeof p == typeof h) || + ((m = + e.bind && r + ? d(h, a) + : e.wrap && r + ? wrapConstructor(h) + : _ && "function" == typeof h + ? d(Function.call, h) + : h), + (e.sham || (h && h.sham) || (p && p.sham)) && + s(m, "sham", !0), + (B[l] = m), + _ && + (u(c, (b = g + "Prototype")) || s(c, b, {}), + (c[b][l] = h), + e.real && N && !N[l] && s(N, l, h))); + }; + }, + 63709: e => { + e.exports = function (e) { + try { + return !!e(); + } catch (e) { + return !0; + } + }; + }, + 68028: (e, t, r) => { + var a = r(63709); + e.exports = !a(function () { + return Object.isExtensible(Object.preventExtensions({})); + }); + }, + 8320: (e, t, r) => { + var a = r(67440); + e.exports = function (e, t, r) { + if ((a(e), void 0 === t)) return e; + switch (r) { + case 0: + return function () { + return e.call(t); + }; + case 1: + return function (r) { + return e.call(t, r); + }; + case 2: + return function (r, a) { + return e.call(t, r, a); + }; + case 3: + return function (r, a, n) { + return e.call(t, r, a, n); + }; + } + return function () { + return e.apply(t, arguments); + }; + }; + }, + 49976: (e, t, r) => { + var a = r(59569), + n = r(39522), + aFunction = function (e) { + return "function" == typeof e ? e : void 0; + }; + e.exports = function (e, t) { + return arguments.length < 2 + ? aFunction(a[e]) || aFunction(n[e]) + : (a[e] && a[e][t]) || (n[e] && n[e][t]); + }; + }, + 31479: (e, t, r) => { + var a = r(27018), + n = r(60527), + o = r(99427)("iterator"); + e.exports = function (e) { + if (null != e) return e[o] || e["@@iterator"] || n[a(e)]; + }; + }, + 39522: (e, t, r) => { + var check = function (e) { + return e && e.Math == Math && e; + }; + e.exports = + check("object" == typeof globalThis && globalThis) || + check("object" == typeof window && window) || + check("object" == typeof self && self) || + check("object" == typeof r.g && r.g) || + Function("return this")(); + }, + 73698: e => { + var t = {}.hasOwnProperty; + e.exports = function (e, r) { + return t.call(e, r); + }; + }, + 4891: e => { + e.exports = {}; + }, + 227: (e, t, r) => { + var a = r(49976); + e.exports = a("document", "documentElement"); + }, + 19135: (e, t, r) => { + var a = r(9324), + n = r(63709), + o = r(58833); + e.exports = + !a && + !n(function () { + return ( + 7 != + Object.defineProperty(o("div"), "a", { + get: function () { + return 7; + } + }).a + ); + }); + }, + 93077: (e, t, r) => { + var a = r(63709), + n = r(31808), + o = "".split; + e.exports = a(function () { + return !Object("z").propertyIsEnumerable(0); + }) + ? function (e) { + return "String" == n(e) ? o.call(e, "") : Object(e); + } + : Object; + }, + 64164: (e, t, r) => { + var a = r(63256), + n = Function.toString; + "function" != typeof a.inspectSource && + (a.inspectSource = function (e) { + return n.call(e); + }), + (e.exports = a.inspectSource); + }, + 8481: (e, t, r) => { + var a = r(4891), + n = r(10382), + o = r(73698), + c = r(40204).f, + d = r(47766), + s = r(68028), + u = d("meta"), + b = 0, + l = + Object.isExtensible || + function () { + return !0; + }, + setMetadata = function (e) { + c(e, u, { value: { objectID: "O" + ++b, weakData: {} } }); + }, + h = (e.exports = { + REQUIRED: !1, + fastKey: function (e, t) { + if (!n(e)) + return "symbol" == typeof e + ? e + : ("string" == typeof e ? "S" : "P") + e; + if (!o(e, u)) { + if (!l(e)) return "F"; + if (!t) return "E"; + setMetadata(e); + } + return e[u].objectID; + }, + getWeakData: function (e, t) { + if (!o(e, u)) { + if (!l(e)) return !0; + if (!t) return !1; + setMetadata(e); + } + return e[u].weakData; + }, + onFreeze: function (e) { + return s && h.REQUIRED && l(e) && !o(e, u) && setMetadata(e), e; + } + }); + a[u] = !0; + }, + 898: (e, t, r) => { + var a, + n, + o, + c = r(73575), + d = r(39522), + s = r(10382), + u = r(98459), + b = r(73698), + l = r(3768), + h = r(4891), + p = d.WeakMap; + if (c) { + var x = new p(), + m = x.get, + y = x.has, + g = x.set; + (a = function (e, t) { + return g.call(x, e, t), t; + }), + (n = function (e) { + return m.call(x, e) || {}; + }), + (o = function (e) { + return y.call(x, e); + }); + } else { + var v = l("state"); + (h[v] = !0), + (a = function (e, t) { + return u(e, v, t), t; + }), + (n = function (e) { + return b(e, v) ? e[v] : {}; + }), + (o = function (e) { + return b(e, v); + }); + } + e.exports = { + set: a, + get: n, + has: o, + enforce: function (e) { + return o(e) ? n(e) : a(e, {}); + }, + getterFor: function (e) { + return function (t) { + var r; + if (!s(t) || (r = n(t)).type !== e) + throw TypeError("Incompatible receiver, " + e + " required"); + return r; + }; + } + }; + }, + 45404: (e, t, r) => { + var a = r(99427), + n = r(60527), + o = a("iterator"), + c = Array.prototype; + e.exports = function (e) { + return void 0 !== e && (n.Array === e || c[o] === e); + }; + }, + 51661: (e, t, r) => { + var a = r(31808); + e.exports = + Array.isArray || + function isArray(e) { + return "Array" == a(e); + }; + }, + 80434: (e, t, r) => { + var a = r(63709), + n = /#|\.prototype\./, + isForced = function (e, t) { + var r = c[o(e)]; + return ( + r == s || (r != d && ("function" == typeof t ? a(t) : !!t)) + ); + }, + o = (isForced.normalize = function (e) { + return String(e).replace(n, ".").toLowerCase(); + }), + c = (isForced.data = {}), + d = (isForced.NATIVE = "N"), + s = (isForced.POLYFILL = "P"); + e.exports = isForced; + }, + 10382: e => { + e.exports = function (e) { + return "object" == typeof e ? null !== e : "function" == typeof e; + }; + }, + 85672: e => { + e.exports = !0; + }, + 67489: (e, t, r) => { + var a = r(82518), + n = r(45404), + o = r(985), + c = r(8320), + d = r(31479), + s = r(54896), + Result = function (e, t) { + (this.stopped = e), (this.result = t); + }; + (e.exports = function (e, t, r, u, b) { + var l, + h, + p, + x, + m, + y, + g, + v = c(t, r, u ? 2 : 1); + if (b) l = e; + else { + if ("function" != typeof (h = d(e))) + throw TypeError("Target is not iterable"); + if (n(h)) { + for (p = 0, x = o(e.length); x > p; p++) + if ( + (m = u ? v(a((g = e[p]))[0], g[1]) : v(e[p])) && + m instanceof Result + ) + return m; + return new Result(!1); + } + l = h.call(e); + } + for (y = l.next; !(g = y.call(l)).done; ) + if ( + "object" == typeof (m = s(l, v, g.value, u)) && + m && + m instanceof Result + ) + return m; + return new Result(!1); + }).stop = function (e) { + return new Result(!0, e); + }; + }, + 43736: (e, t, r) => { + "use strict"; + var a, + n, + o, + c = r(81482), + d = r(98459), + s = r(73698), + u = r(99427), + b = r(85672), + l = u("iterator"), + h = !1; + [].keys && + ("next" in (o = [].keys()) + ? (n = c(c(o))) !== Object.prototype && (a = n) + : (h = !0)), + null == a && (a = {}), + b || + s(a, l) || + d(a, l, function () { + return this; + }), + (e.exports = { IteratorPrototype: a, BUGGY_SAFARI_ITERATORS: h }); + }, + 60527: e => { + e.exports = {}; + }, + 49114: (e, t, r) => { + var a = r(63709); + e.exports = + !!Object.getOwnPropertySymbols && + !a(function () { + return !String(Symbol()); + }); + }, + 73575: (e, t, r) => { + var a = r(39522), + n = r(64164), + o = a.WeakMap; + e.exports = "function" == typeof o && /native code/.test(n(o)); + }, + 44272: (e, t, r) => { + var a, + n = r(82518), + o = r(76725), + c = r(86588), + d = r(4891), + s = r(227), + u = r(58833), + b = r(3768), + l = b("IE_PROTO"), + EmptyConstructor = function () {}, + scriptTag = function (e) { + return "
@@ -900,7 +899,7 @@

constructor

  • Defined in chains/ethereum/src/api.ts:157
    • @@ -976,7 +975,7 @@

  • Defined in chains/ethereum/src/api.ts:155
    • @@ -1000,7 +999,7 @@

  • Defined in chains/ethereum/src/api.ts:152
    • @@ -1032,7 +1031,7 @@

  • Defined in chains/ethereum/src/api.ts:153
    • @@ -1060,7 +1059,7 @@

  • Defined in chains/ethereum/src/api.ts:151
    • @@ -1084,7 +1083,7 @@

  • Defined in chains/ethereum/src/api.ts:156
    • @@ -1117,7 +1116,7 @@

  • Defined in chains/ethereum/src/api.ts:154
    • @@ -1141,7 +1140,7 @@

  • Defined in chains/ethereum/src/api.ts:157
    • @@ -1175,7 +1174,7 @@

    bzz_hive

  • Defined in chains/ethereum/src/api.ts:249
    • @@ -1215,7 +1214,7 @@

    bzz_info

  • Defined in chains/ethereum/src/api.ts:254
    • @@ -1260,7 +1259,7 @@

    db_getHex

  • Defined in chains/ethereum/src/api.ts:242
    • @@ -1329,7 +1328,7 @@

    db_getString

  • Defined in chains/ethereum/src/api.ts:217
    • @@ -1401,7 +1400,7 @@

    db_putHex

  • Defined in chains/ethereum/src/api.ts:230
    • @@ -1481,7 +1480,7 @@

    db_putString

  • Defined in chains/ethereum/src/api.ts:205
    • @@ -1560,7 +1559,7 @@

    debug_traceTransaction

  • Defined in chains/ethereum/src/api.ts:1811
    • @@ -1651,7 +1650,7 @@

    eth_accounts

  • Defined in chains/ethereum/src/api.ts:979
    • @@ -1698,7 +1697,7 @@

    eth_blockNumber

  • Defined in chains/ethereum/src/api.ts:988
    • @@ -1751,7 +1750,7 @@

    eth_call

  • Defined in chains/ethereum/src/api.ts:1732
    • @@ -1822,7 +1821,7 @@

    eth_chainId

  • Defined in chains/ethereum/src/api.ts:1004
    • @@ -1847,7 +1846,7 @@

    eth_chainId

    example
    -
    + 
    await provider.send("eth_chainId");
    @@ -1885,7 +1884,7 @@

    eth_coinbase

  • Defined in chains/ethereum/src/api.ts:761
    • @@ -1940,7 +1939,7 @@

    eth_estimateGas

  • Defined in chains/ethereum/src/api.ts:681
    • @@ -2015,7 +2014,7 @@

    eth_gasPrice

  • Defined in chains/ethereum/src/api.ts:970
    • @@ -2066,7 +2065,7 @@

    eth_getBalance

  • Defined in chains/ethereum/src/api.ts:1015
    • @@ -2149,7 +2148,7 @@

    eth_getBlockByHash

  • Defined in chains/ethereum/src/api.ts:788
    • @@ -2227,7 +2226,7 @@

    eth_getBlockByNumber

  • Defined in chains/ethereum/src/api.ts:774
    • @@ -2319,7 +2318,7 @@

  • Defined in chains/ethereum/src/api.ts:816
    • @@ -2389,7 +2388,7 @@

  • Defined in chains/ethereum/src/api.ts:801
    • @@ -2460,7 +2459,7 @@

    eth_getCode

  • Defined in chains/ethereum/src/api.ts:1034
    • @@ -2537,7 +2536,7 @@

    eth_getCompilers

  • Defined in chains/ethereum/src/api.ts:826
    • @@ -2581,7 +2580,7 @@

    eth_getFilterChanges

  • Defined in chains/ethereum/src/api.ts:1607
    • @@ -2650,7 +2649,7 @@

    eth_getFilterLogs

  • Defined in chains/ethereum/src/api.ts:1640
    • @@ -2710,7 +2709,7 @@

    eth_getLogs

  • Defined in chains/ethereum/src/api.ts:1656
    • @@ -2785,7 +2784,7 @@

    eth_getStorageAt

  • Defined in chains/ethereum/src/api.ts:1088
    • @@ -2881,7 +2880,7 @@

  • Defined in chains/ethereum/src/api.ts:836
    • @@ -2964,7 +2963,7 @@

  • Defined in chains/ethereum/src/api.ts:855
    • @@ -3042,7 +3041,7 @@

    eth_getTransactionByHash

  • Defined in chains/ethereum/src/api.ts:1151
    • @@ -3108,7 +3107,7 @@

    eth_getTransactionCount

  • Defined in chains/ethereum/src/api.ts:1713
    • @@ -3188,7 +3187,7 @@

    eth_getTransactionReceipt

  • Defined in chains/ethereum/src/api.ts:1178
    • @@ -3262,7 +3261,7 @@

  • Defined in chains/ethereum/src/api.ts:888
    • @@ -3341,7 +3340,7 @@

  • Defined in chains/ethereum/src/api.ts:900
    • @@ -3422,7 +3421,7 @@

  • Defined in chains/ethereum/src/api.ts:868
    • @@ -3489,7 +3488,7 @@

  • Defined in chains/ethereum/src/api.ts:877
    • @@ -3556,7 +3555,7 @@

    eth_getWork

  • Defined in chains/ethereum/src/api.ts:917
    • @@ -3629,7 +3628,7 @@

    eth_hashrate

  • Defined in chains/ethereum/src/api.ts:961
    • @@ -3676,7 +3675,7 @@

    eth_mining

  • Defined in chains/ethereum/src/api.ts:951
    • @@ -3728,7 +3727,7 @@

    eth_newBlockFilter

  • Defined in chains/ethereum/src/api.ts:1512
    • @@ -3779,7 +3778,7 @@

    eth_newFilter

  • Defined in chains/ethereum/src/api.ts:1577
    • @@ -3888,7 +3887,7 @@

  • Defined in chains/ethereum/src/api.ts:1534
    • @@ -3938,7 +3937,7 @@

    eth_protocolVersion

  • Defined in chains/ethereum/src/api.ts:739
    • @@ -3986,7 +3985,7 @@

    eth_sendRawTransaction

  • Defined in chains/ethereum/src/api.ts:1279
    • @@ -4046,7 +4045,7 @@

    eth_sendTransaction

  • Defined in chains/ethereum/src/api.ts:1205
    • @@ -4110,7 +4109,7 @@

    eth_sign

  • Defined in chains/ethereum/src/api.ts:1303
    • @@ -4197,7 +4196,7 @@

    eth_signTypedData

  • Defined in chains/ethereum/src/api.ts:1330
    • @@ -4300,7 +4299,7 @@

    eth_submitHashrate

  • Defined in chains/ethereum/src/api.ts:942
    • @@ -4381,7 +4380,7 @@

    eth_submitWork

  • Defined in chains/ethereum/src/api.ts:930
    • @@ -4470,7 +4469,7 @@

    eth_subscribe

  • Defined in chains/ethereum/src/api.ts:1369
    • @@ -4509,7 +4508,7 @@

  • Defined in chains/ethereum/src/api.ts:1382
    • @@ -4587,7 +4586,7 @@

    eth_syncing

  • Defined in chains/ethereum/src/api.ts:752
    • @@ -4645,7 +4644,7 @@

    eth_uninstallFilter

  • Defined in chains/ethereum/src/api.ts:1627
    • @@ -4709,7 +4708,7 @@

    eth_unsubscribe

  • Defined in chains/ethereum/src/api.ts:1493
    • @@ -4762,7 +4761,7 @@

    evm_increaseTime

  • Defined in chains/ethereum/src/api.ts:389
    • @@ -4826,7 +4825,7 @@

    evm_lockUnknownAccount

  • Defined in chains/ethereum/src/api.ts:539
    • @@ -4893,7 +4892,7 @@

    evm_mine

  • Defined in chains/ethereum/src/api.ts:269
    • @@ -4960,7 +4959,7 @@

    evm_revert

  • Defined in chains/ethereum/src/api.ts:467
    • @@ -4980,12 +4979,12 @@

    evm_revert

    example
    -
    + 
    const snapshotId = await provider.send("evm_snapshot");
 const isReverted = await provider.send("evm_revert", [snapshotId]);
    example
    -
    + 
    const provider = ganache.provider();
 const [from, to] = await provider.send("eth_accounts");
 const startingBalance = BigInt(await provider.send("eth_getBalance", [from]));
@@ -5068,7 +5067,7 @@ 
    evm_setAccountNonce
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:353
                       
    • 
@@ -5147,7 +5146,7 @@ 
    evm_setStorageAt
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:279
                       
    • 
@@ -5226,7 +5225,7 @@ 
    evm_setTime
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:408
                       
    • 
@@ -5293,7 +5292,7 @@ 
    evm_snapshot
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:511
                       
    • 
@@ -5314,11 +5313,11 @@ 
    evm_snapshot
    example
    -
    + 
    const snapshotId = await provider.send("evm_snapshot");
    example
    -
    + 
    const provider = ganache.provider();
 const [from, to] = await provider.send("eth_accounts");
 const startingBalance = BigInt(await provider.send("eth_getBalance", [from]));
@@ -5384,7 +5383,7 @@ 
    evm_unlockUnknownAccount
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:524
                       
    • 
@@ -5463,7 +5462,7 @@ 
    miner_setEtherbase
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:597
                       
    • 
@@ -5518,7 +5517,7 @@ 
    miner_setExtra
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:607
                       
    • 
@@ -5576,7 +5575,7 @@ 
    miner_setGasPrice
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:587
                       
    • 
@@ -5632,7 +5631,7 @@ 
    miner_start
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:559
                       
    • 
@@ -5692,7 +5691,7 @@ 
    miner_stop
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:575
                       
    • 
@@ -5735,7 +5734,7 @@ 
    net_listening
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:655
                       
    • 
@@ -5786,7 +5785,7 @@ 
    net_peerCount
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:664
                       
    • 
@@ -5833,7 +5832,7 @@ 
    net_version
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:646
                       
    • 
@@ -5886,7 +5885,7 @@ 
    personal_importRawKey
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1867
                       
    • 
@@ -5953,7 +5952,7 @@ 
    personal_listAccounts
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1827
                       
    • 
@@ -6008,7 +6007,7 @@ 
    personal_lockAccount
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1891
                       
    • 
@@ -6067,7 +6066,7 @@ 
    personal_newAccount
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1838
                       
    • 
@@ -6130,7 +6129,7 @@ 
    personal_sendTransaction
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1936
                       
    • 
@@ -6208,7 +6207,7 @@ 
    personal_unlockAccount
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1911
                       
    • 
@@ -6298,7 +6297,7 @@ 
    rpc_modules
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1969
                       
    • 
@@ -6339,7 +6338,7 @@ 
    shh_addToGroup
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2014
                       
    • 
@@ -6399,7 +6398,7 @@ 
    shh_getFilterChanges
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2051
                       
    • 
@@ -6468,7 +6467,7 @@ 
    shh_getMessages
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2062
                       
    • 
@@ -6530,7 +6529,7 @@ 
    shh_hasIdentity
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1993
                       
    • 
@@ -6598,7 +6597,7 @@ 
    shh_newFilter
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2028
                       
    • 
@@ -6676,7 +6675,7 @@ 
    shh_newGroup
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2003
                       
    • 
@@ -6722,7 +6721,7 @@ 
    shh_newIdentity
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:1982
                       
    • 
@@ -6768,7 +6767,7 @@ 
    shh_post
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2073
                       
    • 
@@ -6830,7 +6829,7 @@ 
    shh_uninstallFilter
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2040
                       
    • 
@@ -6893,7 +6892,7 @@ 
    shh_version
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:2083
                       
    • 
@@ -6939,7 +6938,7 @@ 
    web3_clientVersion
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:624
                       
    • 
@@ -6985,7 +6984,7 @@ 
    web3_sha3
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:634
                       
    • 
@@ -7977,5 +7976,12 @@ 
    Legend
    
       if (location.protocol == "file:")
         document.write('
+
+    
+    
   
 
diff --git a/docs/typedoc/modules/_api_.html b/docs/typedoc/modules/_api_.html
index 4bb6df2d1f..c17dabbd2b 100644
--- a/docs/typedoc/modules/_api_.html
+++ b/docs/typedoc/modules/_api_.html
@@ -230,7 +230,7 @@ 
    TypedData
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:67
                   
    • 
@@ -261,7 +261,7 @@ 
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:53
                   
    • 
@@ -291,7 +291,7 @@ 
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:63
                   
    • 
@@ -320,7 +320,7 @@ 
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:54
                   
    • 
@@ -343,7 +343,7 @@ 
    RPCQUANTITY_ZERO
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:52
                   
    • 
@@ -372,7 +372,7 @@ 
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:55
                   
    • 
@@ -434,7 +434,7 @@ 
    keccak
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:48
                   
    • 
@@ -455,7 +455,7 @@ 
    version
    
                   
  • 
                     Defined in
                     chains/ethereum/src/api.ts:47
                   
    • 
@@ -492,7 +492,7 @@ 
    assertExceptionalTransactions
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:74
                       
    • 
@@ -543,7 +543,7 @@ 
    createCommon
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:130
                       
    • 
@@ -608,7 +608,7 @@ 
    parseCoinbaseAddress
    
                       
  • 
                         Defined in
                         chains/ethereum/src/api.ts:106
                       
    • 
diff --git a/package.json b/package.json
index 01d6bb00ae..f74ef24318 100644
--- a/package.json
+++ b/package.json
@@ -7,7 +7,7 @@
     "npm": ">=6.1.0"
   },
   "scripts": {
-    "build": "lerna run build",
+    "build": "lerna run build && shx cp -r ./src/packages/ganache/dist/web ./docs/assets/js/ganache",
     "clean": "npx shx rm -rf node_modules && npx lerna clean -y && npm run tsc.clean",
     "create": "ts-node ./scripts/create",
     "docs.build": "lerna run docs.build",
diff --git a/src/chains/ethereum/package.json b/src/chains/ethereum/package.json
index 472b64b15f..71cf1ffd61 100644
--- a/src/chains/ethereum/package.json
+++ b/src/chains/ethereum/package.json
@@ -27,6 +27,7 @@
     "docs.build": "rm -rf ./lib/docs ./lib/api.json && npm run docs.typedoc && npm run docs.post-process",
     "docs.typedoc": "typedoc --options ./typedoc.json --readme ./README.md --out ../../../docs/typedoc --json ../../../docs/typedoc/api.json src/api.ts",
     "docs.post-process": "node ./scripts/post-process-docs.js",
+    "docs.preview": "ws --open --port 3010 --directory ../../../",
     "tsc": "ttsc",
     "test": "nyc --reporter lcov npm run mocha",
     "mocha": "cross-env TS_NODE_COMPILER=ttypescript TS_NODE_FILES=true mocha --exit --check-leaks --throw-deprecation --trace-warnings --require ts-node/register 'tests/**/*.test.ts'"
diff --git a/src/chains/ethereum/scripts/inject-editor.js b/src/chains/ethereum/scripts/inject-editor.js
new file mode 100644
index 0000000000..5e2fd64f0d
--- /dev/null
+++ b/src/chains/ethereum/scripts/inject-editor.js
@@ -0,0 +1,116 @@
+// remove the typedoc theme's keydown handler so we can type in our monaco-editors
+$("body").off("keydown");
+
+require.config({
+  paths: { vs: "https://unpkg.com/browse/monaco-editor@0.21.2/min/vs/" }
+});
+
+require([
+  "../src/packages/ganache/dist/web/ganache.min.js",
+  "vs/editor/editor.main"
+], function (Ganache) {
+  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+
+  document.querySelectorAll(".monaco").forEach(codeNode => {
+    async function run(e) {
+      e.preventDefault();
+      e.stopPropagation();
+
+      const code = editor.getValue();
+
+      consoleDiv.innerHTML = "";
+
+      const k = {
+        log: (...args) => {
+          // very naive console implementation
+          const line = document.createElement("div");
+          line.className = "mtk1";
+          line.innerText = args.map(a => "" + a).join(" ");
+          consoleDiv.appendChild(line);
+        }
+      };
+      const ganache = {
+        provider: (options = {}) => {
+          delete options.logger;
+          if (!options.logging) {
+            options.logging = {};
+          }
+          options.logging.logger = k;
+          return Ganache.provider(options);
+        }
+      };
+      const codeText = code.trim();
+      const assert = a => {
+        if (a) return true;
+        throw new Error("not equal");
+      };
+      assert.strictEqual = (a, b) => {
+        if (a === b) return true;
+        throw new Error("not strict equal");
+      };
+      const fn = new AsyncFunction(
+        "ganache",
+        "assert",
+        "console",
+        `with ({provider: ganache.provider()}) {
+          try {
+            return await (async () => {
+              "use strict";
+              ${codeText}
+              ;
+            })();
+          } catch (e) {
+            console.log(e);
+          } finally {
+            try {
+              // await provider.disconnect();
+              // delete all tmp ganache-core databases
+              await indexedDB.databases().then(dbs => {
+                return Promise.all(dbs.map(db => {
+                  if (db.name.startsWith("/tmp/ganache-core_")) {
+                    // return indexedDB.deleteDatabase(db.name);
+                  }
+                }));
+              });
+            } catch {}
+          }
+        }`
+      );
+      await fn(ganache, assert, k);
+    }
+
+    const consoleDiv = document.createElement("div");
+    consoleDiv.className = "monaco-editor-background";
+    consoleDiv.style.borderTop = "solid 1px #393939";
+    consoleDiv.style.fontFamily =
+      '"Droid Sans Mono", monospace, monospace, "Droid Sans Fallback"';
+    consoleDiv.style.fontSize = "14px";
+    consoleDiv.style.fontFeatureSettings = '"liga" 0, "calt" 0';
+    consoleDiv.style.lineHeight = "19px";
+    consoleDiv.style.letterSpacing = "0px";
+    consoleDiv.style.height = "200px";
+    consoleDiv.style.position = "relative";
+    consoleDiv.style.overflow = "auto";
+    consoleDiv.style.padding = ".3em 26px";
+    codeNode.parentNode.insertBefore(consoleDiv, codeNode.nextSibling);
+
+    const container = document.createElement("div");
+    codeNode.parentNode.insertBefore(container, codeNode.nextSibling);
+    codeNode.style.display = "none";
+    container.style.height = "600px";
+
+    const editor = monaco.editor.create(container, {
+      value: codeNode.innerText.trim(),
+      language: "javascript", // TODO, get language from element
+      // lineNumbers: "off",
+      minimap: { enabled: false },
+      scrollBeyondLastLine: false,
+      theme: "vs" // use light theme until
+    });
+
+    const runButton = document.createElement("button");
+    runButton.innerText = "Run";
+    runButton.addEventListener("click", run);
+    codeNode.parentNode.insertBefore(runButton, codeNode.nextSibling);
+  });
+});
diff --git a/src/chains/ethereum/scripts/post-process-docs.js b/src/chains/ethereum/scripts/post-process-docs.js
index 33a4c625ea..0554578c57 100644
--- a/src/chains/ethereum/scripts/post-process-docs.js
+++ b/src/chains/ethereum/scripts/post-process-docs.js
@@ -1,23 +1,20 @@
 const cheerio = require("cheerio");
 const { readFileSync, writeFileSync } = require("fs");
-const { randomBytes } = require("crypto");
 const $ = cheerio.load(
   readFileSync("../../../docs/typedoc/classes/_api_.ethereumapi.html")
 );
 
-$(`.tsd-page-title`).after(``);
+$("body").append(
+  ""
+);
+$(`body`).append(``);
 
-$(".runkit-example").each(function () {
-  const sanitizedCode = $(this)
-    .text()
-    .replace(/;(\s+)/gi, ";\n")
-    .trim();
-  $(this).text("");
-  const id = randomBytes(4).toString("hex");
-  $(this).attr("id", id).html();
-  $(this).prepend(
-    ``
-  );
-});
+$("dt")
+  .filter(function () {
+    return $(this).text().trim().toLocaleUpperCase() === "EXAMPLE";
+  })
+  .each(function () {
+    $(this).next().addClass("monaco");
+  });
 
 writeFileSync("../../../docs/typedoc/classes/_api_.ethereumapi.html", $.html());