npm - @stacks/bns - Versions diffs - 7.1.1-beta.0 → 7.1.2-pr.0 - Mend

@stacks/bns 7.1.1-beta.0 → 7.1.2-pr.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/umd/index.js.map +1 -1
package/package.json +5 -5

package/dist/umd/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","mappings":"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","sources":["webpack://StacksBns/webpack/universalModuleDefinition","webpack://StacksBns/webpack/runtime/create fake namespace object","webpack://StacksBns/../../node_modules/@noble/hashes/_assert.js","webpack://StacksBns/../../node_modules/@noble/hashes/_sha2.js","webpack://StacksBns/../../node_modules/@noble/hashes/cryptoBrowser.js","webpack://StacksBns/../../node_modules/@noble/hashes/sha256.js","webpack://StacksBns/../../node_modules/@noble/hashes/utils.js","webpack://StacksBns/../../node_modules/base-x/src/index.js","webpack://StacksBns/../../node_modules/c32check/lib/address.js","webpack://StacksBns/../../node_modules/c32check/lib/base58check.js","webpack://StacksBns/../../node_modules/c32check/lib/checksum.js","webpack://StacksBns/../../node_modules/c32check/lib/encoding.js","webpack://StacksBns/../../node_modules/c32check/lib/index.js","webpack://StacksBns/../../node_modules/lodash.clonedeep/index.js","webpack://StacksBns/webpack/bootstrap","webpack://StacksBns/webpack/runtime/compat get default export","webpack://StacksBns/webpack/runtime/define property getters","webpack://StacksBns/webpack/runtime/global","webpack://StacksBns/webpack/runtime/hasOwnProperty shorthand","webpack://StacksBns/webpack/runtime/make namespace object","webpack://StacksBns/webpack/runtime/node module decorator","webpack://StacksBns/../common/dist/esm/utils.js","webpack://StacksBns/../common/dist/esm/constants.js","webpack://StacksBns/../common/dist/esm/fetch.js","webpack://StacksBns/../network/dist/esm/constants.js","webpack://StacksBns/../network/dist/esm/network.js","webpack://StacksBns/../common/dist/esm/buffer.js","webpack://StacksBns/../transactions/dist/esm/constants.js","webpack://StacksBns/../transactions/dist/esm/errors.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/_assert.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/utils.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/cryptoBrowser.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/hmac.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/_sha2.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/sha256.js","webpack://StacksBns/../../node_modules/@noble/secp256k1/lib/esm/index.js","webpack://StacksBns/../common/dist/esm/signatures.js","webpack://StacksBns/../common/dist/esm/keys.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/ripemd160.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/_u64.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/sha512.js","webpack://StacksBns/../transactions/dist/esm/BytesReader.js","webpack://StacksBns/../transactions/dist/esm/clarity/constants.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/intCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/bufferCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/booleanCV.js","webpack://StacksBns/../transactions/dist/esm/wire/types.js","webpack://StacksBns/../transactions/dist/esm/wire/create.js","webpack://StacksBns/../transactions/dist/esm/wire/helpers.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/principalCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/optionalCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/tupleCV.js","webpack://StacksBns/../transactions/dist/esm/utils.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/stringCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/deserialize.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/responseCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/listCV.js","webpack://StacksBns/../transactions/dist/esm/wire/serialization.js","webpack://StacksBns/../transactions/dist/esm/keys.js","webpack://StacksBns/../transactions/dist/esm/clarity/serialize.js","webpack://StacksBns/../transactions/dist/esm/address.js","webpack://StacksBns/../transactions/dist/esm/authorization.js","webpack://StacksBns/../transactions/dist/esm/clarity/clarityValue.js","webpack://StacksBns/../transactions/dist/esm/contract-abi.js","webpack://StacksBns/../transactions/dist/esm/transaction.js","webpack://StacksBns/../transactions/dist/esm/fetch.js","webpack://StacksBns/../transactions/dist/esm/postcondition.js","webpack://StacksBns/../transactions/dist/esm/builders.js","webpack://StacksBns/./src/utils.ts","webpack://StacksBns/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"StacksBns\"] = factory();\n\telse\n\t\troot[\"StacksBns\"] = factory();\n})(this, () => {\nreturn ","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8\|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes \|\| [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;\nfunction number(n) {\n if (!Number.isSafeInteger(n) \|\| n < 0)\n throw new Error(`Wrong positive integer: ${n}`);\n}\nexports.number = number;\nfunction bool(b) {\n if (typeof b !== 'boolean')\n throw new Error(`Expected boolean, not ${b}`);\n}\nexports.bool = bool;\nfunction bytes(b, ...lengths) {\n if (!(b instanceof Uint8Array))\n throw new TypeError('Expected Uint8Array');\n if (lengths.length > 0 && !lengths.includes(b.length))\n throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexports.bytes = bytes;\nfunction hash(hash) {\n if (typeof hash !== 'function' \|\| typeof hash.create !== 'function')\n throw new Error('Hash should be wrapped by utils.wrapConstructor');\n number(hash.outputLen);\n number(hash.blockLen);\n}\nexports.hash = hash;\nfunction exists(instance, checkFinished = true) {\n if (instance.destroyed)\n throw new Error('Hash instance has been destroyed');\n if (checkFinished && instance.finished)\n throw new Error('Hash#digest() has already been called');\n}\nexports.exists = exists;\nfunction output(out, instance) {\n bytes(out);\n const min = instance.outputLen;\n if (out.length < min) {\n throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n }\n}\nexports.output = output;\nconst assert = {\n number,\n bool,\n bytes,\n hash,\n exists,\n output,\n};\nexports.default = assert;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SHA2 = void 0;\nconst _assert_js_1 = require(\"./_assert.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n if (typeof view.setBigUint64 === 'function')\n return view.setBigUint64(byteOffset, value, isLE);\n const _32n = BigInt(32);\n const _u32_max = BigInt(0xffffffff);\n const wh = Number((value >> _32n) & _u32_max);\n const wl = Number(value & _u32_max);\n const h = isLE ? 4 : 0;\n const l = isLE ? 0 : 4;\n view.setUint32(byteOffset + h, wh, isLE);\n view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nclass SHA2 extends utils_js_1.Hash {\n constructor(blockLen, outputLen, padOffset, isLE) {\n super();\n this.blockLen = blockLen;\n this.outputLen = outputLen;\n this.padOffset = padOffset;\n this.isLE = isLE;\n this.finished = false;\n this.length = 0;\n this.pos = 0;\n this.destroyed = false;\n this.buffer = new Uint8Array(blockLen);\n this.view = (0, utils_js_1.createView)(this.buffer);\n }\n update(data) {\n _assert_js_1.default.exists(this);\n const { view, buffer, blockLen } = this;\n data = (0, utils_js_1.toBytes)(data);\n const len = data.length;\n for (let pos = 0; pos < len;) {\n const take = Math.min(blockLen - this.pos, len - pos);\n // Fast path: we have at least one block in input, cast it to view and process\n if (take === blockLen) {\n const dataView = (0, utils_js_1.createView)(data);\n for (; blockLen <= len - pos; pos += blockLen)\n this.process(dataView, pos);\n continue;\n }\n buffer.set(data.subarray(pos, pos + take), this.pos);\n this.pos += take;\n pos += take;\n if (this.pos === blockLen) {\n this.process(view, 0);\n this.pos = 0;\n }\n }\n this.length += data.length;\n this.roundClean();\n return this;\n }\n digestInto(out) {\n _assert_js_1.default.exists(this);\n _assert_js_1.default.output(out, this);\n this.finished = true;\n // Padding\n // We can avoid allocation of buffer for padding completely if it\n // was previously not allocated here. But it won't change performance.\n const { buffer, view, blockLen, isLE } = this;\n let { pos } = this;\n // append the bit '1' to the message\n buffer[pos++] = 0b10000000;\n this.buffer.subarray(pos).fill(0);\n // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n if (this.padOffset > blockLen - pos) {\n this.process(view, 0);\n pos = 0;\n }\n // Pad until full block byte with zeros\n for (let i = pos; i < blockLen; i++)\n buffer[i] = 0;\n // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n // You need to write around 2 exabytes (u64_max / 8 / (1024*6)) for this to happen.\n // So we just write lowest 64 bits of that value.\n setBigUint64(view, blockLen - 8, BigInt(this.length 8), isLE);\n this.process(view, 0);\n const oview = (0, utils_js_1.createView)(out);\n const len = this.outputLen;\n // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n if (len % 4)\n throw new Error('_sha2: outputLen should be aligned to 32bit');\n const outLen = len / 4;\n const state = this.get();\n if (outLen > state.length)\n throw new Error('_sha2: outputLen bigger than state');\n for (let i = 0; i < outLen; i++)\n oview.setUint32(4 * i, state[i], isLE);\n }\n digest() {\n const { buffer, outputLen } = this;\n this.digestInto(buffer);\n const res = buffer.slice(0, outputLen);\n this.destroy();\n return res;\n }\n _cloneInto(to) {\n to \|\| (to = new this.constructor());\n to.set(...this.get());\n const { blockLen, buffer, length, finished, destroyed, pos } = this;\n to.length = length;\n to.pos = pos;\n to.finished = finished;\n to.destroyed = destroyed;\n if (length % blockLen)\n to.buffer.set(buffer);\n return to;\n }\n}\nexports.SHA2 = SHA2;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.crypto = void 0;\nexports.crypto = {\n node: undefined,\n web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sha224 = exports.sha256 = void 0;\nconst _sha2_js_1 = require(\"./_sha2.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends _sha2_js_1.SHA2 {\n constructor() {\n super(64, 32, 8, false);\n // We cannot use array here since array allows indexing by variable\n // which means optimizer/compiler cannot use registers.\n this.A = IV[0] \| 0;\n this.B = IV[1] \| 0;\n this.C = IV[2] \| 0;\n this.D = IV[3] \| 0;\n this.E = IV[4] \| 0;\n this.F = IV[5] \| 0;\n this.G = IV[6] \| 0;\n this.H = IV[7] \| 0;\n }\n get() {\n const { A, B, C, D, E, F, G, H } = this;\n return [A, B, C, D, E, F, G, H];\n }\n // prettier-ignore\n set(A, B, C, D, E, F, G, H) {\n this.A = A \| 0;\n this.B = B \| 0;\n this.C = C \| 0;\n this.D = D \| 0;\n this.E = E \| 0;\n this.F = F \| 0;\n this.G = G \| 0;\n this.H = H \| 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4)\n SHA256_W[i] = view.getUint32(offset, false);\n for (let i = 16; i < 64; i++) {\n const W15 = SHA256_W[i - 15];\n const W2 = SHA256_W[i - 2];\n const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ (W15 >>> 3);\n const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.rotr)(W2, 19) ^ (W2 >>> 10);\n SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) \| 0;\n }\n // Compression function main loop, 64 rounds\n let { A, B, C, D, E, F, G, H } = this;\n for (let i = 0; i < 64; i++) {\n const sigma1 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);\n const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) \| 0;\n const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);\n const T2 = (sigma0 + Maj(A, B, C)) \| 0;\n H = G;\n G = F;\n F = E;\n E = (D + T1) \| 0;\n D = C;\n C = B;\n B = A;\n A = (T1 + T2) \| 0;\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) \| 0;\n B = (B + this.B) \| 0;\n C = (C + this.C) \| 0;\n D = (D + this.D) \| 0;\n E = (E + this.E) \| 0;\n F = (F + this.F) \| 0;\n G = (G + this.G) \| 0;\n H = (H + this.H) \| 0;\n this.set(A, B, C, D, E, F, G, H);\n }\n roundClean() {\n SHA256_W.fill(0);\n }\n destroy() {\n this.set(0, 0, 0, 0, 0, 0, 0, 0);\n this.buffer.fill(0);\n }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n constructor() {\n super();\n this.A = 0xc1059ed8 \| 0;\n this.B = 0x367cd507 \| 0;\n this.C = 0x3070dd17 \| 0;\n this.D = 0xf70e5939 \| 0;\n this.E = 0xffc00b31 \| 0;\n this.F = 0x68581511 \| 0;\n this.G = 0x64f98fa7 \| 0;\n this.H = 0xbefa4fa4 \| 0;\n this.outputLen = 28;\n }\n}\n/*\n SHA2-256 hash function\n * @param message - data that would be hashed\n /\nexports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256());\nexports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224());\n","\"use strict\";\n/! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) /\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.randomBytes = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;\n// The import here is via the package name. This is to ensure\n// that exports mapping/resolution does fall into place.\nconst crypto_1 = require(\"@noble/hashes/crypto\");\n// Cast array to different type\nconst u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.u8 = u8;\nconst u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\nexports.u32 = u32;\n// Cast array to view\nconst createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.createView = createView;\n// The rotate right (circular right shift) operation for uint32\nconst rotr = (word, shift) => (word << (32 - shift)) \| (word >>> shift);\nexports.rotr = rotr;\nexports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\n// So, just to be sure not to corrupt anything.\nif (!exports.isLE)\n throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/\n @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\n /\nfunction bytesToHex(uint8a) {\n // pre-caching improves the speed 6x\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Uint8Array expected');\n let hex = '';\n for (let i = 0; i < uint8a.length; i++) {\n hex += hexes[uint8a[i]];\n }\n return hex;\n}\nexports.bytesToHex = bytesToHex;\n/\n @example hexToBytes('deadbeef')\n /\nfunction hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n }\n if (hex.length % 2)\n throw new Error('hexToBytes: received invalid unpadded hex');\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\nexports.hexToBytes = hexToBytes;\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\nconst nextTick = async () => { };\nexports.nextTick = nextTick;\n// Returns control to thread each 'tick' ms to avoid blocking\nasync function asyncLoop(iters, tick, cb) {\n let ts = Date.now();\n for (let i = 0; i < iters; i++) {\n cb(i);\n // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n const diff = Date.now() - ts;\n if (diff >= 0 && diff < tick)\n continue;\n await (0, exports.nextTick)();\n ts += diff;\n }\n}\nexports.asyncLoop = asyncLoop;\nfunction utf8ToBytes(str) {\n if (typeof str !== 'string') {\n throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\n }\n return new TextEncoder().encode(str);\n}\nexports.utf8ToBytes = utf8ToBytes;\nfunction toBytes(data) {\n if (typeof data === 'string')\n data = utf8ToBytes(data);\n if (!(data instanceof Uint8Array))\n throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\n return data;\n}\nexports.toBytes = toBytes;\n/*\n Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\n * @example concatBytes(buf1, buf2)\n /\nfunction concatBytes(...arrays) {\n if (!arrays.every((a) => a instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\nexports.concatBytes = concatBytes;\n// For runtime check if class implements interface\nclass Hash {\n // Safe version that clones internal state\n clone() {\n return this._cloneInto();\n }\n}\nexports.Hash = Hash;\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nfunction checkOpts(defaults, opts) {\n if (opts !== undefined && (typeof opts !== 'object' \|\| !isPlainObject(opts)))\n throw new TypeError('Options should be object or undefined');\n const merged = Object.assign(defaults, opts);\n return merged;\n}\nexports.checkOpts = checkOpts;\nfunction wrapConstructor(hashConstructor) {\n const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\n const tmp = hashConstructor();\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = () => hashConstructor();\n return hashC;\n}\nexports.wrapConstructor = wrapConstructor;\nfunction wrapConstructorWithOpts(hashCons) {\n const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n const tmp = hashCons({});\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = (opts) => hashCons(opts);\n return hashC;\n}\nexports.wrapConstructorWithOpts = wrapConstructorWithOpts;\n/\n Secure PRNG\n /\nfunction randomBytes(bytesLength = 32) {\n if (crypto_1.crypto.web) {\n return crypto_1.crypto.web.getRandomValues(new Uint8Array(bytesLength));\n }\n else if (crypto_1.crypto.node) {\n return new Uint8Array(crypto_1.crypto.node.randomBytes(bytesLength).buffer);\n }\n else {\n throw new Error(\"The environment doesn't have randomBytes function\");\n }\n}\nexports.randomBytes = randomBytes;\n","'use strict'\n// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\nfunction base (ALPHABET) {\n if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n var BASE_MAP = new Uint8Array(256)\n for (var j = 0; j < BASE_MAP.length; j++) {\n BASE_MAP[j] = 255\n }\n for (var i = 0; i < ALPHABET.length; i++) {\n var x = ALPHABET.charAt(i)\n var xc = x.charCodeAt(0)\n if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n BASE_MAP[xc] = i\n }\n var BASE = ALPHABET.length\n var LEADER = ALPHABET.charAt(0)\n var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n function encode (source) {\n if (source instanceof Uint8Array) {\n } else if (ArrayBuffer.isView(source)) {\n source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n } else if (Array.isArray(source)) {\n source = Uint8Array.from(source)\n }\n if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }\n if (source.length === 0) { return '' }\n // Skip & count leading zeroes.\n var zeroes = 0\n var length = 0\n var pbegin = 0\n var pend = source.length\n while (pbegin !== pend && source[pbegin] === 0) {\n pbegin++\n zeroes++\n }\n // Allocate enough space in big-endian base58 representation.\n var size = ((pend - pbegin) iFACTOR + 1) >>> 0\n var b58 = new Uint8Array(size)\n // Process the bytes.\n while (pbegin !== pend) {\n var carry = source[pbegin]\n // Apply \"b58 = b58 * 256 + ch\".\n var i = 0\n for (var it1 = size - 1; (carry !== 0 \|\| i < length) && (it1 !== -1); it1--, i++) {\n carry += (256 * b58[it1]) >>> 0\n b58[it1] = (carry % BASE) >>> 0\n carry = (carry / BASE) >>> 0\n }\n if (carry !== 0) { throw new Error('Non-zero carry') }\n length = i\n pbegin++\n }\n // Skip leading zeroes in base58 result.\n var it2 = size - length\n while (it2 !== size && b58[it2] === 0) {\n it2++\n }\n // Translate the result into a string.\n var str = LEADER.repeat(zeroes)\n for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n return str\n }\n function decodeUnsafe (source) {\n if (typeof source !== 'string') { throw new TypeError('Expected String') }\n if (source.length === 0) { return new Uint8Array() }\n var psz = 0\n // Skip and count leading '1's.\n var zeroes = 0\n var length = 0\n while (source[psz] === LEADER) {\n zeroes++\n psz++\n }\n // Allocate enough space in big-endian base256 representation.\n var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n var b256 = new Uint8Array(size)\n // Process the characters.\n while (source[psz]) {\n // Decode character\n var carry = BASE_MAP[source.charCodeAt(psz)]\n // Invalid character\n if (carry === 255) { return }\n var i = 0\n for (var it3 = size - 1; (carry !== 0 \|\| i < length) && (it3 !== -1); it3--, i++) {\n carry += (BASE * b256[it3]) >>> 0\n b256[it3] = (carry % 256) >>> 0\n carry = (carry / 256) >>> 0\n }\n if (carry !== 0) { throw new Error('Non-zero carry') }\n length = i\n psz++\n }\n // Skip leading zeroes in b256.\n var it4 = size - length\n while (it4 !== size && b256[it4] === 0) {\n it4++\n }\n var vch = new Uint8Array(zeroes + (size - it4))\n var j = zeroes\n while (it4 !== size) {\n vch[j++] = b256[it4++]\n }\n return vch\n }\n function decode (string) {\n var buffer = decodeUnsafe(string)\n if (buffer) { return buffer }\n throw new Error('Non-base' + BASE + ' character')\n }\n return {\n encode: encode,\n decodeUnsafe: decodeUnsafe,\n decode: decode\n }\n}\nmodule.exports = base\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32ToB58 = exports.b58ToC32 = exports.c32addressDecode = exports.c32address = exports.versions = void 0;\nconst checksum_1 = require(\"./checksum\");\nconst base58check = require(\"./base58check\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.versions = {\n mainnet: {\n p2pkh: 22,\n p2sh: 20, // 'M'\n },\n testnet: {\n p2pkh: 26,\n p2sh: 21, // 'N'\n },\n};\n// address conversion : bitcoin to stacks\nconst ADDR_BITCOIN_TO_STACKS = {};\nADDR_BITCOIN_TO_STACKS[0] = exports.versions.mainnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[5] = exports.versions.mainnet.p2sh;\nADDR_BITCOIN_TO_STACKS[111] = exports.versions.testnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[196] = exports.versions.testnet.p2sh;\n// address conversion : stacks to bitcoin\nconst ADDR_STACKS_TO_BITCOIN = {};\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2pkh] = 0;\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2sh] = 5;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2pkh] = 111;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2sh] = 196;\n/*\n Make a c32check address with the given version and hash160\n * The only difference between a c32check string and c32 address\n * is that the letter 'S' is pre-pended.\n * @param {number} version - the address version number\n * @param {string} hash160hex - the hash160 to encode (must be a hash160)\n * @returns {string} the address\n /\nfunction c32address(version, hash160hex) {\n if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {\n throw new Error('Invalid argument: not a hash160 hex string');\n }\n const c32string = (0, checksum_1.c32checkEncode)(version, hash160hex);\n return `S${c32string}`;\n}\nexports.c32address = c32address;\n/\n Decode a c32 address into its version and hash160\n * @param {string} c32addr - the c32check-encoded address\n * @returns {[number, string]} a tuple with the version and hash160\n /\nfunction c32addressDecode(c32addr) {\n if (c32addr.length <= 5) {\n throw new Error('Invalid c32 address: invalid length');\n }\n if (c32addr[0] != 'S') {\n throw new Error('Invalid c32 address: must start with \"S\"');\n }\n return (0, checksum_1.c32checkDecode)(c32addr.slice(1));\n}\nexports.c32addressDecode = c32addressDecode;\n/\n * Convert a base58check address to a c32check address.\n * Try to convert the version number if one is not given.\n * @param {string} b58check - the base58check encoded address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the c32 address with the given version number (or the\n * semantically-equivalent c32 version number, if not given)\n /\nfunction b58ToC32(b58check, version = -1) {\n const addrInfo = base58check.decode(b58check);\n const hash160String = (0, utils_1.bytesToHex)(addrInfo.data);\n const addrVersion = parseInt((0, utils_1.bytesToHex)(addrInfo.prefix), 16);\n let stacksVersion;\n if (version < 0) {\n stacksVersion = addrVersion;\n if (ADDR_BITCOIN_TO_STACKS[addrVersion] !== undefined) {\n stacksVersion = ADDR_BITCOIN_TO_STACKS[addrVersion];\n }\n }\n else {\n stacksVersion = version;\n }\n return c32address(stacksVersion, hash160String);\n}\nexports.b58ToC32 = b58ToC32;\n/\n * Convert a c32check address to a base58check address.\n * @param {string} c32string - the c32check address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the base58 address with the given version number (or the\n * semantically-equivalent bitcoin version number, if not given)\n /\nfunction c32ToB58(c32string, version = -1) {\n const addrInfo = c32addressDecode(c32string);\n const stacksVersion = addrInfo[0];\n const hash160String = addrInfo[1];\n let bitcoinVersion;\n if (version < 0) {\n bitcoinVersion = stacksVersion;\n if (ADDR_STACKS_TO_BITCOIN[stacksVersion] !== undefined) {\n bitcoinVersion = ADDR_STACKS_TO_BITCOIN[stacksVersion];\n }\n }\n else {\n bitcoinVersion = version;\n }\n let prefix = bitcoinVersion.toString(16);\n if (prefix.length === 1) {\n prefix = `0${prefix}`;\n }\n return base58check.encode(hash160String, prefix);\n}\nexports.c32ToB58 = c32ToB58;\n","/\n * From https://github.com/wzbg/base58check\n * @Author: zyc\n * @Date: 2016-09-11 23:36:05\n /\n'use strict';\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decode = exports.encode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst basex = require(\"base-x\");\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nfunction encode(data, prefix = '00') {\n const dataBytes = typeof data === 'string' ? (0, utils_1.hexToBytes)(data) : data;\n const prefixBytes = typeof prefix === 'string' ? (0, utils_1.hexToBytes)(prefix) : data;\n if (!(dataBytes instanceof Uint8Array) \|\| !(prefixBytes instanceof Uint8Array)) {\n throw new TypeError('Argument must be of type Uint8Array or string');\n }\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n return basex(ALPHABET).encode([...prefixBytes, ...dataBytes, ...checksum.slice(0, 4)]);\n}\nexports.encode = encode;\nfunction decode(string) {\n const bytes = basex(ALPHABET).decode(string);\n const prefixBytes = bytes.slice(0, 1);\n const dataBytes = bytes.slice(1, -4);\n // todo: for better performance replace spread with `concatBytes` method\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n bytes.slice(-4).forEach((check, index) => {\n if (check !== checksum[index]) {\n throw new Error('Invalid checksum');\n }\n });\n return { prefix: prefixBytes, data: dataBytes };\n}\nexports.decode = decode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32checkDecode = exports.c32checkEncode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst encoding_1 = require(\"./encoding\");\n/\n Get the c32check checksum of a hex-encoded string\n * @param {string} dataHex - the hex string\n * @returns {string} the c32 checksum, as a bin-encoded string\n /\nfunction c32checksum(dataHex) {\n const dataHash = (0, sha256_1.sha256)((0, sha256_1.sha256)((0, utils_1.hexToBytes)(dataHex)));\n const checksum = (0, utils_1.bytesToHex)(dataHash.slice(0, 4));\n return checksum;\n}\n/\n Encode a hex string as a c32check string. This is a lot like how\n * base58check works in Bitcoin-land, but this algorithm uses the\n * z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * calculate the c32checksum of version + data\n * * c32encode version + data + c32checksum\n * @param {number} version - the version string (between 0 and 31)\n * @param {string} data - the data to encode\n * @returns {string} the c32check representation\n /\nfunction c32checkEncode(version, data) {\n if (version < 0 \|\| version >= 32) {\n throw new Error('Invalid version (must be between 0 and 31)');\n }\n if (!data.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Invalid data (not a hex string)');\n }\n data = data.toLowerCase();\n if (data.length % 2 !== 0) {\n data = `0${data}`;\n }\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n const checksumHex = c32checksum(`${versionHex}${data}`);\n const c32str = (0, encoding_1.c32encode)(`${data}${checksumHex}`);\n return `${encoding_1.c32[version]}${c32str}`;\n}\nexports.c32checkEncode = c32checkEncode;\n/\n Decode a c32check string back into its version and data payload. This is\n * a lot like how base58check works in Bitcoin-land, but this algorithm uses\n * the z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * extract the version, data, and checksum\n * * verify the checksum matches c32checksum(version + data)\n * * return data\n * @param {string} c32data - the c32check-encoded string\n * @returns {array} [version (number), data (string)]. The returned data\n * will be a hex string. Throws an exception if the checksum does not match.\n /\nfunction c32checkDecode(c32data) {\n c32data = (0, encoding_1.c32normalize)(c32data);\n const dataHex = (0, encoding_1.c32decode)(c32data.slice(1));\n const versionChar = c32data[0];\n const version = encoding_1.c32.indexOf(versionChar);\n const checksum = dataHex.slice(-8);\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {\n throw new Error('Invalid c32check string: checksum mismatch');\n }\n return [version, dataHex.substring(0, dataHex.length - 8)];\n}\nexports.c32checkDecode = c32checkDecode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32decode = exports.c32normalize = exports.c32encode = exports.c32 = void 0;\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.c32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';\nconst hex = '0123456789abcdef';\n/\n Encode a hex string as a c32 string. Note that the hex string is assumed\n * to be big-endian (and the resulting c32 string will be as well).\n * @param {string} inputHex - the input to encode\n * @param {number} minLength - the minimum length of the c32 string\n * @returns {string} the c32check-encoded representation of the data, as a string\n /\nfunction c32encode(inputHex, minLength) {\n // must be hex\n if (!inputHex.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Not a hex-encoded string');\n }\n if (inputHex.length % 2 !== 0) {\n inputHex = `0${inputHex}`;\n }\n inputHex = inputHex.toLowerCase();\n let res = [];\n let carry = 0;\n for (let i = inputHex.length - 1; i >= 0; i--) {\n if (carry < 4) {\n const currentCode = hex.indexOf(inputHex[i]) >> carry;\n let nextCode = 0;\n if (i !== 0) {\n nextCode = hex.indexOf(inputHex[i - 1]);\n }\n // carry = 0, nextBits is 1, carry = 1, nextBits is 2\n const nextBits = 1 + carry;\n const nextLowBits = nextCode % (1 << nextBits) << (5 - nextBits);\n const curC32Digit = exports.c32[currentCode + nextLowBits];\n carry = nextBits;\n res.unshift(curC32Digit);\n }\n else {\n carry = 0;\n }\n }\n let C32leadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n C32leadingZeros++;\n }\n }\n res = res.slice(C32leadingZeros);\n const zeroPrefix = new TextDecoder().decode((0, utils_1.hexToBytes)(inputHex)).match(/^\\u0000/);\n const numLeadingZeroBytesInHex = zeroPrefix ? zeroPrefix[0].length : 0;\n for (let i = 0; i < numLeadingZeroBytesInHex; i++) {\n res.unshift(exports.c32[0]);\n }\n if (minLength) {\n const count = minLength - res.length;\n for (let i = 0; i < count; i++) {\n res.unshift(exports.c32[0]);\n }\n }\n return res.join('');\n}\nexports.c32encode = c32encode;\n/\n * Normalize a c32 string\n * @param {string} c32input - the c32-encoded input string\n * @returns {string} the canonical representation of the c32 input string\n /\nfunction c32normalize(c32input) {\n // must be upper-case\n // replace all O's with 0's\n // replace all I's and L's with 1's\n return c32input.toUpperCase().replace(/O/g, '0').replace(/L\|I/g, '1');\n}\nexports.c32normalize = c32normalize;\n/\n * Decode a c32 string back into a hex string. Note that the c32 input\n * string is assumed to be big-endian (and the resulting hex string will\n * be as well).\n * @param {string} c32input - the c32-encoded input to decode\n * @param {number} minLength - the minimum length of the output hex string (in bytes)\n * @returns {string} the hex-encoded representation of the data, as a string\n /\nfunction c32decode(c32input, minLength) {\n c32input = c32normalize(c32input);\n // must result in a c32 string\n if (!c32input.match(`^[${exports.c32}]$`)) {\n throw new Error('Not a c32-encoded string');\n }\n const zeroPrefix = c32input.match(`^${exports.c32[0]}`);\n const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;\n let res = [];\n let carry = 0;\n let carryBits = 0;\n for (let i = c32input.length - 1; i >= 0; i--) {\n if (carryBits === 4) {\n res.unshift(hex[carry]);\n carryBits = 0;\n carry = 0;\n }\n const currentCode = exports.c32.indexOf(c32input[i]) << carryBits;\n const currentValue = currentCode + carry;\n const currentHexDigit = hex[currentValue % 16];\n carryBits += 1;\n carry = currentValue >> 4;\n if (carry > 1 << carryBits) {\n throw new Error('Panic error in decoding.');\n }\n res.unshift(currentHexDigit);\n }\n // one last carry\n res.unshift(hex[carry]);\n if (res.length % 2 === 1) {\n res.unshift('0');\n }\n let hexLeadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n hexLeadingZeros++;\n }\n }\n res = res.slice(hexLeadingZeros - (hexLeadingZeros % 2));\n let hexStr = res.join('');\n for (let i = 0; i < numLeadingZeroBytes; i++) {\n hexStr = `00${hexStr}`;\n }\n if (minLength) {\n const count = minLength 2 - hexStr.length;\n for (let i = 0; i < count; i += 2) {\n hexStr = `00${hexStr}`;\n }\n }\n return hexStr;\n}\nexports.c32decode = c32decode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.b58ToC32 = exports.c32ToB58 = exports.versions = exports.c32normalize = exports.c32addressDecode = exports.c32address = exports.c32checkDecode = exports.c32checkEncode = exports.c32decode = exports.c32encode = void 0;\nconst encoding_1 = require(\"./encoding\");\nObject.defineProperty(exports, \"c32encode\", { enumerable: true, get: function () { return encoding_1.c32encode; } });\nObject.defineProperty(exports, \"c32decode\", { enumerable: true, get: function () { return encoding_1.c32decode; } });\nObject.defineProperty(exports, \"c32normalize\", { enumerable: true, get: function () { return encoding_1.c32normalize; } });\nconst checksum_1 = require(\"./checksum\");\nObject.defineProperty(exports, \"c32checkEncode\", { enumerable: true, get: function () { return checksum_1.c32checkEncode; } });\nObject.defineProperty(exports, \"c32checkDecode\", { enumerable: true, get: function () { return checksum_1.c32checkDecode; } });\nconst address_1 = require(\"./address\");\nObject.defineProperty(exports, \"c32address\", { enumerable: true, get: function () { return address_1.c32address; } });\nObject.defineProperty(exports, \"c32addressDecode\", { enumerable: true, get: function () { return address_1.c32addressDecode; } });\nObject.defineProperty(exports, \"c32ToB58\", { enumerable: true, get: function () { return address_1.c32ToB58; } });\nObject.defineProperty(exports, \"b58ToC32\", { enumerable: true, get: function () { return address_1.b58ToC32; } });\nObject.defineProperty(exports, \"versions\", { enumerable: true, get: function () { return address_1.versions; } });\n","/*\n lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n /\n\n/* Used as the size to enable large array optimizations. /\nvar LARGE_ARRAY_SIZE = 200;\n\n/* Used to stand-in for `undefined` hash values. /\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/* Used as references for various `Number` constants. /\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/* `Object#toString` result references. /\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/\n Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n /\nvar reRegExpChar = /[\\\\^$.+?()[\\]{}\|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. /\nvar reFlags = /\\w$/;\n\n/** Used to detect host constructors (Safari). /\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/* Used to detect unsigned integer values. /\nvar reIsUint = /^(?:0\|[1-9]\\d)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. /\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/* Detect free variable `global` from Node.js. /\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/* Detect free variable `self`. /\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/* Used as a reference to the global object. /\nvar root = freeGlobal \|\| freeSelf \|\| Function('return this')();\n\n/* Detect free variable `exports`. /\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/* Detect free variable `module`. /\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/* Detect the popular CommonJS extension `module.exports`. /\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/\n Adds the key-value `pair` to `map`.\n \n @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n /\nfunction addMapEntry(map, pair) {\n // Don't return `map.set` because it's not chainable in IE 11.\n map.set(pair[0], pair[1]);\n return map;\n}\n\n/\n Adds `value` to `set`.\n \n @private\n * @param {Object} set The set to modify.\n * @param {} value The value to add.\n @returns {Object} Returns `set`.\n /\nfunction addSetEntry(set, value) {\n // Don't return `set.add` because it's not chainable in IE 11.\n set.add(value);\n return set;\n}\n\n/\n A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n /\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array ? array.length : 0;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\n/\n Appends the elements of `values` to `array`.\n \n @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n /\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/\n A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {} [accumulator] The initial value.\n @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {} Returns the accumulated value.\n /\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array ? array.length : 0;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n}\n\n/*\n The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n \n @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n /\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/\n Gets the value at `key` of `object`.\n \n @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {} Returns the property value.\n /\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/*\n Checks if `value` is a host object in IE < 9.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n /\nfunction isHostObject(value) {\n // Many host objects are `Object` objects that can coerce to strings\n // despite having improperly defined `toString` methods.\n var result = false;\n if (value != null && typeof value.toString != 'function') {\n try {\n result = !!(value + '');\n } catch (e) {}\n }\n return result;\n}\n\n/\n Converts `map` to its key-value pairs.\n \n @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n /\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\n/\n Creates a unary function that invokes `func` with its argument transformed.\n \n @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n /\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/\n Converts `set` to an array of its values.\n \n @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n /\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\n/* Used for built-in method references. /\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/* Used to detect overreaching core-js shims. /\nvar coreJsData = root['__core-js_shared__'];\n\n/* Used to detect methods masquerading as native. /\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO \|\| '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/* Used to resolve the decompiled source of functions. /\nvar funcToString = funcProto.toString;\n\n/* Used to check objects for own properties. /\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/\n Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n /\nvar objectToString = objectProto.toString;\n\n/* Used to detect if a method is native. /\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty\|(function).?(?=\\\\\\()\| for .+?(?=\\\\\\])/g, '$1.?') + '$'\n);\n\n/* Built-in value references. /\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice;\n\n/ Built-in method references for those with the same name as other `lodash` methods. /\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeKeys = overArg(Object.keys, Object);\n\n/ Built-in method references that are verified to be native. /\nvar DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n/* Used to detect maps, sets, and weakmaps. /\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/* Used to convert symbols to primitives and strings. /\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/\n Creates a hash object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Hash(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the hash.\n \n @private\n * @name clear\n * @memberOf Hash\n /\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/\n Removes `key` and its value from the hash.\n \n @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction hashDelete(key) {\n return this.has(key) && delete this.__data__[key];\n}\n\n/\n Gets the hash value for `key`.\n \n @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/*\n Checks if a hash value for `key` exists.\n \n @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/\n Sets the hash `key` to `value`.\n \n @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the hash instance.\n /\nfunction hashSet(key, value) {\n var data = this.__data__;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/\n Creates an list cache object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction ListCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the list cache.\n \n @private\n * @name clear\n * @memberOf ListCache\n /\nfunction listCacheClear() {\n this.__data__ = [];\n}\n\n/\n Removes `key` and its value from the list cache.\n \n @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n return true;\n}\n\n/\n Gets the list cache value for `key`.\n \n @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/*\n Checks if a list cache value for `key` exists.\n \n @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/\n Sets the list cache `key` to `value`.\n \n @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the list cache instance.\n /\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/\n Creates a map cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction MapCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the map.\n \n @private\n * @name clear\n * @memberOf MapCache\n /\nfunction mapCacheClear() {\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map \|\| ListCache),\n 'string': new Hash\n };\n}\n\n/\n Removes `key` and its value from the map.\n \n @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction mapCacheDelete(key) {\n return getMapData(this, key)['delete'](key);\n}\n\n/\n Gets the map value for `key`.\n \n @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/*\n Checks if a map value for `key` exists.\n \n @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/\n Sets the map `key` to `value`.\n \n @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the map cache instance.\n /\nfunction mapCacheSet(key, value) {\n getMapData(this, key).set(key, value);\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/\n Creates a stack cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Stack(entries) {\n this.__data__ = new ListCache(entries);\n}\n\n/\n Removes all key-value entries from the stack.\n \n @private\n * @name clear\n * @memberOf Stack\n /\nfunction stackClear() {\n this.__data__ = new ListCache;\n}\n\n/\n Removes `key` and its value from the stack.\n \n @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction stackDelete(key) {\n return this.__data__['delete'](key);\n}\n\n/\n Gets the stack value for `key`.\n \n @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/*\n Checks if a stack value for `key` exists.\n \n @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/\n Sets the stack `key` to `value`.\n \n @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the stack cache instance.\n /\nfunction stackSet(key, value) {\n var cache = this.__data__;\n if (cache instanceof ListCache) {\n var pairs = cache.__data__;\n if (!Map \|\| (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n return this;\n }\n cache = this.__data__ = new MapCache(pairs);\n }\n cache.set(key, value);\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/\n Creates an array of the enumerable property names of the array-like `value`.\n \n @private\n * @param {} value The value to query.\n @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n /\nfunction arrayLikeKeys(value, inherited) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n // Safari 9 makes `arguments.length` enumerable in strict mode.\n var result = (isArray(value) \|\| isArguments(value))\n ? baseTimes(value.length, String)\n : [];\n\n var length = result.length,\n skipIndexes = !!length;\n\n for (var key in value) {\n if ((inherited \|\| hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (key == 'length' \|\| isIndex(key, length)))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n \n @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {} value The value to assign.\n /\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) \|\|\n (value === undefined && !(key in object))) {\n object[key] = value;\n }\n}\n\n/*\n Gets the index at which the `key` is found in `array` of key-value pairs.\n \n @private\n * @param {Array} array The array to inspect.\n * @param {} key The key to search for.\n @returns {number} Returns the index of the matched value, else `-1`.\n /\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/\n The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n \n @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n /\nfunction baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n}\n\n/\n The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n \n @private\n * @param {} value The value to clone.\n @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {} Returns the cloned value.\n /\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n var result;\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag \|\| tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag \|\| tag == argsTag \|\| (isFunc && !object)) {\n if (isHostObject(value)) {\n return object ? value : {};\n }\n result = initCloneObject(isFunc ? {} : value);\n if (!isDeep) {\n return copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, baseClone, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack \|\| (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (!isArr) {\n var props = isFull ? getAllKeys(value) : keys(value);\n }\n arrayEach(props \|\| value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n });\n return result;\n}\n\n/*\n The base implementation of `_.create` without support for assigning\n * properties to the created object.\n \n @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n /\nfunction baseCreate(proto) {\n return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/\n The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/\n The base implementation of `getTag`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nfunction baseGetTag(value) {\n return objectToString.call(value);\n}\n\n/\n The base implementation of `_.isNative` without bad shim checks.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n /\nfunction baseIsNative(value) {\n if (!isObject(value) \|\| isMasked(value)) {\n return false;\n }\n var pattern = (isFunction(value) \|\| isHostObject(value)) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/\n The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n /\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Creates a clone of `buffer`.\n \n @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n /\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var result = new buffer.constructor(buffer.length);\n buffer.copy(result);\n return result;\n}\n\n/\n Creates a clone of `arrayBuffer`.\n \n @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n /\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\n/\n Creates a clone of `dataView`.\n \n @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n /\nfunction cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/\n Creates a clone of `map`.\n \n @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n /\nfunction cloneMap(map, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/\n Creates a clone of `regexp`.\n \n @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n /\nfunction cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n}\n\n/\n Creates a clone of `set`.\n \n @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n /\nfunction cloneSet(set, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/\n Creates a clone of the `symbol` object.\n \n @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n /\nfunction cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/\n Creates a clone of `typedArray`.\n \n @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n /\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/\n Copies the values of `source` to `array`.\n \n @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n /\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array \|\| (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\n/\n Copies properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n /\nfunction copyObject(source, props, object, customizer) {\n object \|\| (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n assignValue(object, key, newValue === undefined ? source[key] : newValue);\n }\n return object;\n}\n\n/\n Copies own symbol properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n /\nfunction copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n}\n\n/\n Creates an array of own enumerable property names and symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/\n Gets the data for `map`.\n \n @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {} Returns the map data.\n /\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/*\n Gets the native function at `key` of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {} Returns the function if it's native, else `undefined`.\n /\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/*\n Creates an array of the own enumerable symbol properties of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n /\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/\n Gets the `toStringTag` of `value`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) \|\|\n (Map && getTag(new Map) != mapTag) \|\|\n (Promise && getTag(Promise.resolve()) != promiseTag) \|\|\n (Set && getTag(new Set) != setTag) \|\|\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = objectToString.call(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : undefined;\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\n/\n Initializes an array clone.\n \n @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n /\nfunction initCloneArray(array) {\n var length = array.length,\n result = array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n}\n\n/\n Initializes an object clone.\n \n @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\n/\n Initializes an object clone based on its `toStringTag`.\n \n Note: This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n \n @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return cloneMap(object, isDeep, cloneFunc);\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return cloneSet(object, isDeep, cloneFunc);\n\n case symbolTag:\n return cloneSymbol(object);\n }\n}\n\n/\n Checks if `value` is a valid array-like index.\n \n @private\n * @param {} value The value to check.\n @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n /\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' \|\| reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/\n Checks if `value` is suitable for use as unique object key.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n /\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' \|\| type == 'number' \|\| type == 'symbol' \|\| type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/\n Checks if `func` has its source masked.\n \n @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n /\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/\n Checks if `value` is likely a prototype object.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n /\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) \|\| objectProto;\n\n return value === proto;\n}\n\n/\n Converts `func` to its source code.\n \n @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n /\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/\n This method is like `_.clone` except that it recursively clones `value`.\n \n @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {} value The value to recursively clone.\n @returns {} Returns the deep cloned value.\n @see _.clone\n * @example\n \n var objects = [{ 'a': 1 }, { 'b': 2 }];\n \n var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n /\nfunction cloneDeep(value) {\n return baseClone(value, true, true);\n}\n\n/\n Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to compare.\n @param {} other The other value to compare.\n @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n \n var object = { 'a': 1 };\n * var other = { 'a': 1 };\n \n _.eq(object, object);\n * // => true\n \n _.eq(object, other);\n * // => false\n \n _.eq('a', 'a');\n * // => true\n \n _.eq('a', Object('a'));\n * // => false\n \n _.eq(NaN, NaN);\n * // => true\n /\nfunction eq(value, other) {\n return value === other \|\| (value !== value && other !== other);\n}\n\n/\n Checks if `value` is likely an `arguments` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n \n _.isArguments(function() { return arguments; }());\n * // => true\n \n _.isArguments([1, 2, 3]);\n * // => false\n /\nfunction isArguments(value) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n (!propertyIsEnumerable.call(value, 'callee') \|\| objectToString.call(value) == argsTag);\n}\n\n/\n Checks if `value` is classified as an `Array` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n \n _.isArray([1, 2, 3]);\n * // => true\n \n _.isArray(document.body.children);\n * // => false\n \n _.isArray('abc');\n * // => false\n \n _.isArray(_.noop);\n * // => false\n /\nvar isArray = Array.isArray;\n\n/\n Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n \n _.isArrayLike([1, 2, 3]);\n * // => true\n \n _.isArrayLike(document.body.children);\n * // => true\n \n _.isArrayLike('abc');\n * // => true\n \n _.isArrayLike(_.noop);\n * // => false\n /\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/\n This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n \n _.isArrayLikeObject([1, 2, 3]);\n * // => true\n \n _.isArrayLikeObject(document.body.children);\n * // => true\n \n _.isArrayLikeObject('abc');\n * // => false\n \n _.isArrayLikeObject(_.noop);\n * // => false\n /\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/\n Checks if `value` is a buffer.\n \n @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n \n _.isBuffer(new Buffer(2));\n * // => true\n \n _.isBuffer(new Uint8Array(2));\n * // => false\n /\nvar isBuffer = nativeIsBuffer \|\| stubFalse;\n\n/\n Checks if `value` is classified as a `Function` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n \n _.isFunction(_);\n * // => true\n \n _.isFunction(/abc/);\n * // => false\n /\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag \|\| tag == genTag;\n}\n\n/\n Checks if `value` is a valid array-like length.\n \n Note: This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n \n _.isLength(3);\n * // => true\n \n _.isLength(Number.MIN_VALUE);\n * // => false\n \n _.isLength(Infinity);\n * // => false\n \n _.isLength('3');\n * // => false\n /\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/\n Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n \n _.isObject({});\n * // => true\n \n _.isObject([1, 2, 3]);\n * // => true\n \n _.isObject(_.noop);\n * // => true\n \n _.isObject(null);\n * // => false\n /\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' \|\| type == 'function');\n}\n\n/\n Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n \n _.isObjectLike({});\n * // => true\n \n _.isObjectLike([1, 2, 3]);\n * // => true\n \n _.isObjectLike(_.noop);\n * // => false\n \n _.isObjectLike(null);\n * // => false\n /\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/\n Creates an array of the own enumerable property names of `object`.\n \n Note: Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n \n @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n \n function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n \n Foo.prototype.c = 3;\n \n _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n \n _.keys('hi');\n * // => ['0', '1']\n /\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/\n This method returns a new empty array.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n \n var arrays = _.times(2, _.stubArray);\n \n console.log(arrays);\n * // => [[], []]\n \n console.log(arrays[0] === arrays[1]);\n * // => false\n /\nfunction stubArray() {\n return [];\n}\n\n/\n This method returns `false`.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n \n _.times(2, _.stubFalse);\n * // => [false, false]\n /\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = cloneDeep;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this \|\| new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import { Logger } from './logger';\nexport const BLOCKSTACK_HANDLER = 'blockstack';\nexport function nextYear() {\n return new Date(new Date().setFullYear(new Date().getFullYear() + 1));\n}\nexport function nextMonth() {\n return new Date(new Date().setMonth(new Date().getMonth() + 1));\n}\nexport function nextHour() {\n return new Date(new Date().setHours(new Date().getHours() + 1));\n}\nexport function megabytesToBytes(megabytes) {\n if (!Number.isFinite(megabytes)) {\n return 0;\n }\n return Math.floor(megabytes 1024 * 1024);\n}\nexport function getAesCbcOutputLength(inputByteLength) {\n const cipherTextLength = (Math.floor(inputByteLength / 16) + 1) * 16;\n return cipherTextLength;\n}\nexport function getBase64OutputLength(inputByteLength) {\n const encodedLength = Math.ceil(inputByteLength / 3) * 4;\n return encodedLength;\n}\nexport function updateQueryStringParameter(uri, key, value) {\n const re = new RegExp(`([?&])${key}=.?(&\|$)`, 'i');\n const separator = uri.indexOf('?') !== -1 ? '&' : '?';\n if (uri.match(re)) {\n return uri.replace(re, `$1${key}=${value}$2`);\n }\n else {\n return `${uri}${separator}${key}=${value}`;\n }\n}\nexport function isLaterVersion(v1, v2) {\n if (v1 === undefined \|\| v1 === '') {\n v1 = '0.0.0';\n }\n if (v2 === undefined \|\| v1 === '') {\n v2 = '0.0.0';\n }\n const v1tuple = v1.split('.').map(x => parseInt(x, 10));\n const v2tuple = v2.split('.').map(x => parseInt(x, 10));\n for (let index = 0; index < v2.length; index++) {\n if (index >= v1.length) {\n v2tuple.push(0);\n }\n if (v1tuple[index] < v2tuple[index]) {\n return false;\n }\n }\n return true;\n}\nexport function makeUUID4() {\n let d = new Date().getTime();\n if (typeof performance !== 'undefined' && typeof performance.now === 'function') {\n d += performance.now();\n }\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n const r = (d + Math.random() 16) % 16 \| 0;\n d = Math.floor(d / 16);\n return (c === 'x' ? r : (r & 0x3) \| 0x8).toString(16);\n });\n}\nexport function isSameOriginAbsoluteUrl(uri1, uri2) {\n try {\n const parsedUri1 = new URL(uri1);\n const parsedUri2 = new URL(uri2);\n const port1 = parseInt(parsedUri1.port \|\| '0', 10) \| 0 \|\| (parsedUri1.protocol === 'https:' ? 443 : 80);\n const port2 = parseInt(parsedUri2.port \|\| '0', 10) \| 0 \|\| (parsedUri2.protocol === 'https:' ? 443 : 80);\n const match = {\n scheme: parsedUri1.protocol === parsedUri2.protocol,\n hostname: parsedUri1.hostname === parsedUri2.hostname,\n port: port1 === port2,\n absolute: (uri1.includes('http://') \|\| uri1.includes('https://')) &&\n (uri2.includes('http://') \|\| uri2.includes('https://')),\n };\n return match.scheme && match.hostname && match.port && match.absolute;\n }\n catch (error) {\n console.log(error);\n console.log('Parsing error in same URL origin check');\n return false;\n }\n}\nexport function getGlobalScope() {\n if (typeof self !== 'undefined') {\n return self;\n }\n if (typeof window !== 'undefined') {\n return window;\n }\n if (typeof global !== 'undefined') {\n return global;\n }\n throw new Error('Unexpected runtime environment - no supported global scope (`window`, `self`, `global`) available');\n}\nfunction getAPIUsageErrorMessage(scopeObject, apiName, usageDesc) {\n if (usageDesc) {\n return `Use of '${usageDesc}' requires \\`${apiName}\\` which is unavailable on the '${scopeObject}' object within the currently executing environment.`;\n }\n else {\n return `\\`${apiName}\\` is unavailable on the '${scopeObject}' object within the currently executing environment.`;\n }\n}\nexport function getGlobalObject(name, { throwIfUnavailable, usageDesc, returnEmptyObject } = {}) {\n let globalScope = undefined;\n try {\n globalScope = getGlobalScope();\n if (globalScope) {\n const obj = globalScope[name];\n if (obj) {\n return obj;\n }\n }\n }\n catch (error) {\n Logger.error(`Error getting object '${name}' from global scope '${globalScope}': ${error}`);\n }\n if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n Logger.error(errMsg);\n throw new Error(errMsg);\n }\n if (returnEmptyObject) {\n return {};\n }\n return undefined;\n}\nexport function getGlobalObjects(names, { throwIfUnavailable, usageDesc, returnEmptyObject } = {}) {\n let globalScope;\n try {\n globalScope = getGlobalScope();\n }\n catch (error) {\n Logger.error(`Error getting global scope: ${error}`);\n if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, names[0].toString(), usageDesc);\n Logger.error(errMsg);\n throw errMsg;\n }\n else if (returnEmptyObject) {\n globalScope = {};\n }\n }\n const result = {};\n for (let i = 0; i < names.length; i++) {\n const name = names[i];\n try {\n if (globalScope) {\n const obj = globalScope[name];\n if (obj) {\n result[name] = obj;\n }\n else if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n Logger.error(errMsg);\n throw new Error(errMsg);\n }\n else if (returnEmptyObject) {\n result[name] = {};\n }\n }\n }\n catch (error) {\n if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n Logger.error(errMsg);\n throw new Error(errMsg);\n }\n }\n }\n return result;\n}\nexport function intToBytes(value, byteLength) {\n return bigIntToBytes(intToBigInt(value), byteLength);\n}\nexport function intToBigInt(value) {\n if (typeof value === 'bigint')\n return value;\n if (typeof value === 'string')\n return BigInt(value);\n if (typeof value === 'number') {\n if (!Number.isInteger(value)) {\n throw new RangeError(`Invalid value. Values of type 'number' must be an integer.`);\n }\n if (value > Number.MAX_SAFE_INTEGER) {\n throw new RangeError(`Invalid value. Values of type 'number' must be less than or equal to ${Number.MAX_SAFE_INTEGER}. For larger values, try using a BigInt instead.`);\n }\n return BigInt(value);\n }\n if (isInstance(value, Uint8Array))\n return BigInt(`0x${bytesToHex(value)}`);\n throw new TypeError(`intToBigInt: Invalid value type. Must be a number, bigint, BigInt-compatible string, or Uint8Array.`);\n}\nexport function with0x(value) {\n return /^0x/i.test(value)\n ? value\n : `0x${value}`;\n}\nexport function without0x(value) {\n return /^0x/i.test(value)\n ? value.slice(2)\n : value;\n}\nexport function hexToBigInt(hex) {\n if (typeof hex !== 'string')\n throw new TypeError(`hexToBigInt: expected string, got ${typeof hex}`);\n return BigInt(`0x${hex}`);\n}\nexport function intToHex(integer, byteLength = 8) {\n const value = typeof integer === 'bigint' ? integer : intToBigInt(integer);\n return value.toString(16).padStart(byteLength * 2, '0');\n}\nexport function hexToInt(hex) {\n return parseInt(hex, 16);\n}\nexport function bigIntToBytes(value, length = 16) {\n const hex = intToHex(value, length);\n return hexToBytes(hex);\n}\nexport function toTwos(value, width) {\n if (value < -(BigInt(1) << (width - BigInt(1))) \|\|\n (BigInt(1) << (width - BigInt(1))) - BigInt(1) < value) {\n throw `Unable to represent integer in width: ${width}`;\n }\n if (value >= BigInt(0)) {\n return BigInt(value);\n }\n return value + (BigInt(1) << width);\n}\nfunction nthBit(value, n) {\n return value & (BigInt(1) << n);\n}\nexport function bytesToTwosBigInt(bytes) {\n return fromTwos(BigInt(`0x${bytesToHex(bytes)}`), BigInt(bytes.byteLength * 8));\n}\nexport function fromTwos(value, width) {\n if (nthBit(value, width - BigInt(1))) {\n return value - (BigInt(1) << width);\n }\n return value;\n}\nconst hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\nexport function bytesToHex(uint8a) {\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Uint8Array expected');\n let hex = '';\n for (const u of uint8a) {\n hex += hexes[u];\n }\n return hex;\n}\nexport function hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError(`hexToBytes: expected string, got ${typeof hex}`);\n }\n hex = without0x(hex);\n hex = hex.length % 2 ? `0${hex}` : hex;\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i * 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\nexport function utf8ToBytes(str) {\n return new TextEncoder().encode(str);\n}\nexport function bytesToUtf8(arr) {\n return new TextDecoder().decode(arr);\n}\nexport function asciiToBytes(str) {\n const byteArray = [];\n for (let i = 0; i < str.length; i++) {\n byteArray.push(str.charCodeAt(i) & 0xff);\n }\n return new Uint8Array(byteArray);\n}\nexport function bytesToAscii(arr) {\n return String.fromCharCode.apply(null, arr);\n}\nfunction isNotOctet(octet) {\n return !Number.isInteger(octet) \|\| octet < 0 \|\| octet > 255;\n}\nexport function octetsToBytes(numbers) {\n if (numbers.some(isNotOctet))\n throw new Error('Some values are invalid bytes.');\n return new Uint8Array(numbers);\n}\nexport function concatBytes(...arrays) {\n if (!arrays.every(a => a instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\nexport function concatArray(elements) {\n return concatBytes(...elements.map(e => {\n if (typeof e === 'number')\n return octetsToBytes([e]);\n if (e instanceof Array)\n return octetsToBytes(e);\n return e;\n }));\n}\nexport function isInstance(object, clazz) {\n return object instanceof clazz \|\| object?.constructor?.name?.toLowerCase() === clazz.name;\n}\nexport function validateHash256(hex) {\n hex = without0x(hex);\n if (hex.length !== 64)\n return false;\n return /^[0-9a-fA-F]+$/.test(hex);\n}\n//# sourceMappingURL=utils.js.map","export const HIRO_MAINNET_URL = 'https://api.mainnet.hiro.so';\nexport const HIRO_TESTNET_URL = 'https://api.testnet.hiro.so';\nexport const DEVNET_URL = 'http://localhost:3999';\nexport const GAIA_URL = 'https://hub.blockstack.org';\nexport const PRIVATE_KEY_BYTES_COMPRESSED = 33;\nexport const PRIVATE_KEY_BYTES_UNCOMPRESSED = 32;\n//# sourceMappingURL=constants.js.map","const defaultFetchOpts = {\n referrerPolicy: 'origin',\n headers: {\n 'x-hiro-product': 'stacksjs',\n },\n};\nexport const getFetchOptions = () => {\n return defaultFetchOpts;\n};\nexport const setFetchOptions = (ops) => {\n return Object.assign(defaultFetchOpts, ops);\n};\nexport async function fetchWrapper(input, init) {\n const fetchOpts = {};\n Object.assign(fetchOpts, defaultFetchOpts, init);\n const fetchResult = await fetch(input, fetchOpts);\n return fetchResult;\n}\nexport function hostMatches(host, pattern) {\n if (typeof pattern === 'string')\n return pattern === host;\n return pattern.exec(host);\n}\nexport function createApiKeyMiddleware({ apiKey, host = /(.)api(.)(\\.stacks\\.co\|\\.hiro\\.so)$/i, httpHeader = 'x-api-key', }) {\n return {\n pre: context => {\n const reqUrl = new URL(context.url);\n if (!hostMatches(reqUrl.host, host))\n return;\n const headers = context.init.headers instanceof Headers\n ? context.init.headers\n : (context.init.headers = new Headers(context.init.headers));\n headers.set(httpHeader, apiKey);\n },\n };\n}\nfunction argsForCreateFetchFn(args) {\n let fetchLib = fetchWrapper;\n let middlewares = [];\n if (args.length > 0 && typeof args[0] === 'function') {\n fetchLib = args.shift();\n }\n if (args.length > 0) {\n middlewares = args;\n }\n return { fetchLib, middlewares };\n}\nexport function createFetchFn(...args) {\n const { fetchLib, middlewares } = argsForCreateFetchFn(args);\n const fetchFn = async (url, init) => {\n let fetchParams = { url, init: init ?? {} };\n for (const middleware of middlewares) {\n if (typeof middleware.pre === 'function') {\n const result = await Promise.resolve(middleware.pre({\n fetch: fetchLib,\n ...fetchParams,\n }));\n fetchParams = result ?? fetchParams;\n }\n }\n let response = await fetchLib(fetchParams.url, fetchParams.init);\n for (const middleware of middlewares) {\n if (typeof middleware.post === 'function') {\n const result = await Promise.resolve(middleware.post({\n fetch: fetchLib,\n url: fetchParams.url,\n init: fetchParams.init,\n response: response?.clone() ?? response,\n }));\n response = result ?? response;\n }\n }\n return response;\n };\n return fetchFn;\n}\n//# sourceMappingURL=fetch.js.map","export var ChainId;\n(function (ChainId) {\n ChainId[ChainId[\"Mainnet\"] = 1] = \"Mainnet\";\n ChainId[ChainId[\"Testnet\"] = 2147483648] = \"Testnet\";\n})(ChainId \|\| (ChainId = {}));\nexport var PeerNetworkId;\n(function (PeerNetworkId) {\n PeerNetworkId[PeerNetworkId[\"Mainnet\"] = 385875968] = \"Mainnet\";\n PeerNetworkId[PeerNetworkId[\"Testnet\"] = 4278190080] = \"Testnet\";\n})(PeerNetworkId \|\| (PeerNetworkId = {}));\nexport const DEFAULT_CHAIN_ID = ChainId.Mainnet;\nexport var TransactionVersion;\n(function (TransactionVersion) {\n TransactionVersion[TransactionVersion[\"Mainnet\"] = 0] = \"Mainnet\";\n TransactionVersion[TransactionVersion[\"Testnet\"] = 128] = \"Testnet\";\n})(TransactionVersion \|\| (TransactionVersion = {}));\nexport var AddressVersion;\n(function (AddressVersion) {\n AddressVersion[AddressVersion[\"MainnetSingleSig\"] = 22] = \"MainnetSingleSig\";\n AddressVersion[AddressVersion[\"MainnetMultiSig\"] = 20] = \"MainnetMultiSig\";\n AddressVersion[AddressVersion[\"TestnetSingleSig\"] = 26] = \"TestnetSingleSig\";\n AddressVersion[AddressVersion[\"TestnetMultiSig\"] = 21] = \"TestnetMultiSig\";\n})(AddressVersion \|\| (AddressVersion = {}));\nexport const DEFAULT_TRANSACTION_VERSION = TransactionVersion.Mainnet;\nexport function whenTransactionVersion(transactionVersion) {\n return (map) => map[transactionVersion];\n}\n//# sourceMappingURL=constants.js.map","import { DEVNET_URL, HIRO_MAINNET_URL, HIRO_TESTNET_URL, createFetchFn, } from '@stacks/common';\nimport { AddressVersion, ChainId, PeerNetworkId, TransactionVersion } from './constants';\nexport const STACKS_MAINNET = {\n chainId: ChainId.Mainnet,\n transactionVersion: TransactionVersion.Mainnet,\n peerNetworkId: PeerNetworkId.Mainnet,\n magicBytes: 'X2',\n bootAddress: 'SP000000000000000000002Q6VF78',\n addressVersion: {\n singleSig: AddressVersion.MainnetSingleSig,\n multiSig: AddressVersion.MainnetMultiSig,\n },\n client: { baseUrl: HIRO_MAINNET_URL },\n};\nexport const STACKS_TESTNET = {\n chainId: ChainId.Testnet,\n transactionVersion: TransactionVersion.Testnet,\n peerNetworkId: PeerNetworkId.Testnet,\n magicBytes: 'T2',\n bootAddress: 'ST000000000000000000002AMW42H',\n addressVersion: {\n singleSig: AddressVersion.TestnetSingleSig,\n multiSig: AddressVersion.TestnetMultiSig,\n },\n client: { baseUrl: HIRO_TESTNET_URL },\n};\nexport const STACKS_DEVNET = {\n ...STACKS_TESTNET,\n addressVersion: { ...STACKS_TESTNET.addressVersion },\n magicBytes: 'id',\n client: { baseUrl: DEVNET_URL },\n};\nexport const STACKS_MOCKNET = {\n ...STACKS_DEVNET,\n addressVersion: { ...STACKS_DEVNET.addressVersion },\n client: { ...STACKS_DEVNET.client },\n};\nexport const StacksNetworks = ['mainnet', 'testnet', 'devnet', 'mocknet'];\nexport function networkFromName(name) {\n switch (name) {\n case 'mainnet':\n return STACKS_MAINNET;\n case 'testnet':\n return STACKS_TESTNET;\n case 'devnet':\n return STACKS_DEVNET;\n case 'mocknet':\n return STACKS_MOCKNET;\n default:\n throw new Error(`Unknown network name: ${name}`);\n }\n}\nexport function networkFrom(network) {\n if (typeof network === 'string')\n return networkFromName(network);\n return network;\n}\nexport function defaultUrlFromNetwork(network) {\n if (!network)\n return HIRO_MAINNET_URL;\n network = networkFrom(network);\n return !network \|\| network.transactionVersion === TransactionVersion.Mainnet\n ? HIRO_MAINNET_URL\n : network.magicBytes === 'id'\n ? DEVNET_URL\n : HIRO_TESTNET_URL;\n}\nexport function clientFromNetwork(network) {\n if (network.client.fetch)\n return network.client;\n return {\n ...network.client,\n fetch: createFetchFn(),\n };\n}\n//# sourceMappingURL=network.js.map","export function equals(a, b) {\n if (a.byteLength !== b.byteLength)\n return false;\n for (let i = 0; i < a.byteLength; i++) {\n if (a[i] !== b[i])\n return false;\n }\n return true;\n}\nexport function alloc(length, value) {\n const a = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n a[i] = value;\n }\n return a;\n}\nexport function readUInt16BE(source, offset) {\n return ((source[offset + 0] << 8) \| source[offset + 1]) >>> 0;\n}\nexport function writeUInt16BE(destination, value, offset = 0) {\n destination[offset + 0] = value >>> 8;\n destination[offset + 1] = value >>> 0;\n return destination;\n}\nexport function readUInt8(source, offset) {\n return source[offset];\n}\nexport function writeUInt8(destination, value, offset = 0) {\n destination[offset] = value;\n return destination;\n}\nexport function readUInt16LE(source, offset) {\n return ((source[offset + 0] << 0) >>> 0) \| ((source[offset + 1] << 8) >>> 0);\n}\nexport function writeUInt16LE(destination, value, offset = 0) {\n destination[offset + 0] = value & 255;\n value >>>= 8;\n destination[offset + 1] = value & 255;\n return destination;\n}\nexport function readUInt32BE(source, offset) {\n return (source[offset] * 2 ** 24 +\n source[offset + 1] * 2 ** 16 +\n source[offset + 2] * 2 ** 8 +\n source[offset + 3]);\n}\nexport function writeUInt32BE(destination, value, offset = 0) {\n destination[offset + 3] = value;\n value >>>= 8;\n destination[offset + 2] = value;\n value >>>= 8;\n destination[offset + 1] = value;\n value >>>= 8;\n destination[offset] = value;\n return destination;\n}\nexport function readUInt32LE(source, offset) {\n return (((source[offset + 0] << 0) >>> 0) \|\n ((source[offset + 1] << 8) >>> 0) \|\n ((source[offset + 2] << 16) >>> 0) \|\n ((source[offset + 3] << 24) >>> 0));\n}\nexport function writeUInt32LE(destination, value, offset = 0) {\n destination[offset + 0] = value & 255;\n value >>>= 8;\n destination[offset + 1] = value & 255;\n value >>>= 8;\n destination[offset + 2] = value & 255;\n value >>>= 8;\n destination[offset + 3] = value & 255;\n return destination;\n}\n//# sourceMappingURL=buffer.js.map","export const BLOCKSTACK_DEFAULT_GAIA_HUB_URL = 'https://hub.blockstack.org';\nexport const MAX_STRING_LENGTH_BYTES = 128;\nexport const CLARITY_INT_SIZE = 128;\nexport const CLARITY_INT_BYTE_SIZE = 16;\nexport const COINBASE_BYTES_LENGTH = 32;\nexport const VRF_PROOF_BYTES_LENGTH = 80;\nexport const RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;\nexport const COMPRESSED_PUBKEY_LENGTH_BYTES = 32;\nexport const UNCOMPRESSED_PUBKEY_LENGTH_BYTES = 64;\nexport const MEMO_MAX_LENGTH_BYTES = 34;\nconst MAX_PAYLOAD_LEN = 1 + 16 * 1024 * 1024;\nconst PREAMBLE_ENCODED_SIZE = 165;\nconst MAX_RELAYERS_LEN = 16;\nconst PEER_ADDRESS_ENCODED_SIZE = 16;\nconst HASH160_ENCODED_SIZE = 20;\nconst NEIGHBOR_ADDRESS_ENCODED_SIZE = PEER_ADDRESS_ENCODED_SIZE + 2 + HASH160_ENCODED_SIZE;\nconst RELAY_DATA_ENCODED_SIZE = NEIGHBOR_ADDRESS_ENCODED_SIZE + 4;\nexport const STRING_MAX_LENGTH = MAX_PAYLOAD_LEN + (PREAMBLE_ENCODED_SIZE + MAX_RELAYERS_LEN * RELAY_DATA_ENCODED_SIZE);\nexport var PayloadType;\n(function (PayloadType) {\n PayloadType[PayloadType[\"TokenTransfer\"] = 0] = \"TokenTransfer\";\n PayloadType[PayloadType[\"SmartContract\"] = 1] = \"SmartContract\";\n PayloadType[PayloadType[\"VersionedSmartContract\"] = 6] = \"VersionedSmartContract\";\n PayloadType[PayloadType[\"ContractCall\"] = 2] = \"ContractCall\";\n PayloadType[PayloadType[\"PoisonMicroblock\"] = 3] = \"PoisonMicroblock\";\n PayloadType[PayloadType[\"Coinbase\"] = 4] = \"Coinbase\";\n PayloadType[PayloadType[\"CoinbaseToAltRecipient\"] = 5] = \"CoinbaseToAltRecipient\";\n PayloadType[PayloadType[\"TenureChange\"] = 7] = \"TenureChange\";\n PayloadType[PayloadType[\"NakamotoCoinbase\"] = 8] = \"NakamotoCoinbase\";\n})(PayloadType \|\| (PayloadType = {}));\nexport var ClarityVersion;\n(function (ClarityVersion) {\n ClarityVersion[ClarityVersion[\"Clarity1\"] = 1] = \"Clarity1\";\n ClarityVersion[ClarityVersion[\"Clarity2\"] = 2] = \"Clarity2\";\n ClarityVersion[ClarityVersion[\"Clarity3\"] = 3] = \"Clarity3\";\n})(ClarityVersion \|\| (ClarityVersion = {}));\nexport var AnchorMode;\n(function (AnchorMode) {\n AnchorMode[AnchorMode[\"OnChainOnly\"] = 1] = \"OnChainOnly\";\n AnchorMode[AnchorMode[\"OffChainOnly\"] = 2] = \"OffChainOnly\";\n AnchorMode[AnchorMode[\"Any\"] = 3] = \"Any\";\n})(AnchorMode \|\| (AnchorMode = {}));\nexport const AnchorModeNames = ['onChainOnly', 'offChainOnly', 'any'];\nconst AnchorModeMap = {\n [AnchorModeNames[0]]: AnchorMode.OnChainOnly,\n [AnchorModeNames[1]]: AnchorMode.OffChainOnly,\n [AnchorModeNames[2]]: AnchorMode.Any,\n [AnchorMode.OnChainOnly]: AnchorMode.OnChainOnly,\n [AnchorMode.OffChainOnly]: AnchorMode.OffChainOnly,\n [AnchorMode.Any]: AnchorMode.Any,\n};\nexport function anchorModeFrom(mode) {\n if (mode in AnchorModeMap)\n return AnchorModeMap[mode];\n throw new Error(`Invalid anchor mode \"${mode}\", must be one of: ${AnchorModeNames.join(', ')}`);\n}\nexport var PostConditionMode;\n(function (PostConditionMode) {\n PostConditionMode[PostConditionMode[\"Allow\"] = 1] = \"Allow\";\n PostConditionMode[PostConditionMode[\"Deny\"] = 2] = \"Deny\";\n})(PostConditionMode \|\| (PostConditionMode = {}));\nexport var PostConditionType;\n(function (PostConditionType) {\n PostConditionType[PostConditionType[\"STX\"] = 0] = \"STX\";\n PostConditionType[PostConditionType[\"Fungible\"] = 1] = \"Fungible\";\n PostConditionType[PostConditionType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(PostConditionType \|\| (PostConditionType = {}));\nexport var AuthType;\n(function (AuthType) {\n AuthType[AuthType[\"Standard\"] = 4] = \"Standard\";\n AuthType[AuthType[\"Sponsored\"] = 5] = \"Sponsored\";\n})(AuthType \|\| (AuthType = {}));\nexport var AddressHashMode;\n(function (AddressHashMode) {\n AddressHashMode[AddressHashMode[\"P2PKH\"] = 0] = \"P2PKH\";\n AddressHashMode[AddressHashMode[\"P2SH\"] = 1] = \"P2SH\";\n AddressHashMode[AddressHashMode[\"P2WPKH\"] = 2] = \"P2WPKH\";\n AddressHashMode[AddressHashMode[\"P2WSH\"] = 3] = \"P2WSH\";\n AddressHashMode[AddressHashMode[\"P2SHNonSequential\"] = 5] = \"P2SHNonSequential\";\n AddressHashMode[AddressHashMode[\"P2WSHNonSequential\"] = 7] = \"P2WSHNonSequential\";\n})(AddressHashMode \|\| (AddressHashMode = {}));\nexport { AddressVersion } from '@stacks/network';\nexport var PubKeyEncoding;\n(function (PubKeyEncoding) {\n PubKeyEncoding[PubKeyEncoding[\"Compressed\"] = 0] = \"Compressed\";\n PubKeyEncoding[PubKeyEncoding[\"Uncompressed\"] = 1] = \"Uncompressed\";\n})(PubKeyEncoding \|\| (PubKeyEncoding = {}));\nexport var FungibleConditionCode;\n(function (FungibleConditionCode) {\n FungibleConditionCode[FungibleConditionCode[\"Equal\"] = 1] = \"Equal\";\n FungibleConditionCode[FungibleConditionCode[\"Greater\"] = 2] = \"Greater\";\n FungibleConditionCode[FungibleConditionCode[\"GreaterEqual\"] = 3] = \"GreaterEqual\";\n FungibleConditionCode[FungibleConditionCode[\"Less\"] = 4] = \"Less\";\n FungibleConditionCode[FungibleConditionCode[\"LessEqual\"] = 5] = \"LessEqual\";\n})(FungibleConditionCode \|\| (FungibleConditionCode = {}));\nexport var NonFungibleConditionCode;\n(function (NonFungibleConditionCode) {\n NonFungibleConditionCode[NonFungibleConditionCode[\"Sends\"] = 16] = \"Sends\";\n NonFungibleConditionCode[NonFungibleConditionCode[\"DoesNotSend\"] = 17] = \"DoesNotSend\";\n})(NonFungibleConditionCode \|\| (NonFungibleConditionCode = {}));\nexport var PostConditionPrincipalId;\n(function (PostConditionPrincipalId) {\n PostConditionPrincipalId[PostConditionPrincipalId[\"Origin\"] = 1] = \"Origin\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Standard\"] = 2] = \"Standard\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Contract\"] = 3] = \"Contract\";\n})(PostConditionPrincipalId \|\| (PostConditionPrincipalId = {}));\nexport var AssetType;\n(function (AssetType) {\n AssetType[AssetType[\"STX\"] = 0] = \"STX\";\n AssetType[AssetType[\"Fungible\"] = 1] = \"Fungible\";\n AssetType[AssetType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(AssetType \|\| (AssetType = {}));\nexport var TenureChangeCause;\n(function (TenureChangeCause) {\n TenureChangeCause[TenureChangeCause[\"BlockFound\"] = 0] = \"BlockFound\";\n TenureChangeCause[TenureChangeCause[\"Extended\"] = 1] = \"Extended\";\n})(TenureChangeCause \|\| (TenureChangeCause = {}));\nexport var AuthFieldType;\n(function (AuthFieldType) {\n AuthFieldType[AuthFieldType[\"PublicKeyCompressed\"] = 0] = \"PublicKeyCompressed\";\n AuthFieldType[AuthFieldType[\"PublicKeyUncompressed\"] = 1] = \"PublicKeyUncompressed\";\n AuthFieldType[AuthFieldType[\"SignatureCompressed\"] = 2] = \"SignatureCompressed\";\n AuthFieldType[AuthFieldType[\"SignatureUncompressed\"] = 3] = \"SignatureUncompressed\";\n})(AuthFieldType \|\| (AuthFieldType = {}));\nexport var TxRejectedReason;\n(function (TxRejectedReason) {\n TxRejectedReason[\"Serialization\"] = \"Serialization\";\n TxRejectedReason[\"Deserialization\"] = \"Deserialization\";\n TxRejectedReason[\"SignatureValidation\"] = \"SignatureValidation\";\n TxRejectedReason[\"FeeTooLow\"] = \"FeeTooLow\";\n TxRejectedReason[\"BadNonce\"] = \"BadNonce\";\n TxRejectedReason[\"NotEnoughFunds\"] = \"NotEnoughFunds\";\n TxRejectedReason[\"NoSuchContract\"] = \"NoSuchContract\";\n TxRejectedReason[\"NoSuchPublicFunction\"] = \"NoSuchPublicFunction\";\n TxRejectedReason[\"BadFunctionArgument\"] = \"BadFunctionArgument\";\n TxRejectedReason[\"ContractAlreadyExists\"] = \"ContractAlreadyExists\";\n TxRejectedReason[\"PoisonMicroblocksDoNotConflict\"] = \"PoisonMicroblocksDoNotConflict\";\n TxRejectedReason[\"PoisonMicroblockHasUnknownPubKeyHash\"] = \"PoisonMicroblockHasUnknownPubKeyHash\";\n TxRejectedReason[\"PoisonMicroblockIsInvalid\"] = \"PoisonMicroblockIsInvalid\";\n TxRejectedReason[\"BadAddressVersionByte\"] = \"BadAddressVersionByte\";\n TxRejectedReason[\"NoCoinbaseViaMempool\"] = \"NoCoinbaseViaMempool\";\n TxRejectedReason[\"ServerFailureNoSuchChainTip\"] = \"ServerFailureNoSuchChainTip\";\n TxRejectedReason[\"ServerFailureDatabase\"] = \"ServerFailureDatabase\";\n TxRejectedReason[\"ServerFailureOther\"] = \"ServerFailureOther\";\n})(TxRejectedReason \|\| (TxRejectedReason = {}));\n//# sourceMappingURL=constants.js.map","class TransactionError extends Error {\n constructor(message) {\n super(message);\n this.message = message;\n this.name = this.constructor.name;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\nexport class SerializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class DeserializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NoEstimateAvailableError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NotImplementedError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class SigningError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class VerificationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\n//# sourceMappingURL=errors.js.map","export function number(n) {\n if (!Number.isSafeInteger(n) \|\| n < 0)\n throw new Error(`Wrong positive integer: ${n}`);\n}\nexport function bool(b) {\n if (typeof b !== 'boolean')\n throw new Error(`Expected boolean, not ${b}`);\n}\nexport function bytes(b, ...lengths) {\n if (!(b instanceof Uint8Array))\n throw new TypeError('Expected Uint8Array');\n if (lengths.length > 0 && !lengths.includes(b.length))\n throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexport function hash(hash) {\n if (typeof hash !== 'function' \|\| typeof hash.create !== 'function')\n throw new Error('Hash should be wrapped by utils.wrapConstructor');\n number(hash.outputLen);\n number(hash.blockLen);\n}\nexport function exists(instance, checkFinished = true) {\n if (instance.destroyed)\n throw new Error('Hash instance has been destroyed');\n if (checkFinished && instance.finished)\n throw new Error('Hash#digest() has already been called');\n}\nexport function output(out, instance) {\n bytes(out);\n const min = instance.outputLen;\n if (out.length < min) {\n throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n }\n}\nconst assert = {\n number,\n bool,\n bytes,\n hash,\n exists,\n output,\n};\nexport default assert;\n","/! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) /\n// The import here is via the package name. This is to ensure\n// that exports mapping/resolution does fall into place.\nimport { crypto } from '@noble/hashes/crypto';\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) \| (word >>> shift);\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\n// So, just to be sure not to corrupt anything.\nif (!isLE)\n throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/*\n @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\n /\nexport function bytesToHex(uint8a) {\n // pre-caching improves the speed 6x\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Uint8Array expected');\n let hex = '';\n for (let i = 0; i < uint8a.length; i++) {\n hex += hexes[uint8a[i]];\n }\n return hex;\n}\n/\n @example hexToBytes('deadbeef')\n /\nexport function hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n }\n if (hex.length % 2)\n throw new Error('hexToBytes: received invalid unpadded hex');\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n let ts = Date.now();\n for (let i = 0; i < iters; i++) {\n cb(i);\n // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n const diff = Date.now() - ts;\n if (diff >= 0 && diff < tick)\n continue;\n await nextTick();\n ts += diff;\n }\n}\nexport function utf8ToBytes(str) {\n if (typeof str !== 'string') {\n throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\n }\n return new TextEncoder().encode(str);\n}\nexport function toBytes(data) {\n if (typeof data === 'string')\n data = utf8ToBytes(data);\n if (!(data instanceof Uint8Array))\n throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\n return data;\n}\n/*\n Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\n * @example concatBytes(buf1, buf2)\n /\nexport function concatBytes(...arrays) {\n if (!arrays.every((a) => a instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\n// For runtime check if class implements interface\nexport class Hash {\n // Safe version that clones internal state\n clone() {\n return this._cloneInto();\n }\n}\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nexport function checkOpts(defaults, opts) {\n if (opts !== undefined && (typeof opts !== 'object' \|\| !isPlainObject(opts)))\n throw new TypeError('Options should be object or undefined');\n const merged = Object.assign(defaults, opts);\n return merged;\n}\nexport function wrapConstructor(hashConstructor) {\n const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\n const tmp = hashConstructor();\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = () => hashConstructor();\n return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n const tmp = hashCons({});\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = (opts) => hashCons(opts);\n return hashC;\n}\n/\n Secure PRNG\n /\nexport function randomBytes(bytesLength = 32) {\n if (crypto.web) {\n return crypto.web.getRandomValues(new Uint8Array(bytesLength));\n }\n else if (crypto.node) {\n return new Uint8Array(crypto.node.randomBytes(bytesLength).buffer);\n }\n else {\n throw new Error(\"The environment doesn't have randomBytes function\");\n }\n}\n","export const crypto = {\n node: undefined,\n web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\n","import assert from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nclass HMAC extends Hash {\n constructor(hash, _key) {\n super();\n this.finished = false;\n this.destroyed = false;\n assert.hash(hash);\n const key = toBytes(_key);\n this.iHash = hash.create();\n if (typeof this.iHash.update !== 'function')\n throw new TypeError('Expected instance of class which extends utils.Hash');\n this.blockLen = this.iHash.blockLen;\n this.outputLen = this.iHash.outputLen;\n const blockLen = this.blockLen;\n const pad = new Uint8Array(blockLen);\n // blockLen can be bigger than outputLen\n pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n for (let i = 0; i < pad.length; i++)\n pad[i] ^= 0x36;\n this.iHash.update(pad);\n // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n this.oHash = hash.create();\n // Undo internal XOR && apply outer XOR\n for (let i = 0; i < pad.length; i++)\n pad[i] ^= 0x36 ^ 0x5c;\n this.oHash.update(pad);\n pad.fill(0);\n }\n update(buf) {\n assert.exists(this);\n this.iHash.update(buf);\n return this;\n }\n digestInto(out) {\n assert.exists(this);\n assert.bytes(out, this.outputLen);\n this.finished = true;\n this.iHash.digestInto(out);\n this.oHash.update(out);\n this.oHash.digestInto(out);\n this.destroy();\n }\n digest() {\n const out = new Uint8Array(this.oHash.outputLen);\n this.digestInto(out);\n return out;\n }\n _cloneInto(to) {\n // Create new instance without calling constructor since key already in state and we don't know it.\n to \|\| (to = Object.create(Object.getPrototypeOf(this), {}));\n const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n to = to;\n to.finished = finished;\n to.destroyed = destroyed;\n to.blockLen = blockLen;\n to.outputLen = outputLen;\n to.oHash = oHash._cloneInto(to.oHash);\n to.iHash = iHash._cloneInto(to.iHash);\n return to;\n }\n destroy() {\n this.destroyed = true;\n this.oHash.destroy();\n this.iHash.destroy();\n }\n}\n/\n HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n /\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n","import assert from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n if (typeof view.setBigUint64 === 'function')\n return view.setBigUint64(byteOffset, value, isLE);\n const _32n = BigInt(32);\n const _u32_max = BigInt(0xffffffff);\n const wh = Number((value >> _32n) & _u32_max);\n const wl = Number(value & _u32_max);\n const h = isLE ? 4 : 0;\n const l = isLE ? 0 : 4;\n view.setUint32(byteOffset + h, wh, isLE);\n view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n constructor(blockLen, outputLen, padOffset, isLE) {\n super();\n this.blockLen = blockLen;\n this.outputLen = outputLen;\n this.padOffset = padOffset;\n this.isLE = isLE;\n this.finished = false;\n this.length = 0;\n this.pos = 0;\n this.destroyed = false;\n this.buffer = new Uint8Array(blockLen);\n this.view = createView(this.buffer);\n }\n update(data) {\n assert.exists(this);\n const { view, buffer, blockLen } = this;\n data = toBytes(data);\n const len = data.length;\n for (let pos = 0; pos < len;) {\n const take = Math.min(blockLen - this.pos, len - pos);\n // Fast path: we have at least one block in input, cast it to view and process\n if (take === blockLen) {\n const dataView = createView(data);\n for (; blockLen <= len - pos; pos += blockLen)\n this.process(dataView, pos);\n continue;\n }\n buffer.set(data.subarray(pos, pos + take), this.pos);\n this.pos += take;\n pos += take;\n if (this.pos === blockLen) {\n this.process(view, 0);\n this.pos = 0;\n }\n }\n this.length += data.length;\n this.roundClean();\n return this;\n }\n digestInto(out) {\n assert.exists(this);\n assert.output(out, this);\n this.finished = true;\n // Padding\n // We can avoid allocation of buffer for padding completely if it\n // was previously not allocated here. But it won't change performance.\n const { buffer, view, blockLen, isLE } = this;\n let { pos } = this;\n // append the bit '1' to the message\n buffer[pos++] = 0b10000000;\n this.buffer.subarray(pos).fill(0);\n // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n if (this.padOffset > blockLen - pos) {\n this.process(view, 0);\n pos = 0;\n }\n // Pad until full block byte with zeros\n for (let i = pos; i < blockLen; i++)\n buffer[i] = 0;\n // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n // You need to write around 2 exabytes (u64_max / 8 / (10246)) for this to happen.\n // So we just write lowest 64 bits of that value.\n setBigUint64(view, blockLen - 8, BigInt(this.length 8), isLE);\n this.process(view, 0);\n const oview = createView(out);\n const len = this.outputLen;\n // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n if (len % 4)\n throw new Error('_sha2: outputLen should be aligned to 32bit');\n const outLen = len / 4;\n const state = this.get();\n if (outLen > state.length)\n throw new Error('_sha2: outputLen bigger than state');\n for (let i = 0; i < outLen; i++)\n oview.setUint32(4 * i, state[i], isLE);\n }\n digest() {\n const { buffer, outputLen } = this;\n this.digestInto(buffer);\n const res = buffer.slice(0, outputLen);\n this.destroy();\n return res;\n }\n _cloneInto(to) {\n to \|\| (to = new this.constructor());\n to.set(...this.get());\n const { blockLen, buffer, length, finished, destroyed, pos } = this;\n to.length = length;\n to.pos = pos;\n to.finished = finished;\n to.destroyed = destroyed;\n if (length % blockLen)\n to.buffer.set(buffer);\n return to;\n }\n}\n","import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends SHA2 {\n constructor() {\n super(64, 32, 8, false);\n // We cannot use array here since array allows indexing by variable\n // which means optimizer/compiler cannot use registers.\n this.A = IV[0] \| 0;\n this.B = IV[1] \| 0;\n this.C = IV[2] \| 0;\n this.D = IV[3] \| 0;\n this.E = IV[4] \| 0;\n this.F = IV[5] \| 0;\n this.G = IV[6] \| 0;\n this.H = IV[7] \| 0;\n }\n get() {\n const { A, B, C, D, E, F, G, H } = this;\n return [A, B, C, D, E, F, G, H];\n }\n // prettier-ignore\n set(A, B, C, D, E, F, G, H) {\n this.A = A \| 0;\n this.B = B \| 0;\n this.C = C \| 0;\n this.D = D \| 0;\n this.E = E \| 0;\n this.F = F \| 0;\n this.G = G \| 0;\n this.H = H \| 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4)\n SHA256_W[i] = view.getUint32(offset, false);\n for (let i = 16; i < 64; i++) {\n const W15 = SHA256_W[i - 15];\n const W2 = SHA256_W[i - 2];\n const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) \| 0;\n }\n // Compression function main loop, 64 rounds\n let { A, B, C, D, E, F, G, H } = this;\n for (let i = 0; i < 64; i++) {\n const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) \| 0;\n const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n const T2 = (sigma0 + Maj(A, B, C)) \| 0;\n H = G;\n G = F;\n F = E;\n E = (D + T1) \| 0;\n D = C;\n C = B;\n B = A;\n A = (T1 + T2) \| 0;\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) \| 0;\n B = (B + this.B) \| 0;\n C = (C + this.C) \| 0;\n D = (D + this.D) \| 0;\n E = (E + this.E) \| 0;\n F = (F + this.F) \| 0;\n G = (G + this.G) \| 0;\n H = (H + this.H) \| 0;\n this.set(A, B, C, D, E, F, G, H);\n }\n roundClean() {\n SHA256_W.fill(0);\n }\n destroy() {\n this.set(0, 0, 0, 0, 0, 0, 0, 0);\n this.buffer.fill(0);\n }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n constructor() {\n super();\n this.A = 0xc1059ed8 \| 0;\n this.B = 0x367cd507 \| 0;\n this.C = 0x3070dd17 \| 0;\n this.D = 0xf70e5939 \| 0;\n this.E = 0xffc00b31 \| 0;\n this.F = 0x68581511 \| 0;\n this.G = 0x64f98fa7 \| 0;\n this.H = 0xbefa4fa4 \| 0;\n this.outputLen = 28;\n }\n}\n/*\n SHA2-256 hash function\n * @param message - data that would be hashed\n /\nexport const sha256 = wrapConstructor(() => new SHA256());\nexport const sha224 = wrapConstructor(() => new SHA224());\n","/! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) /\nimport as nodeCrypto from 'crypto';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst _3n = BigInt(3);\nconst _8n = BigInt(8);\nconst CURVE = Object.freeze({\n a: _0n,\n b: BigInt(7),\n P: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\n n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\n h: _1n,\n Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n});\nconst divNearest = (a, b) => (a + b / _2n) / b;\nconst endo = {\n beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n splitScalar(k) {\n const { n } = CURVE;\n const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n const b2 = a1;\n const POW_2_128 = BigInt('0x100000000000000000000000000000000');\n const c1 = divNearest(b2 * k, n);\n const c2 = divNearest(-b1 * k, n);\n let k1 = mod(k - c1 * a1 - c2 * a2, n);\n let k2 = mod(-c1 * b1 - c2 * b2, n);\n const k1neg = k1 > POW_2_128;\n const k2neg = k2 > POW_2_128;\n if (k1neg)\n k1 = n - k1;\n if (k2neg)\n k2 = n - k2;\n if (k1 > POW_2_128 \|\| k2 > POW_2_128) {\n throw new Error('splitScalarEndo: Endomorphism failed, k=' + k);\n }\n return { k1neg, k1, k2neg, k2 };\n },\n};\nconst fieldLen = 32;\nconst groupLen = 32;\nconst hashLen = 32;\nconst compressedLen = fieldLen + 1;\nconst uncompressedLen = 2 * fieldLen + 1;\nexport { CURVE };\nfunction weierstrass(x) {\n const { a, b } = CURVE;\n const x2 = mod(x * x);\n const x3 = mod(x2 * x);\n return mod(x3 + a * x + b);\n}\nconst USE_ENDOMORPHISM = CURVE.a === _0n;\nclass ShaError extends Error {\n constructor(message) {\n super(message);\n }\n}\nfunction assertJacPoint(other) {\n if (!(other instanceof JacobianPoint))\n throw new TypeError('JacobianPoint expected');\n}\nclass JacobianPoint {\n constructor(x, y, z) {\n this.x = x;\n this.y = y;\n this.z = z;\n }\n static fromAffine(p) {\n if (!(p instanceof Point)) {\n throw new TypeError('JacobianPoint#fromAffine: expected Point');\n }\n if (p.equals(Point.ZERO))\n return JacobianPoint.ZERO;\n return new JacobianPoint(p.x, p.y, _1n);\n }\n static toAffineBatch(points) {\n const toInv = invertBatch(points.map((p) => p.z));\n return points.map((p, i) => p.toAffine(toInv[i]));\n }\n static normalizeZ(points) {\n return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine);\n }\n equals(other) {\n assertJacPoint(other);\n const { x: X1, y: Y1, z: Z1 } = this;\n const { x: X2, y: Y2, z: Z2 } = other;\n const Z1Z1 = mod(Z1 * Z1);\n const Z2Z2 = mod(Z2 * Z2);\n const U1 = mod(X1 * Z2Z2);\n const U2 = mod(X2 * Z1Z1);\n const S1 = mod(mod(Y1 * Z2) * Z2Z2);\n const S2 = mod(mod(Y2 * Z1) * Z1Z1);\n return U1 === U2 && S1 === S2;\n }\n negate() {\n return new JacobianPoint(this.x, mod(-this.y), this.z);\n }\n double() {\n const { x: X1, y: Y1, z: Z1 } = this;\n const A = mod(X1 * X1);\n const B = mod(Y1 * Y1);\n const C = mod(B * B);\n const x1b = X1 + B;\n const D = mod(_2n * (mod(x1b * x1b) - A - C));\n const E = mod(_3n * A);\n const F = mod(E * E);\n const X3 = mod(F - _2n * D);\n const Y3 = mod(E * (D - X3) - _8n * C);\n const Z3 = mod(_2n * Y1 * Z1);\n return new JacobianPoint(X3, Y3, Z3);\n }\n add(other) {\n assertJacPoint(other);\n const { x: X1, y: Y1, z: Z1 } = this;\n const { x: X2, y: Y2, z: Z2 } = other;\n if (X2 === _0n \|\| Y2 === _0n)\n return this;\n if (X1 === _0n \|\| Y1 === _0n)\n return other;\n const Z1Z1 = mod(Z1 * Z1);\n const Z2Z2 = mod(Z2 * Z2);\n const U1 = mod(X1 * Z2Z2);\n const U2 = mod(X2 * Z1Z1);\n const S1 = mod(mod(Y1 * Z2) * Z2Z2);\n const S2 = mod(mod(Y2 * Z1) * Z1Z1);\n const H = mod(U2 - U1);\n const r = mod(S2 - S1);\n if (H === _0n) {\n if (r === _0n) {\n return this.double();\n }\n else {\n return JacobianPoint.ZERO;\n }\n }\n const HH = mod(H * H);\n const HHH = mod(H * HH);\n const V = mod(U1 * HH);\n const X3 = mod(r * r - HHH - _2n * V);\n const Y3 = mod(r * (V - X3) - S1 * HHH);\n const Z3 = mod(Z1 * Z2 * H);\n return new JacobianPoint(X3, Y3, Z3);\n }\n subtract(other) {\n return this.add(other.negate());\n }\n multiplyUnsafe(scalar) {\n const P0 = JacobianPoint.ZERO;\n if (typeof scalar === 'bigint' && scalar === _0n)\n return P0;\n let n = normalizeScalar(scalar);\n if (n === _1n)\n return this;\n if (!USE_ENDOMORPHISM) {\n let p = P0;\n let d = this;\n while (n > _0n) {\n if (n & _1n)\n p = p.add(d);\n d = d.double();\n n >>= _1n;\n }\n return p;\n }\n let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n let k1p = P0;\n let k2p = P0;\n let d = this;\n while (k1 > _0n \|\| k2 > _0n) {\n if (k1 & _1n)\n k1p = k1p.add(d);\n if (k2 & _1n)\n k2p = k2p.add(d);\n d = d.double();\n k1 >>= _1n;\n k2 >>= _1n;\n }\n if (k1neg)\n k1p = k1p.negate();\n if (k2neg)\n k2p = k2p.negate();\n k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);\n return k1p.add(k2p);\n }\n precomputeWindow(W) {\n const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1;\n const points = [];\n let p = this;\n let base = p;\n for (let window = 0; window < windows; window++) {\n base = p;\n points.push(base);\n for (let i = 1; i < 2 (W - 1); i++) {\n base = base.add(p);\n points.push(base);\n }\n p = base.double();\n }\n return points;\n }\n wNAF(n, affinePoint) {\n if (!affinePoint && this.equals(JacobianPoint.BASE))\n affinePoint = Point.BASE;\n const W = (affinePoint && affinePoint._WINDOW_SIZE) \|\| 1;\n if (256 % W) {\n throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');\n }\n let precomputes = affinePoint && pointPrecomputes.get(affinePoint);\n if (!precomputes) {\n precomputes = this.precomputeWindow(W);\n if (affinePoint && W !== 1) {\n precomputes = JacobianPoint.normalizeZ(precomputes);\n pointPrecomputes.set(affinePoint, precomputes);\n }\n }\n let p = JacobianPoint.ZERO;\n let f = JacobianPoint.BASE;\n const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W);\n const windowSize = 2 (W - 1);\n const mask = BigInt(2 W - 1);\n const maxNumber = 2 W;\n const shiftBy = BigInt(W);\n for (let window = 0; window < windows; window++) {\n const offset = window * windowSize;\n let wbits = Number(n & mask);\n n >>= shiftBy;\n if (wbits > windowSize) {\n wbits -= maxNumber;\n n += _1n;\n }\n const offset1 = offset;\n const offset2 = offset + Math.abs(wbits) - 1;\n const cond1 = window % 2 !== 0;\n const cond2 = wbits < 0;\n if (wbits === 0) {\n f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n }\n else {\n p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n }\n }\n return { p, f };\n }\n multiply(scalar, affinePoint) {\n let n = normalizeScalar(scalar);\n let point;\n let fake;\n if (USE_ENDOMORPHISM) {\n const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);\n let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);\n k1p = constTimeNegate(k1neg, k1p);\n k2p = constTimeNegate(k2neg, k2p);\n k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);\n point = k1p.add(k2p);\n fake = f1p.add(f2p);\n }\n else {\n const { p, f } = this.wNAF(n, affinePoint);\n point = p;\n fake = f;\n }\n return JacobianPoint.normalizeZ([point, fake])[0];\n }\n toAffine(invZ) {\n const { x, y, z } = this;\n const is0 = this.equals(JacobianPoint.ZERO);\n if (invZ == null)\n invZ = is0 ? _8n : invert(z);\n const iz1 = invZ;\n const iz2 = mod(iz1 * iz1);\n const iz3 = mod(iz2 * iz1);\n const ax = mod(x * iz2);\n const ay = mod(y * iz3);\n const zz = mod(z * iz1);\n if (is0)\n return Point.ZERO;\n if (zz !== _1n)\n throw new Error('invZ was invalid');\n return new Point(ax, ay);\n }\n}\nJacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);\nJacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);\nfunction constTimeNegate(condition, item) {\n const neg = item.negate();\n return condition ? neg : item;\n}\nconst pointPrecomputes = new WeakMap();\nexport class Point {\n constructor(x, y) {\n this.x = x;\n this.y = y;\n }\n _setWindowSize(windowSize) {\n this._WINDOW_SIZE = windowSize;\n pointPrecomputes.delete(this);\n }\n hasEvenY() {\n return this.y % _2n === _0n;\n }\n static fromCompressedHex(bytes) {\n const isShort = bytes.length === 32;\n const x = bytesToNumber(isShort ? bytes : bytes.subarray(1));\n if (!isValidFieldElement(x))\n throw new Error('Point is not on curve');\n const y2 = weierstrass(x);\n let y = sqrtMod(y2);\n const isYOdd = (y & _1n) === _1n;\n if (isShort) {\n if (isYOdd)\n y = mod(-y);\n }\n else {\n const isFirstByteOdd = (bytes[0] & 1) === 1;\n if (isFirstByteOdd !== isYOdd)\n y = mod(-y);\n }\n const point = new Point(x, y);\n point.assertValidity();\n return point;\n }\n static fromUncompressedHex(bytes) {\n const x = bytesToNumber(bytes.subarray(1, fieldLen + 1));\n const y = bytesToNumber(bytes.subarray(fieldLen + 1, fieldLen * 2 + 1));\n const point = new Point(x, y);\n point.assertValidity();\n return point;\n }\n static fromHex(hex) {\n const bytes = ensureBytes(hex);\n const len = bytes.length;\n const header = bytes[0];\n if (len === fieldLen)\n return this.fromCompressedHex(bytes);\n if (len === compressedLen && (header === 0x02 \|\| header === 0x03)) {\n return this.fromCompressedHex(bytes);\n }\n if (len === uncompressedLen && header === 0x04)\n return this.fromUncompressedHex(bytes);\n throw new Error(`Point.fromHex: received invalid point. Expected 32-${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes, not ${len}`);\n }\n static fromPrivateKey(privateKey) {\n return Point.BASE.multiply(normalizePrivateKey(privateKey));\n }\n static fromSignature(msgHash, signature, recovery) {\n const { r, s } = normalizeSignature(signature);\n if (![0, 1, 2, 3].includes(recovery))\n throw new Error('Cannot recover: invalid recovery bit');\n const h = truncateHash(ensureBytes(msgHash));\n const { n } = CURVE;\n const radj = recovery === 2 \|\| recovery === 3 ? r + n : r;\n const rinv = invert(radj, n);\n const u1 = mod(-h * rinv, n);\n const u2 = mod(s * rinv, n);\n const prefix = recovery & 1 ? '03' : '02';\n const R = Point.fromHex(prefix + numTo32bStr(radj));\n const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);\n if (!Q)\n throw new Error('Cannot recover signature: point at infinify');\n Q.assertValidity();\n return Q;\n }\n toRawBytes(isCompressed = false) {\n return hexToBytes(this.toHex(isCompressed));\n }\n toHex(isCompressed = false) {\n const x = numTo32bStr(this.x);\n if (isCompressed) {\n const prefix = this.hasEvenY() ? '02' : '03';\n return `${prefix}${x}`;\n }\n else {\n return `04${x}${numTo32bStr(this.y)}`;\n }\n }\n toHexX() {\n return this.toHex(true).slice(2);\n }\n toRawX() {\n return this.toRawBytes(true).slice(1);\n }\n assertValidity() {\n const msg = 'Point is not on elliptic curve';\n const { x, y } = this;\n if (!isValidFieldElement(x) \|\| !isValidFieldElement(y))\n throw new Error(msg);\n const left = mod(y * y);\n const right = weierstrass(x);\n if (mod(left - right) !== _0n)\n throw new Error(msg);\n }\n equals(other) {\n return this.x === other.x && this.y === other.y;\n }\n negate() {\n return new Point(this.x, mod(-this.y));\n }\n double() {\n return JacobianPoint.fromAffine(this).double().toAffine();\n }\n add(other) {\n return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine();\n }\n subtract(other) {\n return this.add(other.negate());\n }\n multiply(scalar) {\n return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine();\n }\n multiplyAndAddUnsafe(Q, a, b) {\n const P = JacobianPoint.fromAffine(this);\n const aP = a === _0n \|\| a === _1n \|\| this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);\n const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);\n const sum = aP.add(bQ);\n return sum.equals(JacobianPoint.ZERO) ? undefined : sum.toAffine();\n }\n}\nPoint.BASE = new Point(CURVE.Gx, CURVE.Gy);\nPoint.ZERO = new Point(_0n, _0n);\nfunction sliceDER(s) {\n return Number.parseInt(s[0], 16) >= 8 ? '00' + s : s;\n}\nfunction parseDERInt(data) {\n if (data.length < 2 \|\| data[0] !== 0x02) {\n throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);\n }\n const len = data[1];\n const res = data.subarray(2, len + 2);\n if (!len \|\| res.length !== len) {\n throw new Error(`Invalid signature integer: wrong length`);\n }\n if (res[0] === 0x00 && res[1] <= 0x7f) {\n throw new Error('Invalid signature integer: trailing length');\n }\n return { data: bytesToNumber(res), left: data.subarray(len + 2) };\n}\nfunction parseDERSignature(data) {\n if (data.length < 2 \|\| data[0] != 0x30) {\n throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);\n }\n if (data[1] !== data.length - 2) {\n throw new Error('Invalid signature: incorrect length');\n }\n const { data: r, left: sBytes } = parseDERInt(data.subarray(2));\n const { data: s, left: rBytesLeft } = parseDERInt(sBytes);\n if (rBytesLeft.length) {\n throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);\n }\n return { r, s };\n}\nexport class Signature {\n constructor(r, s) {\n this.r = r;\n this.s = s;\n this.assertValidity();\n }\n static fromCompact(hex) {\n const arr = hex instanceof Uint8Array;\n const name = 'Signature.fromCompact';\n if (typeof hex !== 'string' && !arr)\n throw new TypeError(`${name}: Expected string or Uint8Array`);\n const str = arr ? bytesToHex(hex) : hex;\n if (str.length !== 128)\n throw new Error(`${name}: Expected 64-byte hex`);\n return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));\n }\n static fromDER(hex) {\n const arr = hex instanceof Uint8Array;\n if (typeof hex !== 'string' && !arr)\n throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);\n const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));\n return new Signature(r, s);\n }\n static fromHex(hex) {\n return this.fromDER(hex);\n }\n assertValidity() {\n const { r, s } = this;\n if (!isWithinCurveOrder(r))\n throw new Error('Invalid Signature: r must be 0 < r < n');\n if (!isWithinCurveOrder(s))\n throw new Error('Invalid Signature: s must be 0 < s < n');\n }\n hasHighS() {\n const HALF = CURVE.n >> _1n;\n return this.s > HALF;\n }\n normalizeS() {\n return this.hasHighS() ? new Signature(this.r, mod(-this.s, CURVE.n)) : this;\n }\n toDERRawBytes() {\n return hexToBytes(this.toDERHex());\n }\n toDERHex() {\n const sHex = sliceDER(numberToHexUnpadded(this.s));\n const rHex = sliceDER(numberToHexUnpadded(this.r));\n const sHexL = sHex.length / 2;\n const rHexL = rHex.length / 2;\n const sLen = numberToHexUnpadded(sHexL);\n const rLen = numberToHexUnpadded(rHexL);\n const length = numberToHexUnpadded(rHexL + sHexL + 4);\n return `30${length}02${rLen}${rHex}02${sLen}${sHex}`;\n }\n toRawBytes() {\n return this.toDERRawBytes();\n }\n toHex() {\n return this.toDERHex();\n }\n toCompactRawBytes() {\n return hexToBytes(this.toCompactHex());\n }\n toCompactHex() {\n return numTo32bStr(this.r) + numTo32bStr(this.s);\n }\n}\nfunction concatBytes(...arrays) {\n if (!arrays.every((b) => b instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\nfunction bytesToHex(uint8a) {\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Expected Uint8Array');\n let hex = '';\n for (let i = 0; i < uint8a.length; i++) {\n hex += hexes[uint8a[i]];\n }\n return hex;\n}\nconst POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');\nfunction numTo32bStr(num) {\n if (typeof num !== 'bigint')\n throw new Error('Expected bigint');\n if (!(_0n <= num && num < POW_2_256))\n throw new Error('Expected number 0 <= n < 2^256');\n return num.toString(16).padStart(64, '0');\n}\nfunction numTo32b(num) {\n const b = hexToBytes(numTo32bStr(num));\n if (b.length !== 32)\n throw new Error('Error: expected 32 bytes');\n return b;\n}\nfunction numberToHexUnpadded(num) {\n const hex = num.toString(16);\n return hex.length & 1 ? `0${hex}` : hex;\n}\nfunction hexToNumber(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToNumber: expected string, got ' + typeof hex);\n }\n return BigInt(`0x${hex}`);\n}\nfunction hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n }\n if (hex.length % 2)\n throw new Error('hexToBytes: received invalid unpadded hex' + hex.length);\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i * 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\nfunction bytesToNumber(bytes) {\n return hexToNumber(bytesToHex(bytes));\n}\nfunction ensureBytes(hex) {\n return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);\n}\nfunction normalizeScalar(num) {\n if (typeof num === 'number' && Number.isSafeInteger(num) && num > 0)\n return BigInt(num);\n if (typeof num === 'bigint' && isWithinCurveOrder(num))\n return num;\n throw new TypeError('Expected valid private scalar: 0 < scalar < curve.n');\n}\nfunction mod(a, b = CURVE.P) {\n const result = a % b;\n return result >= _0n ? result : b + result;\n}\nfunction pow2(x, power) {\n const { P } = CURVE;\n let res = x;\n while (power-- > _0n) {\n res = res;\n res %= P;\n }\n return res;\n}\nfunction sqrtMod(x) {\n const { P } = CURVE;\n const _6n = BigInt(6);\n const _11n = BigInt(11);\n const _22n = BigInt(22);\n const _23n = BigInt(23);\n const _44n = BigInt(44);\n const _88n = BigInt(88);\n const b2 = (x x * x) % P;\n const b3 = (b2 * b2 * x) % P;\n const b6 = (pow2(b3, _3n) * b3) % P;\n const b9 = (pow2(b6, _3n) * b3) % P;\n const b11 = (pow2(b9, _2n) * b2) % P;\n const b22 = (pow2(b11, _11n) * b11) % P;\n const b44 = (pow2(b22, _22n) * b22) % P;\n const b88 = (pow2(b44, _44n) * b44) % P;\n const b176 = (pow2(b88, _88n) * b88) % P;\n const b220 = (pow2(b176, _44n) * b44) % P;\n const b223 = (pow2(b220, _3n) * b3) % P;\n const t1 = (pow2(b223, _23n) * b22) % P;\n const t2 = (pow2(t1, _6n) * b2) % P;\n const rt = pow2(t2, _2n);\n const xc = (rt * rt) % P;\n if (xc !== x)\n throw new Error('Cannot find square root');\n return rt;\n}\nfunction invert(number, modulo = CURVE.P) {\n if (number === _0n \|\| modulo <= _0n) {\n throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n }\n let a = mod(number, modulo);\n let b = modulo;\n let x = _0n, y = _1n, u = _1n, v = _0n;\n while (a !== _0n) {\n const q = b / a;\n const r = b % a;\n const m = x - u * q;\n const n = y - v * q;\n b = a, a = r, x = u, y = v, u = m, v = n;\n }\n const gcd = b;\n if (gcd !== _1n)\n throw new Error('invert: does not exist');\n return mod(x, modulo);\n}\nfunction invertBatch(nums, p = CURVE.P) {\n const scratch = new Array(nums.length);\n const lastMultiplied = nums.reduce((acc, num, i) => {\n if (num === _0n)\n return acc;\n scratch[i] = acc;\n return mod(acc * num, p);\n }, _1n);\n const inverted = invert(lastMultiplied, p);\n nums.reduceRight((acc, num, i) => {\n if (num === _0n)\n return acc;\n scratch[i] = mod(acc * scratch[i], p);\n return mod(acc * num, p);\n }, inverted);\n return scratch;\n}\nfunction bits2int_2(bytes) {\n const delta = bytes.length * 8 - groupLen * 8;\n const num = bytesToNumber(bytes);\n return delta > 0 ? num >> BigInt(delta) : num;\n}\nfunction truncateHash(hash, truncateOnly = false) {\n const h = bits2int_2(hash);\n if (truncateOnly)\n return h;\n const { n } = CURVE;\n return h >= n ? h - n : h;\n}\nlet _sha256Sync;\nlet _hmacSha256Sync;\nclass HmacDrbg {\n constructor(hashLen, qByteLen) {\n this.hashLen = hashLen;\n this.qByteLen = qByteLen;\n if (typeof hashLen !== 'number' \|\| hashLen < 2)\n throw new Error('hashLen must be a number');\n if (typeof qByteLen !== 'number' \|\| qByteLen < 2)\n throw new Error('qByteLen must be a number');\n this.v = new Uint8Array(hashLen).fill(1);\n this.k = new Uint8Array(hashLen).fill(0);\n this.counter = 0;\n }\n hmac(...values) {\n return utils.hmacSha256(this.k, ...values);\n }\n hmacSync(...values) {\n return _hmacSha256Sync(this.k, ...values);\n }\n checkSync() {\n if (typeof _hmacSha256Sync !== 'function')\n throw new ShaError('hmacSha256Sync needs to be set');\n }\n incr() {\n if (this.counter >= 1000)\n throw new Error('Tried 1,000 k values for sign(), all were invalid');\n this.counter += 1;\n }\n async reseed(seed = new Uint8Array()) {\n this.k = await this.hmac(this.v, Uint8Array.from([0x00]), seed);\n this.v = await this.hmac(this.v);\n if (seed.length === 0)\n return;\n this.k = await this.hmac(this.v, Uint8Array.from([0x01]), seed);\n this.v = await this.hmac(this.v);\n }\n reseedSync(seed = new Uint8Array()) {\n this.checkSync();\n this.k = this.hmacSync(this.v, Uint8Array.from([0x00]), seed);\n this.v = this.hmacSync(this.v);\n if (seed.length === 0)\n return;\n this.k = this.hmacSync(this.v, Uint8Array.from([0x01]), seed);\n this.v = this.hmacSync(this.v);\n }\n async generate() {\n this.incr();\n let len = 0;\n const out = [];\n while (len < this.qByteLen) {\n this.v = await this.hmac(this.v);\n const sl = this.v.slice();\n out.push(sl);\n len += this.v.length;\n }\n return concatBytes(...out);\n }\n generateSync() {\n this.checkSync();\n this.incr();\n let len = 0;\n const out = [];\n while (len < this.qByteLen) {\n this.v = this.hmacSync(this.v);\n const sl = this.v.slice();\n out.push(sl);\n len += this.v.length;\n }\n return concatBytes(...out);\n }\n}\nfunction isWithinCurveOrder(num) {\n return _0n < num && num < CURVE.n;\n}\nfunction isValidFieldElement(num) {\n return _0n < num && num < CURVE.P;\n}\nfunction kmdToSig(kBytes, m, d, lowS = true) {\n const { n } = CURVE;\n const k = truncateHash(kBytes, true);\n if (!isWithinCurveOrder(k))\n return;\n const kinv = invert(k, n);\n const q = Point.BASE.multiply(k);\n const r = mod(q.x, n);\n if (r === _0n)\n return;\n const s = mod(kinv * mod(m + d * r, n), n);\n if (s === _0n)\n return;\n let sig = new Signature(r, s);\n let recovery = (q.x === sig.r ? 0 : 2) \| Number(q.y & _1n);\n if (lowS && sig.hasHighS()) {\n sig = sig.normalizeS();\n recovery ^= 1;\n }\n return { sig, recovery };\n}\nfunction normalizePrivateKey(key) {\n let num;\n if (typeof key === 'bigint') {\n num = key;\n }\n else if (typeof key === 'number' && Number.isSafeInteger(key) && key > 0) {\n num = BigInt(key);\n }\n else if (typeof key === 'string') {\n if (key.length !== 2 * groupLen)\n throw new Error('Expected 32 bytes of private key');\n num = hexToNumber(key);\n }\n else if (key instanceof Uint8Array) {\n if (key.length !== groupLen)\n throw new Error('Expected 32 bytes of private key');\n num = bytesToNumber(key);\n }\n else {\n throw new TypeError('Expected valid private key');\n }\n if (!isWithinCurveOrder(num))\n throw new Error('Expected private key: 0 < key < n');\n return num;\n}\nfunction normalizePublicKey(publicKey) {\n if (publicKey instanceof Point) {\n publicKey.assertValidity();\n return publicKey;\n }\n else {\n return Point.fromHex(publicKey);\n }\n}\nfunction normalizeSignature(signature) {\n if (signature instanceof Signature) {\n signature.assertValidity();\n return signature;\n }\n try {\n return Signature.fromDER(signature);\n }\n catch (error) {\n return Signature.fromCompact(signature);\n }\n}\nexport function getPublicKey(privateKey, isCompressed = false) {\n return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n}\nexport function recoverPublicKey(msgHash, signature, recovery, isCompressed = false) {\n return Point.fromSignature(msgHash, signature, recovery).toRawBytes(isCompressed);\n}\nfunction isProbPub(item) {\n const arr = item instanceof Uint8Array;\n const str = typeof item === 'string';\n const len = (arr \|\| str) && item.length;\n if (arr)\n return len === compressedLen \|\| len === uncompressedLen;\n if (str)\n return len === compressedLen * 2 \|\| len === uncompressedLen * 2;\n if (item instanceof Point)\n return true;\n return false;\n}\nexport function getSharedSecret(privateA, publicB, isCompressed = false) {\n if (isProbPub(privateA))\n throw new TypeError('getSharedSecret: first arg must be private key');\n if (!isProbPub(publicB))\n throw new TypeError('getSharedSecret: second arg must be public key');\n const b = normalizePublicKey(publicB);\n b.assertValidity();\n return b.multiply(normalizePrivateKey(privateA)).toRawBytes(isCompressed);\n}\nfunction bits2int(bytes) {\n const slice = bytes.length > fieldLen ? bytes.slice(0, fieldLen) : bytes;\n return bytesToNumber(slice);\n}\nfunction bits2octets(bytes) {\n const z1 = bits2int(bytes);\n const z2 = mod(z1, CURVE.n);\n return int2octets(z2 < _0n ? z1 : z2);\n}\nfunction int2octets(num) {\n return numTo32b(num);\n}\nfunction initSigArgs(msgHash, privateKey, extraEntropy) {\n if (msgHash == null)\n throw new Error(`sign: expected valid message hash, not \"${msgHash}\"`);\n const h1 = ensureBytes(msgHash);\n const d = normalizePrivateKey(privateKey);\n const seedArgs = [int2octets(d), bits2octets(h1)];\n if (extraEntropy != null) {\n if (extraEntropy === true)\n extraEntropy = utils.randomBytes(fieldLen);\n const e = ensureBytes(extraEntropy);\n if (e.length !== fieldLen)\n throw new Error(`sign: Expected ${fieldLen} bytes of extra data`);\n seedArgs.push(e);\n }\n const seed = concatBytes(...seedArgs);\n const m = bits2int(h1);\n return { seed, m, d };\n}\nfunction finalizeSig(recSig, opts) {\n const { sig, recovery } = recSig;\n const { der, recovered } = Object.assign({ canonical: true, der: true }, opts);\n const hashed = der ? sig.toDERRawBytes() : sig.toCompactRawBytes();\n return recovered ? [hashed, recovery] : hashed;\n}\nasync function sign(msgHash, privKey, opts = {}) {\n const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\n const drbg = new HmacDrbg(hashLen, groupLen);\n await drbg.reseed(seed);\n let sig;\n while (!(sig = kmdToSig(await drbg.generate(), m, d, opts.canonical)))\n await drbg.reseed();\n return finalizeSig(sig, opts);\n}\nfunction signSync(msgHash, privKey, opts = {}) {\n const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\n const drbg = new HmacDrbg(hashLen, groupLen);\n drbg.reseedSync(seed);\n let sig;\n while (!(sig = kmdToSig(drbg.generateSync(), m, d, opts.canonical)))\n drbg.reseedSync();\n return finalizeSig(sig, opts);\n}\nexport { sign, signSync };\nconst vopts = { strict: true };\nexport function verify(signature, msgHash, publicKey, opts = vopts) {\n let sig;\n try {\n sig = normalizeSignature(signature);\n msgHash = ensureBytes(msgHash);\n }\n catch (error) {\n return false;\n }\n const { r, s } = sig;\n if (opts.strict && sig.hasHighS())\n return false;\n const h = truncateHash(msgHash);\n let P;\n try {\n P = normalizePublicKey(publicKey);\n }\n catch (error) {\n return false;\n }\n const { n } = CURVE;\n const sinv = invert(s, n);\n const u1 = mod(h * sinv, n);\n const u2 = mod(r * sinv, n);\n const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2);\n if (!R)\n return false;\n const v = mod(R.x, n);\n return v === r;\n}\nfunction schnorrChallengeFinalize(ch) {\n return mod(bytesToNumber(ch), CURVE.n);\n}\nclass SchnorrSignature {\n constructor(r, s) {\n this.r = r;\n this.s = s;\n this.assertValidity();\n }\n static fromHex(hex) {\n const bytes = ensureBytes(hex);\n if (bytes.length !== 64)\n throw new TypeError(`SchnorrSignature.fromHex: expected 64 bytes, not ${bytes.length}`);\n const r = bytesToNumber(bytes.subarray(0, 32));\n const s = bytesToNumber(bytes.subarray(32, 64));\n return new SchnorrSignature(r, s);\n }\n assertValidity() {\n const { r, s } = this;\n if (!isValidFieldElement(r) \|\| !isWithinCurveOrder(s))\n throw new Error('Invalid signature');\n }\n toHex() {\n return numTo32bStr(this.r) + numTo32bStr(this.s);\n }\n toRawBytes() {\n return hexToBytes(this.toHex());\n }\n}\nfunction schnorrGetPublicKey(privateKey) {\n return Point.fromPrivateKey(privateKey).toRawX();\n}\nclass InternalSchnorrSignature {\n constructor(message, privateKey, auxRand = utils.randomBytes()) {\n if (message == null)\n throw new TypeError(`sign: Expected valid message, not \"${message}\"`);\n this.m = ensureBytes(message);\n const { x, scalar } = this.getScalar(normalizePrivateKey(privateKey));\n this.px = x;\n this.d = scalar;\n this.rand = ensureBytes(auxRand);\n if (this.rand.length !== 32)\n throw new TypeError('sign: Expected 32 bytes of aux randomness');\n }\n getScalar(priv) {\n const point = Point.fromPrivateKey(priv);\n const scalar = point.hasEvenY() ? priv : CURVE.n - priv;\n return { point, scalar, x: point.toRawX() };\n }\n initNonce(d, t0h) {\n return numTo32b(d ^ bytesToNumber(t0h));\n }\n finalizeNonce(k0h) {\n const k0 = mod(bytesToNumber(k0h), CURVE.n);\n if (k0 === _0n)\n throw new Error('sign: Creation of signature failed. k is zero');\n const { point: R, x: rx, scalar: k } = this.getScalar(k0);\n return { R, rx, k };\n }\n finalizeSig(R, k, e, d) {\n return new SchnorrSignature(R.x, mod(k + e * d, CURVE.n)).toRawBytes();\n }\n error() {\n throw new Error('sign: Invalid signature produced');\n }\n async calc() {\n const { m, d, px, rand } = this;\n const tag = utils.taggedHash;\n const t = this.initNonce(d, await tag(TAGS.aux, rand));\n const { R, rx, k } = this.finalizeNonce(await tag(TAGS.nonce, t, px, m));\n const e = schnorrChallengeFinalize(await tag(TAGS.challenge, rx, px, m));\n const sig = this.finalizeSig(R, k, e, d);\n if (!(await schnorrVerify(sig, m, px)))\n this.error();\n return sig;\n }\n calcSync() {\n const { m, d, px, rand } = this;\n const tag = utils.taggedHashSync;\n const t = this.initNonce(d, tag(TAGS.aux, rand));\n const { R, rx, k } = this.finalizeNonce(tag(TAGS.nonce, t, px, m));\n const e = schnorrChallengeFinalize(tag(TAGS.challenge, rx, px, m));\n const sig = this.finalizeSig(R, k, e, d);\n if (!schnorrVerifySync(sig, m, px))\n this.error();\n return sig;\n }\n}\nasync function schnorrSign(msg, privKey, auxRand) {\n return new InternalSchnorrSignature(msg, privKey, auxRand).calc();\n}\nfunction schnorrSignSync(msg, privKey, auxRand) {\n return new InternalSchnorrSignature(msg, privKey, auxRand).calcSync();\n}\nfunction initSchnorrVerify(signature, message, publicKey) {\n const raw = signature instanceof SchnorrSignature;\n const sig = raw ? signature : SchnorrSignature.fromHex(signature);\n if (raw)\n sig.assertValidity();\n return {\n ...sig,\n m: ensureBytes(message),\n P: normalizePublicKey(publicKey),\n };\n}\nfunction finalizeSchnorrVerify(r, P, s, e) {\n const R = Point.BASE.multiplyAndAddUnsafe(P, normalizePrivateKey(s), mod(-e, CURVE.n));\n if (!R \|\| !R.hasEvenY() \|\| R.x !== r)\n return false;\n return true;\n}\nasync function schnorrVerify(signature, message, publicKey) {\n try {\n const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\n const e = schnorrChallengeFinalize(await utils.taggedHash(TAGS.challenge, numTo32b(r), P.toRawX(), m));\n return finalizeSchnorrVerify(r, P, s, e);\n }\n catch (error) {\n return false;\n }\n}\nfunction schnorrVerifySync(signature, message, publicKey) {\n try {\n const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\n const e = schnorrChallengeFinalize(utils.taggedHashSync(TAGS.challenge, numTo32b(r), P.toRawX(), m));\n return finalizeSchnorrVerify(r, P, s, e);\n }\n catch (error) {\n if (error instanceof ShaError)\n throw error;\n return false;\n }\n}\nexport const schnorr = {\n Signature: SchnorrSignature,\n getPublicKey: schnorrGetPublicKey,\n sign: schnorrSign,\n verify: schnorrVerify,\n signSync: schnorrSignSync,\n verifySync: schnorrVerifySync,\n};\nPoint.BASE._setWindowSize(8);\nconst crypto = {\n node: nodeCrypto,\n web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\nconst TAGS = {\n challenge: 'BIP0340/challenge',\n aux: 'BIP0340/aux',\n nonce: 'BIP0340/nonce',\n};\nconst TAGGED_HASH_PREFIXES = {};\nexport const utils = {\n bytesToHex,\n hexToBytes,\n concatBytes,\n mod,\n invert,\n isValidPrivateKey(privateKey) {\n try {\n normalizePrivateKey(privateKey);\n return true;\n }\n catch (error) {\n return false;\n }\n },\n _bigintTo32Bytes: numTo32b,\n _normalizePrivateKey: normalizePrivateKey,\n hashToPrivateKey: (hash) => {\n hash = ensureBytes(hash);\n const minLen = groupLen + 8;\n if (hash.length < minLen \|\| hash.length > 1024) {\n throw new Error(`Expected valid bytes of private key as per FIPS 186`);\n }\n const num = mod(bytesToNumber(hash), CURVE.n - _1n) + _1n;\n return numTo32b(num);\n },\n randomBytes: (bytesLength = 32) => {\n if (crypto.web) {\n return crypto.web.getRandomValues(new Uint8Array(bytesLength));\n }\n else if (crypto.node) {\n const { randomBytes } = crypto.node;\n return Uint8Array.from(randomBytes(bytesLength));\n }\n else {\n throw new Error(\"The environment doesn't have randomBytes function\");\n }\n },\n randomPrivateKey: () => utils.hashToPrivateKey(utils.randomBytes(groupLen + 8)),\n precompute(windowSize = 8, point = Point.BASE) {\n const cached = point === Point.BASE ? point : new Point(point.x, point.y);\n cached._setWindowSize(windowSize);\n cached.multiply(_3n);\n return cached;\n },\n sha256: async (...messages) => {\n if (crypto.web) {\n const buffer = await crypto.web.subtle.digest('SHA-256', concatBytes(...messages));\n return new Uint8Array(buffer);\n }\n else if (crypto.node) {\n const { createHash } = crypto.node;\n const hash = createHash('sha256');\n messages.forEach((m) => hash.update(m));\n return Uint8Array.from(hash.digest());\n }\n else {\n throw new Error(\"The environment doesn't have sha256 function\");\n }\n },\n hmacSha256: async (key, ...messages) => {\n if (crypto.web) {\n const ckey = await crypto.web.subtle.importKey('raw', key, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);\n const message = concatBytes(...messages);\n const buffer = await crypto.web.subtle.sign('HMAC', ckey, message);\n return new Uint8Array(buffer);\n }\n else if (crypto.node) {\n const { createHmac } = crypto.node;\n const hash = createHmac('sha256', key);\n messages.forEach((m) => hash.update(m));\n return Uint8Array.from(hash.digest());\n }\n else {\n throw new Error(\"The environment doesn't have hmac-sha256 function\");\n }\n },\n sha256Sync: undefined,\n hmacSha256Sync: undefined,\n taggedHash: async (tag, ...messages) => {\n let tagP = TAGGED_HASH_PREFIXES[tag];\n if (tagP === undefined) {\n const tagH = await utils.sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n tagP = concatBytes(tagH, tagH);\n TAGGED_HASH_PREFIXES[tag] = tagP;\n }\n return utils.sha256(tagP, ...messages);\n },\n taggedHashSync: (tag, ...messages) => {\n if (typeof _sha256Sync !== 'function')\n throw new ShaError('sha256Sync is undefined, you need to set it');\n let tagP = TAGGED_HASH_PREFIXES[tag];\n if (tagP === undefined) {\n const tagH = _sha256Sync(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n tagP = concatBytes(tagH, tagH);\n TAGGED_HASH_PREFIXES[tag] = tagP;\n }\n return _sha256Sync(tagP, ...messages);\n },\n _JacobianPoint: JacobianPoint,\n};\nObject.defineProperties(utils, {\n sha256Sync: {\n configurable: false,\n get() {\n return _sha256Sync;\n },\n set(val) {\n if (!_sha256Sync)\n _sha256Sync = val;\n },\n },\n hmacSha256Sync: {\n configurable: false,\n get() {\n return _hmacSha256Sync;\n },\n set(val) {\n if (!_hmacSha256Sync)\n _hmacSha256Sync = val;\n },\n },\n});\n","import { hexToInt } from './utils';\nconst COORDINATE_BYTES = 32;\nexport function parseRecoverableSignatureVrs(signature) {\n if (signature.length < COORDINATE_BYTES * 2 * 2 + 1) {\n throw new Error('Invalid signature');\n }\n const recoveryIdHex = signature.slice(0, 2);\n const r = signature.slice(2, 2 + COORDINATE_BYTES * 2);\n const s = signature.slice(2 + COORDINATE_BYTES * 2);\n return {\n recoveryId: hexToInt(recoveryIdHex),\n r,\n s,\n };\n}\nexport function signatureVrsToRsv(signature) {\n return signature.slice(2) + signature.slice(0, 2);\n}\nexport function signatureRsvToVrs(signature) {\n return signature.slice(-2) + signature.slice(0, -2);\n}\n//# sourceMappingURL=signatures.js.map","import { hexToBytes } from './utils';\nexport function privateKeyToBytes(privateKey) {\n const privateKeyBuffer = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey;\n if (privateKeyBuffer.length != 32 && privateKeyBuffer.length != 33) {\n throw new Error(`Improperly formatted private-key. Private-key byte length should be 32 or 33. Length provided: ${privateKeyBuffer.length}`);\n }\n if (privateKeyBuffer.length == 33 && privateKeyBuffer[32] !== 1) {\n throw new Error('Improperly formatted private-key. 33 bytes indicate compressed key, but the last byte must be == 01');\n }\n return privateKeyBuffer;\n}\n//# sourceMappingURL=keys.js.map","import { SHA2 } from './_sha2.js';\nimport { wrapConstructor } from './utils.js';\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\nconst Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);\nconst Id = Uint8Array.from({ length: 16 }, (_, i) => i);\nconst Pi = Id.map((i) => (9 * i + 5) % 16);\nlet idxL = [Id];\nlet idxR = [Pi];\nfor (let i = 0; i < 4; i++)\n for (let j of [idxL, idxR])\n j.push(j[i].map((k) => Rho[k]));\nconst shifts = [\n [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],\n [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],\n [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],\n [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],\n [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],\n].map((i) => new Uint8Array(i));\nconst shiftsL = idxL.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst shiftsR = idxR.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst Kl = new Uint32Array([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);\nconst Kr = new Uint32Array([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);\n// The rotate left (circular left shift) operation for uint32\nconst rotl = (word, shift) => (word << shift) \| (word >>> (32 - shift));\n// It's called f() in spec.\nfunction f(group, x, y, z) {\n if (group === 0)\n return x ^ y ^ z;\n else if (group === 1)\n return (x & y) \| (~x & z);\n else if (group === 2)\n return (x \| ~y) ^ z;\n else if (group === 3)\n return (x & z) \| (y & ~z);\n else\n return x ^ (y \| ~z);\n}\n// Temporary buffer, not used to store anything between runs\nconst BUF = new Uint32Array(16);\nexport class RIPEMD160 extends SHA2 {\n constructor() {\n super(64, 20, 8, true);\n this.h0 = 0x67452301 \| 0;\n this.h1 = 0xefcdab89 \| 0;\n this.h2 = 0x98badcfe \| 0;\n this.h3 = 0x10325476 \| 0;\n this.h4 = 0xc3d2e1f0 \| 0;\n }\n get() {\n const { h0, h1, h2, h3, h4 } = this;\n return [h0, h1, h2, h3, h4];\n }\n set(h0, h1, h2, h3, h4) {\n this.h0 = h0 \| 0;\n this.h1 = h1 \| 0;\n this.h2 = h2 \| 0;\n this.h3 = h3 \| 0;\n this.h4 = h4 \| 0;\n }\n process(view, offset) {\n for (let i = 0; i < 16; i++, offset += 4)\n BUF[i] = view.getUint32(offset, true);\n // prettier-ignore\n let al = this.h0 \| 0, ar = al, bl = this.h1 \| 0, br = bl, cl = this.h2 \| 0, cr = cl, dl = this.h3 \| 0, dr = dl, el = this.h4 \| 0, er = el;\n // Instead of iterating 0 to 80, we split it into 5 groups\n // And use the groups in constants, functions, etc. Much simpler\n for (let group = 0; group < 5; group++) {\n const rGroup = 4 - group;\n const hbl = Kl[group], hbr = Kr[group]; // prettier-ignore\n const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n const sl = shiftsL[group], sr = shiftsR[group]; // prettier-ignore\n for (let i = 0; i < 16; i++) {\n const tl = (rotl(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el) \| 0;\n al = el, el = dl, dl = rotl(cl, 10) \| 0, cl = bl, bl = tl; // prettier-ignore\n }\n // 2 loops are 10% faster\n for (let i = 0; i < 16; i++) {\n const tr = (rotl(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er) \| 0;\n ar = er, er = dr, dr = rotl(cr, 10) \| 0, cr = br, br = tr; // prettier-ignore\n }\n }\n // Add the compressed chunk to the current hash value\n this.set((this.h1 + cl + dr) \| 0, (this.h2 + dl + er) \| 0, (this.h3 + el + ar) \| 0, (this.h4 + al + br) \| 0, (this.h0 + bl + cr) \| 0);\n }\n roundClean() {\n BUF.fill(0);\n }\n destroy() {\n this.destroyed = true;\n this.buffer.fill(0);\n this.set(0, 0, 0, 0, 0);\n }\n}\n/*\n RIPEMD-160 - a hash function from 1990s.\n * @param message - msg that would be hashed\n /\nexport const ripemd160 = wrapConstructor(() => new RIPEMD160());\n","const U32_MASK64 = BigInt(2 * 32 - 1);\nconst _32n = BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nexport function fromBig(n, le = false) {\n if (le)\n return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n return { h: Number((n >> _32n) & U32_MASK64) \| 0, l: Number(n & U32_MASK64) \| 0 };\n}\nexport function split(lst, le = false) {\n let Ah = new Uint32Array(lst.length);\n let Al = new Uint32Array(lst.length);\n for (let i = 0; i < lst.length; i++) {\n const { h, l } = fromBig(lst[i], le);\n [Ah[i], Al[i]] = [h, l];\n }\n return [Ah, Al];\n}\nexport const toBig = (h, l) => (BigInt(h >>> 0) << _32n) \| BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) \| (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) \| (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) \| (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) \| (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) \| (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (h, l) => l;\nconst rotr32L = (h, l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) \| (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) \| (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) \| (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) \| (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\n// Removing \"export\" has 5% perf penalty -_-\nexport function add(Ah, Al, Bh, Bl) {\n const l = (Al >>> 0) + (Bl >>> 0);\n return { h: (Ah + Bh + ((l / 2 32) \| 0)) \| 0, l: l \| 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 32) \| 0)) \| 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 32) \| 0)) \| 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 32) \| 0)) \| 0;\n// prettier-ignore\nconst u64 = {\n fromBig, split, toBig,\n shrSH, shrSL,\n rotrSH, rotrSL, rotrBH, rotrBL,\n rotr32H, rotr32L,\n rotlSH, rotlSL, rotlBH, rotlBL,\n add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n","import { SHA2 } from './_sha2.js';\nimport u64 from './_u64.js';\nimport { wrapConstructor } from './utils.js';\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = u64.split([\n '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n)));\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = new Uint32Array(80);\nconst SHA512_W_L = new Uint32Array(80);\nexport class SHA512 extends SHA2 {\n constructor() {\n super(128, 64, 16, false);\n // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n // Also looks cleaner and easier to verify with spec.\n // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0x6a09e667 \| 0;\n this.Al = 0xf3bcc908 \| 0;\n this.Bh = 0xbb67ae85 \| 0;\n this.Bl = 0x84caa73b \| 0;\n this.Ch = 0x3c6ef372 \| 0;\n this.Cl = 0xfe94f82b \| 0;\n this.Dh = 0xa54ff53a \| 0;\n this.Dl = 0x5f1d36f1 \| 0;\n this.Eh = 0x510e527f \| 0;\n this.El = 0xade682d1 \| 0;\n this.Fh = 0x9b05688c \| 0;\n this.Fl = 0x2b3e6c1f \| 0;\n this.Gh = 0x1f83d9ab \| 0;\n this.Gl = 0xfb41bd6b \| 0;\n this.Hh = 0x5be0cd19 \| 0;\n this.Hl = 0x137e2179 \| 0;\n }\n // prettier-ignore\n get() {\n const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n }\n // prettier-ignore\n set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n this.Ah = Ah \| 0;\n this.Al = Al \| 0;\n this.Bh = Bh \| 0;\n this.Bl = Bl \| 0;\n this.Ch = Ch \| 0;\n this.Cl = Cl \| 0;\n this.Dh = Dh \| 0;\n this.Dl = Dl \| 0;\n this.Eh = Eh \| 0;\n this.El = El \| 0;\n this.Fh = Fh \| 0;\n this.Fl = Fl \| 0;\n this.Gh = Gh \| 0;\n this.Gl = Gl \| 0;\n this.Hh = Hh \| 0;\n this.Hl = Hl \| 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4) {\n SHA512_W_H[i] = view.getUint32(offset);\n SHA512_W_L[i] = view.getUint32((offset += 4));\n }\n for (let i = 16; i < 80; i++) {\n // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n const W15h = SHA512_W_H[i - 15] \| 0;\n const W15l = SHA512_W_L[i - 15] \| 0;\n const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n const W2h = SHA512_W_H[i - 2] \| 0;\n const W2l = SHA512_W_L[i - 2] \| 0;\n const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n SHA512_W_H[i] = SUMh \| 0;\n SHA512_W_L[i] = SUMl \| 0;\n }\n let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n // Compression function main loop, 80 rounds\n for (let i = 0; i < 80; i++) {\n // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) \| 0;\n const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n const CHIl = (El & Fl) ^ (~El & Gl);\n // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n // prettier-ignore\n const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n const T1l = T1ll \| 0;\n // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n Hh = Gh \| 0;\n Hl = Gl \| 0;\n Gh = Fh \| 0;\n Gl = Fl \| 0;\n Fh = Eh \| 0;\n Fl = El \| 0;\n ({ h: Eh, l: El } = u64.add(Dh \| 0, Dl \| 0, T1h \| 0, T1l \| 0));\n Dh = Ch \| 0;\n Dl = Cl \| 0;\n Ch = Bh \| 0;\n Cl = Bl \| 0;\n Bh = Ah \| 0;\n Bl = Al \| 0;\n const All = u64.add3L(T1l, sigma0l, MAJl);\n Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n Al = All \| 0;\n }\n // Add the compressed chunk to the current hash value\n ({ h: Ah, l: Al } = u64.add(this.Ah \| 0, this.Al \| 0, Ah \| 0, Al \| 0));\n ({ h: Bh, l: Bl } = u64.add(this.Bh \| 0, this.Bl \| 0, Bh \| 0, Bl \| 0));\n ({ h: Ch, l: Cl } = u64.add(this.Ch \| 0, this.Cl \| 0, Ch \| 0, Cl \| 0));\n ({ h: Dh, l: Dl } = u64.add(this.Dh \| 0, this.Dl \| 0, Dh \| 0, Dl \| 0));\n ({ h: Eh, l: El } = u64.add(this.Eh \| 0, this.El \| 0, Eh \| 0, El \| 0));\n ({ h: Fh, l: Fl } = u64.add(this.Fh \| 0, this.Fl \| 0, Fh \| 0, Fl \| 0));\n ({ h: Gh, l: Gl } = u64.add(this.Gh \| 0, this.Gl \| 0, Gh \| 0, Gl \| 0));\n ({ h: Hh, l: Hl } = u64.add(this.Hh \| 0, this.Hl \| 0, Hh \| 0, Hl \| 0));\n this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n }\n roundClean() {\n SHA512_W_H.fill(0);\n SHA512_W_L.fill(0);\n }\n destroy() {\n this.buffer.fill(0);\n this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n }\n}\nclass SHA512_224 extends SHA512 {\n constructor() {\n super();\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0x8c3d37c8 \| 0;\n this.Al = 0x19544da2 \| 0;\n this.Bh = 0x73e19966 \| 0;\n this.Bl = 0x89dcd4d6 \| 0;\n this.Ch = 0x1dfab7ae \| 0;\n this.Cl = 0x32ff9c82 \| 0;\n this.Dh = 0x679dd514 \| 0;\n this.Dl = 0x582f9fcf \| 0;\n this.Eh = 0x0f6d2b69 \| 0;\n this.El = 0x7bd44da8 \| 0;\n this.Fh = 0x77e36f73 \| 0;\n this.Fl = 0x04c48942 \| 0;\n this.Gh = 0x3f9d85a8 \| 0;\n this.Gl = 0x6a1d36c8 \| 0;\n this.Hh = 0x1112e6ad \| 0;\n this.Hl = 0x91d692a1 \| 0;\n this.outputLen = 28;\n }\n}\nclass SHA512_256 extends SHA512 {\n constructor() {\n super();\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0x22312194 \| 0;\n this.Al = 0xfc2bf72c \| 0;\n this.Bh = 0x9f555fa3 \| 0;\n this.Bl = 0xc84c64c2 \| 0;\n this.Ch = 0x2393b86b \| 0;\n this.Cl = 0x6f53b151 \| 0;\n this.Dh = 0x96387719 \| 0;\n this.Dl = 0x5940eabd \| 0;\n this.Eh = 0x96283ee2 \| 0;\n this.El = 0xa88effe3 \| 0;\n this.Fh = 0xbe5e1e25 \| 0;\n this.Fl = 0x53863992 \| 0;\n this.Gh = 0x2b0199fc \| 0;\n this.Gl = 0x2c85b8aa \| 0;\n this.Hh = 0x0eb72ddc \| 0;\n this.Hl = 0x81c52ca2 \| 0;\n this.outputLen = 32;\n }\n}\nclass SHA384 extends SHA512 {\n constructor() {\n super();\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0xcbbb9d5d \| 0;\n this.Al = 0xc1059ed8 \| 0;\n this.Bh = 0x629a292a \| 0;\n this.Bl = 0x367cd507 \| 0;\n this.Ch = 0x9159015a \| 0;\n this.Cl = 0x3070dd17 \| 0;\n this.Dh = 0x152fecd8 \| 0;\n this.Dl = 0xf70e5939 \| 0;\n this.Eh = 0x67332667 \| 0;\n this.El = 0xffc00b31 \| 0;\n this.Fh = 0x8eb44a87 \| 0;\n this.Fl = 0x68581511 \| 0;\n this.Gh = 0xdb0c2e0d \| 0;\n this.Gl = 0x64f98fa7 \| 0;\n this.Hh = 0x47b5481d \| 0;\n this.Hl = 0xbefa4fa4 \| 0;\n this.outputLen = 48;\n }\n}\nexport const sha512 = wrapConstructor(() => new SHA512());\nexport const sha512_224 = wrapConstructor(() => new SHA512_224());\nexport const sha512_256 = wrapConstructor(() => new SHA512_256());\nexport const sha384 = wrapConstructor(() => new SHA384());\n","import { bytesToHex, hexToBytes, readUInt16BE, readUInt32BE, readUInt8 } from '@stacks/common';\nfunction createEnumChecker(enumVariable) {\n const enumValues = Object.values(enumVariable).filter(v => typeof v === 'number');\n const enumValueSet = new Set(enumValues);\n return (value) => enumValueSet.has(value);\n}\nconst enumCheckFunctions = new Map();\nexport function isEnum(enumVariable, value) {\n const checker = enumCheckFunctions.get(enumVariable);\n if (checker !== undefined) {\n return checker(value);\n }\n const newChecker = createEnumChecker(enumVariable);\n enumCheckFunctions.set(enumVariable, newChecker);\n return isEnum(enumVariable, value);\n}\nexport class BytesReader {\n constructor(bytes) {\n this.consumed = 0;\n this.source = typeof bytes === 'string' ? hexToBytes(bytes) : bytes;\n }\n readBytes(length) {\n const view = this.source.subarray(this.consumed, this.consumed + length);\n this.consumed += length;\n return view;\n }\n readUInt32BE() {\n return readUInt32BE(this.readBytes(4), 0);\n }\n readUInt8() {\n return readUInt8(this.readBytes(1), 0);\n }\n readUInt16BE() {\n return readUInt16BE(this.readBytes(2), 0);\n }\n readBigUIntLE(length) {\n const bytes = this.readBytes(length).slice().reverse();\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n readBigUIntBE(length) {\n const bytes = this.readBytes(length);\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n get readOffset() {\n return this.consumed;\n }\n set readOffset(val) {\n this.consumed = val;\n }\n get internalBytes() {\n return this.source;\n }\n readUInt8Enum(enumVariable, invalidEnumErrorFormatter) {\n const num = this.readUInt8();\n if (isEnum(enumVariable, num)) {\n return num;\n }\n throw invalidEnumErrorFormatter(num);\n }\n}\n//# sourceMappingURL=BytesReader.js.map","export var ClarityType;\n(function (ClarityType) {\n ClarityType[\"Int\"] = \"int\";\n ClarityType[\"UInt\"] = \"uint\";\n ClarityType[\"Buffer\"] = \"buffer\";\n ClarityType[\"BoolTrue\"] = \"true\";\n ClarityType[\"BoolFalse\"] = \"false\";\n ClarityType[\"PrincipalStandard\"] = \"address\";\n ClarityType[\"PrincipalContract\"] = \"contract\";\n ClarityType[\"ResponseOk\"] = \"ok\";\n ClarityType[\"ResponseErr\"] = \"err\";\n ClarityType[\"OptionalNone\"] = \"none\";\n ClarityType[\"OptionalSome\"] = \"some\";\n ClarityType[\"List\"] = \"list\";\n ClarityType[\"Tuple\"] = \"tuple\";\n ClarityType[\"StringASCII\"] = \"ascii\";\n ClarityType[\"StringUTF8\"] = \"utf8\";\n})(ClarityType \|\| (ClarityType = {}));\nexport var ClarityWireType;\n(function (ClarityWireType) {\n ClarityWireType[ClarityWireType[\"int\"] = 0] = \"int\";\n ClarityWireType[ClarityWireType[\"uint\"] = 1] = \"uint\";\n ClarityWireType[ClarityWireType[\"buffer\"] = 2] = \"buffer\";\n ClarityWireType[ClarityWireType[\"true\"] = 3] = \"true\";\n ClarityWireType[ClarityWireType[\"false\"] = 4] = \"false\";\n ClarityWireType[ClarityWireType[\"address\"] = 5] = \"address\";\n ClarityWireType[ClarityWireType[\"contract\"] = 6] = \"contract\";\n ClarityWireType[ClarityWireType[\"ok\"] = 7] = \"ok\";\n ClarityWireType[ClarityWireType[\"err\"] = 8] = \"err\";\n ClarityWireType[ClarityWireType[\"none\"] = 9] = \"none\";\n ClarityWireType[ClarityWireType[\"some\"] = 10] = \"some\";\n ClarityWireType[ClarityWireType[\"list\"] = 11] = \"list\";\n ClarityWireType[ClarityWireType[\"tuple\"] = 12] = \"tuple\";\n ClarityWireType[ClarityWireType[\"ascii\"] = 13] = \"ascii\";\n ClarityWireType[ClarityWireType[\"utf8\"] = 14] = \"utf8\";\n})(ClarityWireType \|\| (ClarityWireType = {}));\nexport function clarityTypeToByte(type) {\n return ClarityWireType[type];\n}\nexport function clarityByteToType(wireType) {\n return ClarityWireType[wireType];\n}\n//# sourceMappingURL=constants.js.map","import { bytesToTwosBigInt, hexToBytes, intToBigInt, isInstance, } from '@stacks/common';\nimport { ClarityType } from '../constants';\nconst MAX_U128 = BigInt('0xffffffffffffffffffffffffffffffff');\nconst MIN_U128 = BigInt(0);\nconst MAX_I128 = BigInt('0x7fffffffffffffffffffffffffffffff');\nconst MIN_I128 = BigInt('-170141183460469231731687303715884105728');\nexport const intCV = (value) => {\n if (typeof value === 'string' && value.toLowerCase().startsWith('0x')) {\n value = bytesToTwosBigInt(hexToBytes(value));\n }\n if (isInstance(value, Uint8Array))\n value = bytesToTwosBigInt(value);\n const bigInt = intToBigInt(value);\n if (bigInt > MAX_I128) {\n throw new RangeError(`Cannot construct clarity integer from value greater than ${MAX_I128}`);\n }\n else if (bigInt < MIN_I128) {\n throw new RangeError(`Cannot construct clarity integer form value less than ${MIN_I128}`);\n }\n return { type: ClarityType.Int, value: bigInt };\n};\nexport const uintCV = (value) => {\n const bigInt = intToBigInt(value);\n if (bigInt < MIN_U128) {\n throw new RangeError('Cannot construct unsigned clarity integer from negative value');\n }\n else if (bigInt > MAX_U128) {\n throw new RangeError(`Cannot construct unsigned clarity integer greater than ${MAX_U128}`);\n }\n return { type: ClarityType.UInt, value: bigInt };\n};\n//# sourceMappingURL=intCV.js.map","import { bytesToHex, utf8ToBytes } from '@stacks/common';\nimport { ClarityType } from '../constants';\nexport const bufferCV = (buffer) => {\n if (buffer.byteLength > 1048576) {\n throw new Error('Cannot construct clarity buffer that is greater than 1MB');\n }\n return { type: ClarityType.Buffer, value: bytesToHex(buffer) };\n};\nexport const bufferCVFromString = (str) => bufferCV(utf8ToBytes(str));\n//# sourceMappingURL=bufferCV.js.map","import { ClarityType } from '../constants';\nexport const trueCV = () => ({ type: ClarityType.BoolTrue });\nexport const falseCV = () => ({ type: ClarityType.BoolFalse });\nexport const boolCV = (bool) => (bool ? trueCV() : falseCV());\n//# sourceMappingURL=booleanCV.js.map","export var StacksWireType;\n(function (StacksWireType) {\n StacksWireType[StacksWireType[\"Address\"] = 0] = \"Address\";\n StacksWireType[StacksWireType[\"Principal\"] = 1] = \"Principal\";\n StacksWireType[StacksWireType[\"LengthPrefixedString\"] = 2] = \"LengthPrefixedString\";\n StacksWireType[StacksWireType[\"MemoString\"] = 3] = \"MemoString\";\n StacksWireType[StacksWireType[\"Asset\"] = 4] = \"Asset\";\n StacksWireType[StacksWireType[\"PostCondition\"] = 5] = \"PostCondition\";\n StacksWireType[StacksWireType[\"PublicKey\"] = 6] = \"PublicKey\";\n StacksWireType[StacksWireType[\"LengthPrefixedList\"] = 7] = \"LengthPrefixedList\";\n StacksWireType[StacksWireType[\"Payload\"] = 8] = \"Payload\";\n StacksWireType[StacksWireType[\"MessageSignature\"] = 9] = \"MessageSignature\";\n StacksWireType[StacksWireType[\"StructuredDataSignature\"] = 10] = \"StructuredDataSignature\";\n StacksWireType[StacksWireType[\"TransactionAuthField\"] = 11] = \"TransactionAuthField\";\n})(StacksWireType \|\| (StacksWireType = {}));\nexport function whenWireType(wireType) {\n return (wireTypeMap) => wireTypeMap[wireType];\n}\n//# sourceMappingURL=types.js.map","import { hexToBytes, intToBigInt } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport { ClarityType, principalCV } from '../clarity';\nimport { AddressVersion, COINBASE_BYTES_LENGTH, MAX_STRING_LENGTH_BYTES, MEMO_MAX_LENGTH_BYTES, PayloadType, PostConditionPrincipalId, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { exceedsMaxLengthBytes } from '../utils';\nimport { StacksWireType, } from './types';\nexport function createEmptyAddress() {\n return {\n type: StacksWireType.Address,\n version: AddressVersion.MainnetSingleSig,\n hash160: '0'.repeat(40),\n };\n}\nexport function createMemoString(content) {\n if (content && exceedsMaxLengthBytes(content, MEMO_MAX_LENGTH_BYTES)) {\n throw new Error(`Memo exceeds maximum length of ${MEMO_MAX_LENGTH_BYTES} bytes`);\n }\n return { type: StacksWireType.MemoString, content };\n}\nexport function createLPList(values, lengthPrefixBytes) {\n return {\n type: StacksWireType.LengthPrefixedList,\n lengthPrefixBytes: lengthPrefixBytes \|\| 4,\n values,\n };\n}\nexport function createMessageSignature(signature) {\n const length = hexToBytes(signature).byteLength;\n if (length != RECOVERABLE_ECDSA_SIG_LENGTH_BYTES) {\n throw Error('Invalid signature');\n }\n return {\n type: StacksWireType.MessageSignature,\n data: signature,\n };\n}\nexport function createTokenTransferPayload(recipient, amount, memo) {\n if (typeof recipient === 'string') {\n recipient = principalCV(recipient);\n }\n if (typeof memo === 'string') {\n memo = createMemoString(memo);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TokenTransfer,\n recipient,\n amount: intToBigInt(amount),\n memo: memo ?? createMemoString(''),\n };\n}\nexport function createContractCallPayload(contractAddress, contractName, functionName, functionArgs) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof functionName === 'string') {\n functionName = createLPString(functionName);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.ContractCall,\n contractAddress: typeof contractAddress === 'string' ? createAddress(contractAddress) : contractAddress,\n contractName,\n functionName,\n functionArgs,\n };\n}\nexport function codeBodyString(content) {\n return createLPString(content, 4, 100000);\n}\nexport function createSmartContractPayload(contractName, codeBody, clarityVersion) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof codeBody === 'string') {\n codeBody = codeBodyString(codeBody);\n }\n if (typeof clarityVersion === 'number') {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.VersionedSmartContract,\n clarityVersion,\n contractName,\n codeBody,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.SmartContract,\n contractName,\n codeBody,\n };\n}\nexport function createPoisonPayload() {\n return { type: StacksWireType.Payload, payloadType: PayloadType.PoisonMicroblock };\n}\nexport function createCoinbasePayload(coinbaseBytes, altRecipient) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (altRecipient != undefined) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.CoinbaseToAltRecipient,\n coinbaseBytes,\n recipient: altRecipient,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.Coinbase,\n coinbaseBytes,\n };\n}\nexport function createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (vrfProof.byteLength != VRF_PROOF_BYTES_LENGTH) {\n throw Error(`VRF proof buffer size must be ${VRF_PROOF_BYTES_LENGTH} bytes`);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.NakamotoCoinbase,\n coinbaseBytes,\n recipient: recipient.type === ClarityType.OptionalSome ? recipient.value : undefined,\n vrfProof,\n };\n}\nexport function createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TenureChange,\n tenureHash,\n previousTenureHash,\n burnViewHash,\n previousTenureEnd,\n previousTenureBlocks,\n cause,\n publicKeyHash,\n };\n}\nexport function createLPString(content, lengthPrefixBytes, maxLengthBytes) {\n const prefixLength = lengthPrefixBytes \|\| 1;\n const maxLength = maxLengthBytes \|\| MAX_STRING_LENGTH_BYTES;\n if (exceedsMaxLengthBytes(content, maxLength)) {\n throw new Error(`String length exceeds maximum bytes ${maxLength}`);\n }\n return {\n type: StacksWireType.LengthPrefixedString,\n content,\n lengthPrefixBytes: prefixLength,\n maxLengthBytes: maxLength,\n };\n}\nexport function createAsset(addressString, contractName, assetName) {\n return {\n type: StacksWireType.Asset,\n address: createAddress(addressString),\n contractName: createLPString(contractName),\n assetName: createLPString(assetName),\n };\n}\nexport function createAddress(c32AddressString) {\n const addressData = c32addressDecode(c32AddressString);\n return {\n type: StacksWireType.Address,\n version: addressData[0],\n hash160: addressData[1],\n };\n}\nexport function createContractPrincipal(addressString, contractName) {\n const addr = createAddress(addressString);\n const name = createLPString(contractName);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Contract,\n address: addr,\n contractName: name,\n };\n}\nexport function createStandardPrincipal(addressString) {\n const addr = createAddress(addressString);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Standard,\n address: addr,\n };\n}\nexport function createTransactionAuthField(pubKeyEncoding, contents) {\n return {\n pubKeyEncoding,\n type: StacksWireType.TransactionAuthField,\n contents,\n };\n}\n//# sourceMappingURL=create.js.map","import { c32address } from 'c32check';\nimport { AddressHashMode, PayloadType } from '../constants';\nimport { publicKeyIsCompressed } from '../keys';\nimport { hashP2PKH, hashP2SH, hashP2WPKH, hashP2WSH } from '../utils';\nimport { createAsset, createContractPrincipal, createStandardPrincipal } from './create';\nimport { serializePublicKeyBytes } from './serialization';\nimport { StacksWireType, } from './types';\nexport function addressFromPublicKeys(version, hashMode, numSigs, publicKeys) {\n if (publicKeys.length === 0) {\n throw Error('Invalid number of public keys');\n }\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n if (publicKeys.length !== 1 \|\| numSigs !== 1) {\n throw Error('Invalid number of public keys or signatures');\n }\n }\n if (hashMode === AddressHashMode.P2WPKH \|\|\n hashMode === AddressHashMode.P2WSH \|\|\n hashMode === AddressHashMode.P2WSHNonSequential) {\n if (!publicKeys.map(p => p.data).every(publicKeyIsCompressed)) {\n throw Error('Public keys must be compressed for segwit');\n }\n }\n switch (hashMode) {\n case AddressHashMode.P2PKH:\n return addressFromVersionHash(version, hashP2PKH(publicKeys[0].data));\n case AddressHashMode.P2WPKH:\n return addressFromVersionHash(version, hashP2WPKH(publicKeys[0].data));\n case AddressHashMode.P2SH:\n case AddressHashMode.P2SHNonSequential:\n return addressFromVersionHash(version, hashP2SH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n case AddressHashMode.P2WSH:\n case AddressHashMode.P2WSHNonSequential:\n return addressFromVersionHash(version, hashP2WSH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n }\n}\nexport function addressFromVersionHash(version, hash) {\n return { type: StacksWireType.Address, version, hash160: hash };\n}\nexport function addressToString(address) {\n return c32address(address.version, address.hash160);\n}\nexport function isTokenTransferPayload(p) {\n return p.payloadType === PayloadType.TokenTransfer;\n}\nexport function isContractCallPayload(p) {\n return p.payloadType === PayloadType.ContractCall;\n}\nexport function isSmartContractPayload(p) {\n return p.payloadType === PayloadType.SmartContract;\n}\nexport function isPoisonPayload(p) {\n return p.payloadType === PayloadType.PoisonMicroblock;\n}\nexport function isCoinbasePayload(p) {\n return p.payloadType === PayloadType.Coinbase;\n}\nexport function parseAssetString(id) {\n const [assetAddress, assetContractName, assetTokenName] = id.split(/\\.\|::/);\n const asset = createAsset(assetAddress, assetContractName, assetTokenName);\n return asset;\n}\nexport function parsePrincipalString(principalString) {\n if (principalString.includes('.')) {\n const [address, contractName] = principalString.split('.');\n return createContractPrincipal(address, contractName);\n }\n else {\n return createStandardPrincipal(principalString);\n }\n}\n//# sourceMappingURL=helpers.js.map","import { utf8ToBytes } from '@stacks/common';\nimport { addressToString, createAddress, createLPString, } from '../../wire';\nimport { ClarityType } from '../constants';\nexport function principalCV(principal) {\n if (principal.includes('.')) {\n const [address, contractName] = principal.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(principal);\n }\n}\nexport function standardPrincipalCV(addressString) {\n const addr = createAddress(addressString);\n return { type: ClarityType.PrincipalStandard, value: addressToString(addr) };\n}\nexport function standardPrincipalCVFromAddress(address) {\n return { type: ClarityType.PrincipalStandard, value: addressToString(address) };\n}\nexport function contractPrincipalCV(addressString, contractName) {\n const addr = createAddress(addressString);\n const lengthPrefixedContractName = createLPString(contractName);\n return contractPrincipalCVFromAddress(addr, lengthPrefixedContractName);\n}\nexport function contractPrincipalCVFromAddress(address, contractName) {\n if (utf8ToBytes(contractName.content).byteLength >= 128) {\n throw new Error('Contract name must be less than 128 bytes');\n }\n return {\n type: ClarityType.PrincipalContract,\n value: `${addressToString(address)}.${contractName.content}`,\n };\n}\nexport function contractPrincipalCVFromStandard(sp, contractName) {\n return {\n type: ClarityType.PrincipalContract,\n value: `${sp.value}.${contractName}`,\n };\n}\n//# sourceMappingURL=principalCV.js.map","import { ClarityType } from '../constants';\nexport function noneCV() {\n return { type: ClarityType.OptionalNone };\n}\nexport function someCV(value) {\n return { type: ClarityType.OptionalSome, value };\n}\nexport function optionalCVOf(value) {\n return value ? someCV(value) : noneCV();\n}\n//# sourceMappingURL=optionalCV.js.map","import { ClarityType } from '../constants';\nimport { isClarityName } from '../../utils';\nexport function tupleCV(data) {\n for (const key in data) {\n if (!isClarityName(key)) {\n throw new Error(`\"${key}\" is not a valid Clarity name`);\n }\n }\n return { type: ClarityType.Tuple, value: data };\n}\n//# sourceMappingURL=tupleCV.js.map","import { ripemd160 } from '@noble/hashes/ripemd160';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { sha512_256 } from '@noble/hashes/sha512';\nimport { utils } from '@noble/secp256k1';\nimport { bytesToHex, concatArray, concatBytes, utf8ToBytes } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport lodashCloneDeep from 'lodash.clonedeep';\nimport { deserializeCV, serializeCV } from './clarity';\nexport { verify as verifySignature } from '@noble/secp256k1';\nexport const randomBytes = (bytesLength) => utils.randomBytes(bytesLength);\nexport const leftPadHex = (hexString) => hexString.length % 2 ? `0${hexString}` : hexString;\nexport const leftPadHexToLength = (hexString, length) => hexString.padStart(length, '0');\nexport const rightPadHexToLength = (hexString, length) => hexString.padEnd(length, '0');\nexport const exceedsMaxLengthBytes = (string, maxLengthBytes) => string ? utf8ToBytes(string).length > maxLengthBytes : false;\nexport function cloneDeep(obj) {\n return lodashCloneDeep(obj);\n}\nexport function omit(obj, prop) {\n const clone = cloneDeep(obj);\n delete clone[prop];\n return clone;\n}\nexport const hash160 = (input) => {\n return ripemd160(sha256(input));\n};\nexport const txidFromData = (data) => {\n return bytesToHex(sha512_256(data));\n};\nexport const txidFromBytes = txidFromData;\nexport const hashP2PKH = (input) => {\n return bytesToHex(hash160(input));\n};\nexport const hashP2WPKH = (input) => {\n const keyHash = hash160(input);\n const redeemScript = concatBytes(new Uint8Array([0]), new Uint8Array([keyHash.length]), keyHash);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2SH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2SH multisig address can only contain up to 15 public keys');\n }\n const bytesArray = [];\n bytesArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n bytesArray.push(pubKey.length);\n bytesArray.push(pubKey);\n });\n bytesArray.push(80 + pubKeys.length);\n bytesArray.push(174);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2WSH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2WSH multisig address can only contain up to 15 public keys');\n }\n const scriptArray = [];\n scriptArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n scriptArray.push(pubKey.length);\n scriptArray.push(pubKey);\n });\n scriptArray.push(80 + pubKeys.length);\n scriptArray.push(174);\n const script = concatArray(scriptArray);\n const digest = sha256(script);\n const bytesArray = [];\n bytesArray.push(0);\n bytesArray.push(digest.length);\n bytesArray.push(digest);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport function isClarityName(name) {\n const regex = /^[a-zA-Z]([a-zA-Z0-9]\|[-_!?+<>=/])$\|^[-+=/]$\|^[<>]=?$/;\n return regex.test(name) && name.length < 128;\n}\nexport function cvToHex(cv) {\n const serialized = serializeCV(cv);\n return `0x${serialized}`;\n}\nexport function hexToCV(hex) {\n return deserializeCV(hex);\n}\nexport const parseReadOnlyResponse = (response) => {\n if (response.okay)\n return hexToCV(response.result);\n throw new Error(response.cause);\n};\nexport const validateStacksAddress = (address) => {\n try {\n c32addressDecode(address);\n return true;\n }\n catch (e) {\n return false;\n }\n};\nexport function parseContractId(contractId) {\n const [address, name] = contractId.split('.');\n if (!address \|\| !name)\n throw new Error(`Invalid contract identifier: ${contractId}`);\n return [address, name];\n}\n//# sourceMappingURL=utils.js.map","import { ClarityType } from '../constants';\nexport const stringAsciiCV = (data) => {\n return { type: ClarityType.StringASCII, value: data };\n};\nexport const stringUtf8CV = (data) => {\n return { type: ClarityType.StringUTF8, value: data };\n};\nexport const stringCV = (data, encoding) => {\n switch (encoding) {\n case 'ascii':\n return stringAsciiCV(data);\n case 'utf8':\n return stringUtf8CV(data);\n }\n};\n//# sourceMappingURL=stringCV.js.map","import { bytesToAscii, bytesToTwosBigInt, bytesToUtf8, hexToBytes } from '@stacks/common';\nimport { ClarityWireType, bufferCV, contractPrincipalCVFromAddress, falseCV, intCV, listCV, noneCV, responseErrorCV, responseOkCV, someCV, standardPrincipalCVFromAddress, stringAsciiCV, stringUtf8CV, trueCV, tupleCV, uintCV, } from '.';\nimport { BytesReader } from '../BytesReader';\nimport { DeserializationError } from '../errors';\nimport { deserializeAddress, deserializeLPString } from '../wire';\nexport function deserializeCV(serializedClarityValue) {\n let bytesReader;\n if (typeof serializedClarityValue === 'string') {\n const hasHexPrefix = serializedClarityValue.slice(0, 2).toLowerCase() === '0x';\n bytesReader = new BytesReader(hexToBytes(hasHexPrefix ? serializedClarityValue.slice(2) : serializedClarityValue));\n }\n else if (serializedClarityValue instanceof Uint8Array) {\n bytesReader = new BytesReader(serializedClarityValue);\n }\n else {\n bytesReader = serializedClarityValue;\n }\n const type = bytesReader.readUInt8Enum(ClarityWireType, n => {\n throw new DeserializationError(`Cannot recognize Clarity Type: ${n}`);\n });\n switch (type) {\n case ClarityWireType.int:\n return intCV(bytesToTwosBigInt(bytesReader.readBytes(16)));\n case ClarityWireType.uint:\n return uintCV(bytesReader.readBytes(16));\n case ClarityWireType.buffer:\n const bufferLength = bytesReader.readUInt32BE();\n return bufferCV(bytesReader.readBytes(bufferLength));\n case ClarityWireType.true:\n return trueCV();\n case ClarityWireType.false:\n return falseCV();\n case ClarityWireType.address:\n const sAddress = deserializeAddress(bytesReader);\n return standardPrincipalCVFromAddress(sAddress);\n case ClarityWireType.contract:\n const cAddress = deserializeAddress(bytesReader);\n const contractName = deserializeLPString(bytesReader);\n return contractPrincipalCVFromAddress(cAddress, contractName);\n case ClarityWireType.ok:\n return responseOkCV(deserializeCV(bytesReader));\n case ClarityWireType.err:\n return responseErrorCV(deserializeCV(bytesReader));\n case ClarityWireType.none:\n return noneCV();\n case ClarityWireType.some:\n return someCV(deserializeCV(bytesReader));\n case ClarityWireType.list:\n const listLength = bytesReader.readUInt32BE();\n const listContents = [];\n for (let i = 0; i < listLength; i++) {\n listContents.push(deserializeCV(bytesReader));\n }\n return listCV(listContents);\n case ClarityWireType.tuple:\n const tupleLength = bytesReader.readUInt32BE();\n const tupleContents = {};\n for (let i = 0; i < tupleLength; i++) {\n const clarityName = deserializeLPString(bytesReader).content;\n if (clarityName === undefined) {\n throw new DeserializationError('\"content\" is undefined');\n }\n tupleContents[clarityName] = deserializeCV(bytesReader);\n }\n return tupleCV(tupleContents);\n case ClarityWireType.ascii:\n const asciiStrLen = bytesReader.readUInt32BE();\n const asciiStr = bytesToAscii(bytesReader.readBytes(asciiStrLen));\n return stringAsciiCV(asciiStr);\n case ClarityWireType.utf8:\n const utf8StrLen = bytesReader.readUInt32BE();\n const utf8Str = bytesToUtf8(bytesReader.readBytes(utf8StrLen));\n return stringUtf8CV(utf8Str);\n default:\n throw new DeserializationError('Unable to deserialize Clarity Value from Uint8Array. Could not find valid Clarity Type.');\n }\n}\n//# sourceMappingURL=deserialize.js.map","import { ClarityType } from '../constants';\nexport function responseErrorCV(value) {\n return { type: ClarityType.ResponseErr, value };\n}\nexport function responseOkCV(value) {\n return { type: ClarityType.ResponseOk, value };\n}\n//# sourceMappingURL=responseCV.js.map","import { ClarityType } from '../constants';\nexport function listCV(values) {\n return { type: ClarityType.List, value: values };\n}\n//# sourceMappingURL=listCV.js.map","import { bytesToHex, bytesToUtf8, concatArray, hexToBytes, hexToInt, intToBigInt, intToBytes, intToHex, isInstance, utf8ToBytes, writeUInt32BE, writeUInt8, } from '@stacks/common';\nimport { BytesReader } from '../BytesReader';\nimport { deserializeCV, noneCV, serializeCVBytes, someCV, } from '../clarity';\nimport { AuthFieldType, COINBASE_BYTES_LENGTH, COMPRESSED_PUBKEY_LENGTH_BYTES, ClarityVersion, FungibleConditionCode, STRING_MAX_LENGTH, MEMO_MAX_LENGTH_BYTES, NonFungibleConditionCode, PayloadType, PostConditionPrincipalId, PostConditionType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, TenureChangeCause, UNCOMPRESSED_PUBKEY_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { DeserializationError, SerializationError } from '../errors';\nimport { compressPublicKey, createStacksPublicKey, uncompressPublicKey } from '../keys';\nimport { rightPadHexToLength } from '../utils';\nimport { createCoinbasePayload, createContractCallPayload, createLPList, createLPString, createMessageSignature, createNakamotoCoinbasePayload, createPoisonPayload, createSmartContractPayload, createTenureChangePayload, createTokenTransferPayload, createTransactionAuthField, } from './create';\nimport { StacksWireType, } from './types';\nexport function serializeStacksWire(wire) {\n return bytesToHex(serializeStacksWireBytes(wire));\n}\nexport function serializeStacksWireBytes(wire) {\n switch (wire.type) {\n case StacksWireType.Address:\n return serializeAddressBytes(wire);\n case StacksWireType.Principal:\n return serializePrincipalBytes(wire);\n case StacksWireType.LengthPrefixedString:\n return serializeLPStringBytes(wire);\n case StacksWireType.MemoString:\n return serializeMemoStringBytes(wire);\n case StacksWireType.Asset:\n return serializeAssetBytes(wire);\n case StacksWireType.PostCondition:\n return serializePostConditionWireBytes(wire);\n case StacksWireType.PublicKey:\n return serializePublicKeyBytes(wire);\n case StacksWireType.LengthPrefixedList:\n return serializeLPListBytes(wire);\n case StacksWireType.Payload:\n return serializePayloadBytes(wire);\n case StacksWireType.TransactionAuthField:\n return serializeTransactionAuthFieldBytes(wire);\n case StacksWireType.MessageSignature:\n return serializeMessageSignatureBytes(wire);\n }\n}\nexport function deserializeStacksWire(bytesReader, type, listType) {\n switch (type) {\n case StacksWireType.Address:\n return deserializeAddress(bytesReader);\n case StacksWireType.Principal:\n return deserializePrincipal(bytesReader);\n case StacksWireType.LengthPrefixedString:\n return deserializeLPString(bytesReader);\n case StacksWireType.MemoString:\n return deserializeMemoString(bytesReader);\n case StacksWireType.Asset:\n return deserializeAsset(bytesReader);\n case StacksWireType.PostCondition:\n return deserializePostConditionWire(bytesReader);\n case StacksWireType.PublicKey:\n return deserializePublicKey(bytesReader);\n case StacksWireType.Payload:\n return deserializePayload(bytesReader);\n case StacksWireType.LengthPrefixedList:\n if (!listType) {\n throw new DeserializationError('No list type specified');\n }\n return deserializeLPList(bytesReader, listType);\n case StacksWireType.MessageSignature:\n return deserializeMessageSignature(bytesReader);\n default:\n throw new Error('Could not recognize StacksWireType');\n }\n}\nexport function serializeAddress(address) {\n return bytesToHex(serializeAddressBytes(address));\n}\nexport function serializeAddressBytes(address) {\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(address.version, 1)));\n bytesArray.push(hexToBytes(address.hash160));\n return concatArray(bytesArray);\n}\nexport function deserializeAddress(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const version = hexToInt(bytesToHex(bytesReader.readBytes(1)));\n const data = bytesToHex(bytesReader.readBytes(20));\n return { type: StacksWireType.Address, version, hash160: data };\n}\nexport function serializePrincipal(principal) {\n return bytesToHex(serializePrincipalBytes(principal));\n}\nexport function serializePrincipalBytes(principal) {\n const bytesArray = [];\n bytesArray.push(principal.prefix);\n if (principal.prefix === PostConditionPrincipalId.Standard \|\|\n principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeAddressBytes(principal.address));\n }\n if (principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeLPStringBytes(principal.contractName));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePrincipal(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const prefix = bytesReader.readUInt8Enum(PostConditionPrincipalId, n => {\n throw new DeserializationError(`Unexpected Principal payload type: ${n}`);\n });\n if (prefix === PostConditionPrincipalId.Origin) {\n return { type: StacksWireType.Principal, prefix };\n }\n const address = deserializeAddress(bytesReader);\n if (prefix === PostConditionPrincipalId.Standard) {\n return { type: StacksWireType.Principal, prefix, address };\n }\n const contractName = deserializeLPString(bytesReader);\n return {\n type: StacksWireType.Principal,\n prefix,\n address,\n contractName,\n };\n}\nexport function serializeLPString(lps) {\n return bytesToHex(serializeLPStringBytes(lps));\n}\nexport function serializeLPStringBytes(lps) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(lps.content);\n const length = contentBytes.byteLength;\n bytesArray.push(hexToBytes(intToHex(length, lps.lengthPrefixBytes)));\n bytesArray.push(contentBytes);\n return concatArray(bytesArray);\n}\nexport function deserializeLPString(serialized, prefixBytes, maxLength) {\n prefixBytes = prefixBytes ? prefixBytes : 1;\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(prefixBytes)));\n const content = bytesToUtf8(bytesReader.readBytes(length));\n return createLPString(content, prefixBytes, maxLength ?? 128);\n}\nexport function serializeMemoString(memoString) {\n return bytesToHex(serializeMemoStringBytes(memoString));\n}\nexport function serializeMemoStringBytes(memoString) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(memoString.content);\n const paddedContent = rightPadHexToLength(bytesToHex(contentBytes), MEMO_MAX_LENGTH_BYTES 2);\n bytesArray.push(hexToBytes(paddedContent));\n return concatArray(bytesArray);\n}\nexport function deserializeMemoString(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n let content = bytesToUtf8(bytesReader.readBytes(MEMO_MAX_LENGTH_BYTES));\n content = content.replace(/\\u0000$/, '');\n return { type: StacksWireType.MemoString, content };\n}\nexport function serializeAsset(info) {\n return bytesToHex(serializeAssetBytes(info));\n}\nexport function serializeAssetBytes(info) {\n const bytesArray = [];\n bytesArray.push(serializeAddressBytes(info.address));\n bytesArray.push(serializeLPStringBytes(info.contractName));\n bytesArray.push(serializeLPStringBytes(info.assetName));\n return concatArray(bytesArray);\n}\nexport function deserializeAsset(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return {\n type: StacksWireType.Asset,\n address: deserializeAddress(bytesReader),\n contractName: deserializeLPString(bytesReader),\n assetName: deserializeLPString(bytesReader),\n };\n}\nexport function serializeLPList(lpList) {\n return bytesToHex(serializeLPListBytes(lpList));\n}\nexport function serializeLPListBytes(lpList) {\n const list = lpList.values;\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(list.length, lpList.lengthPrefixBytes)));\n for (const l of list) {\n bytesArray.push(serializeStacksWireBytes(l));\n }\n return concatArray(bytesArray);\n}\nexport function deserializeLPList(serialized, type, lengthPrefixBytes) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(lengthPrefixBytes \|\| 4)));\n const l = [];\n for (let index = 0; index < length; index++) {\n switch (type) {\n case StacksWireType.Address:\n l.push(deserializeAddress(bytesReader));\n break;\n case StacksWireType.LengthPrefixedString:\n l.push(deserializeLPString(bytesReader));\n break;\n case StacksWireType.MemoString:\n l.push(deserializeMemoString(bytesReader));\n break;\n case StacksWireType.Asset:\n l.push(deserializeAsset(bytesReader));\n break;\n case StacksWireType.PostCondition:\n l.push(deserializePostConditionWire(bytesReader));\n break;\n case StacksWireType.PublicKey:\n l.push(deserializePublicKey(bytesReader));\n break;\n case StacksWireType.TransactionAuthField:\n l.push(deserializeTransactionAuthField(bytesReader));\n break;\n }\n }\n return createLPList(l, lengthPrefixBytes);\n}\nexport function serializePostConditionWire(postCondition) {\n return bytesToHex(serializePostConditionWireBytes(postCondition));\n}\nexport function serializePostConditionWireBytes(postCondition) {\n const bytesArray = [];\n bytesArray.push(postCondition.conditionType);\n bytesArray.push(serializePrincipalBytes(postCondition.principal));\n if (postCondition.conditionType === PostConditionType.Fungible \|\|\n postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeAssetBytes(postCondition.asset));\n }\n if (postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeCVBytes(postCondition.assetName));\n }\n bytesArray.push(postCondition.conditionCode);\n if (postCondition.conditionType === PostConditionType.STX \|\|\n postCondition.conditionType === PostConditionType.Fungible) {\n if (postCondition.amount > BigInt('0xffffffffffffffff'))\n throw new SerializationError('The post-condition amount may not be larger than 8 bytes');\n bytesArray.push(intToBytes(postCondition.amount, 8));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePostConditionWire(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const postConditionType = bytesReader.readUInt8Enum(PostConditionType, n => {\n throw new DeserializationError(`Could not read ${n} as PostConditionType`);\n });\n const principal = deserializePrincipal(bytesReader);\n let conditionCode;\n let asset;\n let amount;\n switch (postConditionType) {\n case PostConditionType.STX:\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal,\n conditionCode,\n amount,\n };\n case PostConditionType.Fungible:\n asset = deserializeAsset(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal,\n conditionCode,\n amount,\n asset: asset,\n };\n case PostConditionType.NonFungible:\n asset = deserializeAsset(bytesReader);\n const assetName = deserializeCV(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(NonFungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal,\n conditionCode,\n asset,\n assetName,\n };\n }\n}\nexport function serializePayload(payload) {\n return bytesToHex(serializePayloadBytes(payload));\n}\nexport function serializePayloadBytes(payload) {\n const bytesArray = [];\n bytesArray.push(payload.payloadType);\n switch (payload.payloadType) {\n case PayloadType.TokenTransfer:\n bytesArray.push(serializeCVBytes(payload.recipient));\n bytesArray.push(intToBytes(payload.amount, 8));\n bytesArray.push(serializeStacksWireBytes(payload.memo));\n break;\n case PayloadType.ContractCall:\n bytesArray.push(serializeStacksWireBytes(payload.contractAddress));\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.functionName));\n const numArgs = new Uint8Array(4);\n writeUInt32BE(numArgs, payload.functionArgs.length, 0);\n bytesArray.push(numArgs);\n payload.functionArgs.forEach(arg => {\n bytesArray.push(serializeCVBytes(arg));\n });\n break;\n case PayloadType.SmartContract:\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.VersionedSmartContract:\n bytesArray.push(payload.clarityVersion);\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.PoisonMicroblock:\n break;\n case PayloadType.Coinbase:\n bytesArray.push(payload.coinbaseBytes);\n break;\n case PayloadType.CoinbaseToAltRecipient:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient));\n break;\n case PayloadType.NakamotoCoinbase:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient ? someCV(payload.recipient) : noneCV()));\n bytesArray.push(payload.vrfProof);\n break;\n case PayloadType.TenureChange:\n bytesArray.push(hexToBytes(payload.tenureHash));\n bytesArray.push(hexToBytes(payload.previousTenureHash));\n bytesArray.push(hexToBytes(payload.burnViewHash));\n bytesArray.push(hexToBytes(payload.previousTenureEnd));\n bytesArray.push(writeUInt32BE(new Uint8Array(4), payload.previousTenureBlocks));\n bytesArray.push(writeUInt8(new Uint8Array(1), payload.cause));\n bytesArray.push(hexToBytes(payload.publicKeyHash));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializePayload(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const payloadType = bytesReader.readUInt8Enum(PayloadType, n => {\n throw new Error(`Cannot recognize PayloadType: ${n}`);\n });\n switch (payloadType) {\n case PayloadType.TokenTransfer:\n const recipient = deserializeCV(bytesReader);\n const amount = intToBigInt(bytesReader.readBytes(8));\n const memo = deserializeMemoString(bytesReader);\n return createTokenTransferPayload(recipient, amount, memo);\n case PayloadType.ContractCall:\n const contractAddress = deserializeAddress(bytesReader);\n const contractCallName = deserializeLPString(bytesReader);\n const functionName = deserializeLPString(bytesReader);\n const functionArgs = [];\n const numberOfArgs = bytesReader.readUInt32BE();\n for (let i = 0; i < numberOfArgs; i++) {\n const clarityValue = deserializeCV(bytesReader);\n functionArgs.push(clarityValue);\n }\n return createContractCallPayload(contractAddress, contractCallName, functionName, functionArgs);\n case PayloadType.SmartContract:\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, 100000);\n return createSmartContractPayload(smartContractName, codeBody);\n case PayloadType.VersionedSmartContract: {\n const clarityVersion = bytesReader.readUInt8Enum(ClarityVersion, n => {\n throw new Error(`Cannot recognize ClarityVersion: ${n}`);\n });\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, STRING_MAX_LENGTH);\n return createSmartContractPayload(smartContractName, codeBody, clarityVersion);\n }\n case PayloadType.PoisonMicroblock:\n return createPoisonPayload();\n case PayloadType.Coinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n return createCoinbasePayload(coinbaseBytes);\n }\n case PayloadType.CoinbaseToAltRecipient: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const altRecipient = deserializeCV(bytesReader);\n return createCoinbasePayload(coinbaseBytes, altRecipient);\n }\n case PayloadType.NakamotoCoinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const recipient = deserializeCV(bytesReader);\n const vrfProof = bytesReader.readBytes(VRF_PROOF_BYTES_LENGTH);\n return createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof);\n }\n case PayloadType.TenureChange:\n const tenureHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureHash = bytesToHex(bytesReader.readBytes(20));\n const burnViewHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureEnd = bytesToHex(bytesReader.readBytes(32));\n const previousTenureBlocks = bytesReader.readUInt32BE();\n const cause = bytesReader.readUInt8Enum(TenureChangeCause, n => {\n throw new Error(`Cannot recognize TenureChangeCause: ${n}`);\n });\n const publicKeyHash = bytesToHex(bytesReader.readBytes(20));\n return createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash);\n }\n}\nexport function deserializeMessageSignature(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return createMessageSignature(bytesToHex(bytesReader.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)));\n}\nexport function deserializeTransactionAuthField(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const authFieldType = bytesReader.readUInt8Enum(AuthFieldType, n => {\n throw new DeserializationError(`Could not read ${n} as AuthFieldType`);\n });\n switch (authFieldType) {\n case AuthFieldType.PublicKeyCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializePublicKey(bytesReader));\n case AuthFieldType.PublicKeyUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, createStacksPublicKey(uncompressPublicKey(deserializePublicKey(bytesReader).data)));\n case AuthFieldType.SignatureCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializeMessageSignature(bytesReader));\n case AuthFieldType.SignatureUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, deserializeMessageSignature(bytesReader));\n default:\n throw new Error(`Unknown auth field type: ${JSON.stringify(authFieldType)}`);\n }\n}\nexport function serializeMessageSignature(messageSignature) {\n return bytesToHex(serializeMessageSignatureBytes(messageSignature));\n}\nexport function serializeMessageSignatureBytes(messageSignature) {\n return hexToBytes(messageSignature.data);\n}\nexport function serializeTransactionAuthField(field) {\n return bytesToHex(serializeTransactionAuthFieldBytes(field));\n}\nexport function serializeTransactionAuthFieldBytes(field) {\n const bytesArray = [];\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.PublicKeyCompressed\n : AuthFieldType.PublicKeyUncompressed);\n bytesArray.push(hexToBytes(compressPublicKey(field.contents.data)));\n break;\n case StacksWireType.MessageSignature:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.SignatureCompressed\n : AuthFieldType.SignatureUncompressed);\n bytesArray.push(serializeMessageSignatureBytes(field.contents));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function serializePublicKey(key) {\n return bytesToHex(serializePublicKeyBytes(key));\n}\nexport function serializePublicKeyBytes(key) {\n return key.data.slice();\n}\nexport function deserializePublicKey(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const fieldId = bytesReader.readUInt8();\n const keyLength = fieldId === 4 ? UNCOMPRESSED_PUBKEY_LENGTH_BYTES : COMPRESSED_PUBKEY_LENGTH_BYTES;\n return createStacksPublicKey(concatArray([fieldId, bytesReader.readBytes(keyLength)]));\n}\n//# sourceMappingURL=serialization.js.map","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, Point, Signature, signSync, utils, } from '@noble/secp256k1';\nimport { bytesToHex, hexToBigInt, hexToBytes, intToHex, parseRecoverableSignatureVrs, PRIVATE_KEY_BYTES_COMPRESSED, privateKeyToBytes, signatureRsvToVrs, signatureVrsToRsv, } from '@stacks/common';\nimport { networkFrom, STACKS_MAINNET } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { addressHashModeToVersion } from './address';\nimport { AddressHashMode, PubKeyEncoding } from './constants';\nimport { hash160, hashP2PKH } from './utils';\nimport { addressFromVersionHash, addressToString, StacksWireType } from './wire';\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport function getAddressFromPrivateKey(privateKey, network = 'mainnet') {\n network = networkFrom(network);\n const publicKey = privateKeyToPublic(privateKey);\n return getAddressFromPublicKey(publicKey, network);\n}\nexport function getAddressFromPublicKey(publicKey, network = 'mainnet') {\n network = networkFrom(network);\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n const addrVer = addressHashModeToVersion(AddressHashMode.P2PKH, network);\n const addr = addressFromVersionHash(addrVer, hashP2PKH(publicKey));\n const addrString = addressToString(addr);\n return addrString;\n}\nexport function createStacksPublicKey(publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return {\n type: StacksWireType.PublicKey,\n data: publicKey,\n };\n}\nexport function publicKeyFromSignatureVrs(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n const parsedSignature = parseRecoverableSignatureVrs(messageSignature);\n const signature = new Signature(hexToBigInt(parsedSignature.r), hexToBigInt(parsedSignature.s));\n const point = Point.fromSignature(messageHash, signature, parsedSignature.recoveryId);\n const compressed = pubKeyEncoding === PubKeyEncoding.Compressed;\n return point.toHex(compressed);\n}\nexport function publicKeyFromSignatureRsv(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n return publicKeyFromSignatureVrs(messageHash, signatureRsvToVrs(messageSignature), pubKeyEncoding);\n}\nexport function privateKeyToHex(publicKey) {\n return typeof publicKey === 'string' ? publicKey : bytesToHex(publicKey);\n}\nexport const publicKeyToHex = privateKeyToHex;\nexport const isPrivateKeyCompressed = privateKeyIsCompressed;\nexport function privateKeyIsCompressed(privateKey) {\n const length = typeof privateKey === 'string' ? privateKey.length / 2 : privateKey.byteLength;\n return length === PRIVATE_KEY_BYTES_COMPRESSED;\n}\nexport const isPublicKeyCompressed = publicKeyIsCompressed;\nexport function publicKeyIsCompressed(publicKey) {\n return !publicKeyToHex(publicKey).startsWith('04');\n}\nexport function privateKeyToPublic(privateKey) {\n privateKey = privateKeyToBytes(privateKey);\n const isCompressed = privateKeyIsCompressed(privateKey);\n return bytesToHex(nobleGetPublicKey(privateKey.slice(0, 32), isCompressed));\n}\nexport function compressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(true);\n}\nexport function uncompressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(false);\n}\nexport const makeRandomPrivKey = randomPrivateKey;\nexport function randomPrivateKey() {\n return compressPrivateKey(utils.randomPrivateKey());\n}\nexport function signWithKey(privateKey, messageHash) {\n privateKey = privateKeyToBytes(privateKey);\n const [rawSignature, recoveryId] = signSync(messageHash, privateKey.slice(0, 32), {\n canonical: true,\n recovered: true,\n });\n if (recoveryId == null) {\n throw new Error('No signature recoveryId received');\n }\n const recoveryIdHex = intToHex(recoveryId, 1);\n return recoveryIdHex + Signature.fromHex(rawSignature).toCompactHex();\n}\nexport function signMessageHashRsv({ messageHash, privateKey, }) {\n return signatureVrsToRsv(signWithKey(privateKey, messageHash));\n}\nexport function compressPrivateKey(privateKey) {\n privateKey = privateKeyToHex(privateKey);\n return privateKey.length == PRIVATE_KEY_BYTES_COMPRESSED 2\n ? privateKey\n : `${privateKey}01`;\n}\nexport function privateKeyToAddress(privateKey, network) {\n const publicKey = privateKeyToPublic(privateKey);\n return publicKeyToAddressSingleSig(publicKey, network);\n}\nexport function publicKeyToAddress(...args) {\n if (typeof args[0] === 'number')\n return _publicKeyToAddress(...args);\n return publicKeyToAddressSingleSig(...args);\n}\nfunction _publicKeyToAddress(version, publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(version, bytesToHex(hash160(publicKey)));\n}\nexport function publicKeyToAddressSingleSig(publicKey, network) {\n network = network ? networkFrom(network) : STACKS_MAINNET;\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(network.addressVersion.singleSig, bytesToHex(hash160(publicKey)));\n}\n//# sourceMappingURL=keys.js.map","import { asciiToBytes, bigIntToBytes, bytesToHex, concatArray, concatBytes, hexToBytes, toTwos, utf8ToBytes, writeUInt32BE, } from '@stacks/common';\nimport { CLARITY_INT_BYTE_SIZE, CLARITY_INT_SIZE } from '../constants';\nimport { SerializationError } from '../errors';\nimport { parseContractId } from '../utils';\nimport { createAddress, createLPString, serializeAddressBytes, serializeLPStringBytes, } from '../wire';\nimport { ClarityType, clarityTypeToByte } from './constants';\nfunction bytesWithTypeID(typeId, bytes) {\n return concatArray([clarityTypeToByte(typeId), bytes]);\n}\nfunction serializeBoolCV(value) {\n return new Uint8Array([clarityTypeToByte(value.type)]);\n}\nfunction serializeOptionalCV(cv) {\n if (cv.type === ClarityType.OptionalNone) {\n return new Uint8Array([clarityTypeToByte(cv.type)]);\n }\n else {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n }\n}\nfunction serializeBufferCV(cv) {\n const length = new Uint8Array(4);\n writeUInt32BE(length, Math.ceil(cv.value.length / 2), 0);\n return bytesWithTypeID(cv.type, concatBytes(length, hexToBytes(cv.value)));\n}\nfunction serializeIntCV(cv) {\n const bytes = bigIntToBytes(toTwos(BigInt(cv.value), BigInt(CLARITY_INT_SIZE)), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeUIntCV(cv) {\n const bytes = bigIntToBytes(BigInt(cv.value), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeStandardPrincipalCV(cv) {\n return bytesWithTypeID(cv.type, serializeAddressBytes(createAddress(cv.value)));\n}\nfunction serializeContractPrincipalCV(cv) {\n const [address, name] = parseContractId(cv.value);\n return bytesWithTypeID(cv.type, concatBytes(serializeAddressBytes(createAddress(address)), serializeLPStringBytes(createLPString(name))));\n}\nfunction serializeResponseCV(cv) {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n}\nfunction serializeListCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, cv.value.length, 0);\n bytesArray.push(length);\n for (const value of cv.value) {\n const serializedValue = serializeCVBytes(value);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeTupleCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, Object.keys(cv.value).length, 0);\n bytesArray.push(length);\n const lexicographicOrder = Object.keys(cv.value).sort((a, b) => a.localeCompare(b));\n for (const key of lexicographicOrder) {\n const nameWithLength = createLPString(key);\n bytesArray.push(serializeLPStringBytes(nameWithLength));\n const serializedValue = serializeCVBytes(cv.value[key]);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringCV(cv, encoding) {\n const bytesArray = [];\n const str = encoding == 'ascii' ? asciiToBytes(cv.value) : utf8ToBytes(cv.value);\n const len = new Uint8Array(4);\n writeUInt32BE(len, str.length, 0);\n bytesArray.push(len);\n bytesArray.push(str);\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringAsciiCV(cv) {\n return serializeStringCV(cv, 'ascii');\n}\nfunction serializeStringUtf8CV(cv) {\n return serializeStringCV(cv, 'utf8');\n}\nexport function serializeCV(value) {\n return bytesToHex(serializeCVBytes(value));\n}\nexport function serializeCVBytes(value) {\n switch (value.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return serializeBoolCV(value);\n case ClarityType.OptionalNone:\n case ClarityType.OptionalSome:\n return serializeOptionalCV(value);\n case ClarityType.Buffer:\n return serializeBufferCV(value);\n case ClarityType.UInt:\n return serializeUIntCV(value);\n case ClarityType.Int:\n return serializeIntCV(value);\n case ClarityType.PrincipalStandard:\n return serializeStandardPrincipalCV(value);\n case ClarityType.PrincipalContract:\n return serializeContractPrincipalCV(value);\n case ClarityType.ResponseOk:\n case ClarityType.ResponseErr:\n return serializeResponseCV(value);\n case ClarityType.List:\n return serializeListCV(value);\n case ClarityType.Tuple:\n return serializeTupleCV(value);\n case ClarityType.StringASCII:\n return serializeStringAsciiCV(value);\n case ClarityType.StringUTF8:\n return serializeStringUtf8CV(value);\n default:\n throw new SerializationError('Unable to serialize. Invalid Clarity Value.');\n }\n}\n//# sourceMappingURL=serialize.js.map","import { STACKS_MAINNET, TransactionVersion, networkFrom, } from '@stacks/network';\nimport { AddressHashMode, AddressVersion } from './constants';\nexport function addressHashModeToVersion(hashMode, network) {\n network = networkFrom(network ?? STACKS_MAINNET);\n switch (hashMode) {\n case AddressHashMode.P2PKH:\n switch (network.transactionVersion) {\n case TransactionVersion.Mainnet:\n return AddressVersion.MainnetSingleSig;\n case TransactionVersion.Testnet:\n return AddressVersion.TestnetSingleSig;\n default:\n throw new Error(`Unexpected transactionVersion ${network.transactionVersion} for hashMode ${hashMode}`);\n }\n case AddressHashMode.P2SH:\n case AddressHashMode.P2SHNonSequential:\n case AddressHashMode.P2WPKH:\n case AddressHashMode.P2WSH:\n case AddressHashMode.P2WSHNonSequential:\n switch (network.transactionVersion) {\n case TransactionVersion.Mainnet:\n return AddressVersion.MainnetMultiSig;\n case TransactionVersion.Testnet:\n return AddressVersion.TestnetMultiSig;\n default:\n throw new Error(`Unexpected transactionVersion ${network.transactionVersion} for hashMode ${hashMode}`);\n }\n default:\n throw new Error(`Unexpected hashMode ${hashMode}`);\n }\n}\n//# sourceMappingURL=address.js.map","import { bytesToHex, concatArray, hexToBytes, intToBigInt, intToBytes, writeUInt16BE, } from '@stacks/common';\nimport { AddressHashMode, AuthType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { DeserializationError, SigningError, VerificationError } from './errors';\nimport { createStacksPublicKey, privateKeyToPublic, publicKeyFromSignatureVrs, publicKeyIsCompressed, signWithKey, } from './keys';\nimport { cloneDeep, leftPadHex, txidFromData } from './utils';\nimport { addressFromPublicKeys, createEmptyAddress, createLPList, deserializeLPList, deserializeMessageSignature, serializeLPListBytes, serializeMessageSignatureBytes, StacksWireType, } from './wire';\nexport function emptyMessageSignature() {\n return {\n type: StacksWireType.MessageSignature,\n data: bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)),\n };\n}\nexport function createSpendingCondition(options) {\n if ('publicKey' in options) {\n return createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n return createMultiSigSpendingCondition(AddressHashMode.P2SH, options.numSignatures, options.publicKeys, options.nonce, options.fee);\n}\nexport function createSingleSigSpendingCondition(hashMode, pubKey, nonce, fee) {\n const signer = addressFromPublicKeys(0, hashMode, 1, [createStacksPublicKey(pubKey)]).hash160;\n const keyEncoding = publicKeyIsCompressed(pubKey)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n keyEncoding,\n signature: emptyMessageSignature(),\n };\n}\nexport function createMultiSigSpendingCondition(hashMode, numSigs, pubKeys, nonce, fee) {\n const stacksPublicKeys = pubKeys.map(createStacksPublicKey);\n const signer = addressFromPublicKeys(0, hashMode, numSigs, stacksPublicKeys).hash160;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n fields: [],\n signaturesRequired: numSigs,\n };\n}\nexport function isSingleSig(condition) {\n return 'signature' in condition;\n}\nexport function isSequentialMultiSig(hashMode) {\n return hashMode === AddressHashMode.P2SH \|\| hashMode === AddressHashMode.P2WSH;\n}\nexport function isNonSequentialMultiSig(hashMode) {\n return (hashMode === AddressHashMode.P2SHNonSequential \|\|\n hashMode === AddressHashMode.P2WSHNonSequential);\n}\nfunction clearCondition(condition) {\n const cloned = cloneDeep(condition);\n cloned.nonce = 0;\n cloned.fee = 0;\n if (isSingleSig(cloned)) {\n cloned.signature = emptyMessageSignature();\n }\n else {\n cloned.fields = [];\n }\n return {\n ...cloned,\n nonce: BigInt(0),\n fee: BigInt(0),\n };\n}\nexport function serializeSingleSigSpendingCondition(condition) {\n return bytesToHex(serializeSingleSigSpendingConditionBytes(condition));\n}\nexport function serializeSingleSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n condition.keyEncoding,\n serializeMessageSignatureBytes(condition.signature),\n ];\n return concatArray(bytesArray);\n}\nexport function serializeMultiSigSpendingCondition(condition) {\n return bytesToHex(serializeMultiSigSpendingConditionBytes(condition));\n}\nexport function serializeMultiSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n ];\n const fields = createLPList(condition.fields);\n bytesArray.push(serializeLPListBytes(fields));\n const numSigs = new Uint8Array(2);\n writeUInt16BE(numSigs, condition.signaturesRequired, 0);\n bytesArray.push(numSigs);\n return concatArray(bytesArray);\n}\nexport function deserializeSingleSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const fee = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const keyEncoding = bytesReader.readUInt8Enum(PubKeyEncoding, n => {\n throw new DeserializationError(`Could not parse ${n} as PubKeyEncoding`);\n });\n if (hashMode === AddressHashMode.P2WPKH && keyEncoding != PubKeyEncoding.Compressed) {\n throw new DeserializationError('Failed to parse singlesig spending condition: incomaptible hash mode and key encoding');\n }\n const signature = deserializeMessageSignature(bytesReader);\n return {\n hashMode,\n signer,\n nonce,\n fee,\n keyEncoding,\n signature,\n };\n}\nexport function deserializeMultiSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fee = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fields = deserializeLPList(bytesReader, StacksWireType.TransactionAuthField)\n .values;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Failed to parse multisig spending condition: too many signatures');\n break;\n }\n }\n const signaturesRequired = bytesReader.readUInt16BE();\n if (haveUncompressed &&\n (hashMode === AddressHashMode.P2WSH \|\| hashMode === AddressHashMode.P2WSHNonSequential)) {\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n }\n return {\n hashMode,\n signer,\n nonce,\n fee,\n fields,\n signaturesRequired,\n };\n}\nexport function serializeSpendingCondition(condition) {\n return bytesToHex(serializeSpendingConditionBytes(condition));\n}\nexport function serializeSpendingConditionBytes(condition) {\n if (isSingleSig(condition))\n return serializeSingleSigSpendingConditionBytes(condition);\n return serializeMultiSigSpendingConditionBytes(condition);\n}\nexport function deserializeSpendingCondition(bytesReader) {\n const hashMode = bytesReader.readUInt8Enum(AddressHashMode, n => {\n throw new DeserializationError(`Could not parse ${n} as AddressHashMode`);\n });\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n return deserializeSingleSigSpendingCondition(hashMode, bytesReader);\n }\n else {\n return deserializeMultiSigSpendingCondition(hashMode, bytesReader);\n }\n}\nexport function sigHashPreSign(curSigHash, authType, fee, nonce) {\n const hashLength = 32 + 1 + 8 + 8;\n const sigHash = curSigHash +\n bytesToHex(new Uint8Array([authType])) +\n bytesToHex(intToBytes(fee, 8)) +\n bytesToHex(intToBytes(nonce, 8));\n if (hexToBytes(sigHash).byteLength !== hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(hexToBytes(sigHash));\n}\nfunction sigHashPostSign(curSigHash, pubKey, signature) {\n const hashLength = 32 + 1 + RECOVERABLE_ECDSA_SIG_LENGTH_BYTES;\n const pubKeyEncoding = publicKeyIsCompressed(pubKey.data)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n const sigHash = curSigHash + leftPadHex(pubKeyEncoding.toString(16)) + signature;\n const sigHashBytes = hexToBytes(sigHash);\n if (sigHashBytes.byteLength > hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(sigHashBytes);\n}\nexport function nextSignature(curSigHash, authType, fee, nonce, privateKey) {\n const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);\n const signature = signWithKey(privateKey, sigHashPre);\n const publicKey = createStacksPublicKey(privateKeyToPublic(privateKey));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n nextSig: signature,\n nextSigHash,\n };\n}\nexport function nextVerification(initialSigHash, authType, fee, nonce, pubKeyEncoding, signature) {\n const sigHashPre = sigHashPreSign(initialSigHash, authType, fee, nonce);\n const publicKey = createStacksPublicKey(publicKeyFromSignatureVrs(sigHashPre, signature, pubKeyEncoding));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n pubKey: publicKey,\n nextSigHash,\n };\n}\nfunction newInitialSigHash() {\n const spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, '', 0, 0);\n spendingCondition.signer = createEmptyAddress().hash160;\n spendingCondition.keyEncoding = PubKeyEncoding.Compressed;\n spendingCondition.signature = emptyMessageSignature();\n return spendingCondition;\n}\nfunction verify(condition, initialSigHash, authType) {\n if (isSingleSig(condition)) {\n return verifySingleSig(condition, initialSigHash, authType);\n }\n else {\n return verifyMultiSig(condition, initialSigHash, authType);\n }\n}\nfunction verifySingleSig(condition, initialSigHash, authType) {\n const { pubKey, nextSigHash } = nextVerification(initialSigHash, authType, condition.fee, condition.nonce, condition.keyEncoding, condition.signature.data);\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, 1, [pubKey]).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return nextSigHash;\n}\nfunction verifyMultiSig(condition, initialSigHash, authType) {\n const publicKeys = [];\n let curSigHash = initialSigHash;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of condition.fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n publicKeys.push(field.contents);\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n const { pubKey, nextSigHash } = nextVerification(curSigHash, authType, condition.fee, condition.nonce, field.pubKeyEncoding, field.contents.data);\n if (isSequentialMultiSig(condition.hashMode)) {\n curSigHash = nextSigHash;\n }\n publicKeys.push(pubKey);\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Too many signatures');\n break;\n }\n }\n if ((isSequentialMultiSig(condition.hashMode) && numSigs !== condition.signaturesRequired) \|\|\n (isNonSequentialMultiSig(condition.hashMode) && numSigs < condition.signaturesRequired))\n throw new VerificationError('Incorrect number of signatures');\n if (haveUncompressed &&\n (condition.hashMode === AddressHashMode.P2WSH \|\|\n condition.hashMode === AddressHashMode.P2WSHNonSequential))\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, condition.signaturesRequired, publicKeys).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return curSigHash;\n}\nexport function createStandardAuth(spendingCondition) {\n return {\n authType: AuthType.Standard,\n spendingCondition,\n };\n}\nexport function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {\n return {\n authType: AuthType.Sponsored,\n spendingCondition,\n sponsorSpendingCondition: sponsorSpendingCondition\n ? sponsorSpendingCondition\n : createSingleSigSpendingCondition(AddressHashMode.P2PKH, '0'.repeat(66), 0, 0),\n };\n}\nexport function intoInitialSighashAuth(auth) {\n if (auth.spendingCondition) {\n switch (auth.authType) {\n case AuthType.Standard:\n return createStandardAuth(clearCondition(auth.spendingCondition));\n case AuthType.Sponsored:\n return createSponsoredAuth(clearCondition(auth.spendingCondition), newInitialSigHash());\n default:\n throw new SigningError('Unexpected authorization type for signing');\n }\n }\n throw new Error('Authorization missing SpendingCondition');\n}\nexport function verifyOrigin(auth, initialSigHash) {\n switch (auth.authType) {\n case AuthType.Standard:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n case AuthType.Sponsored:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n default:\n throw new SigningError('Invalid origin auth type');\n }\n}\nexport function setFee(auth, amount) {\n switch (auth.authType) {\n case AuthType.Standard:\n const spendingCondition = {\n ...auth.spendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, spendingCondition };\n case AuthType.Sponsored:\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, sponsorSpendingCondition };\n }\n}\nexport function getFee(auth) {\n switch (auth.authType) {\n case AuthType.Standard:\n return auth.spendingCondition.fee;\n case AuthType.Sponsored:\n return auth.sponsorSpendingCondition.fee;\n }\n}\nexport function setNonce(auth, nonce) {\n const spendingCondition = {\n ...auth.spendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n spendingCondition,\n };\n}\nexport function setSponsorNonce(auth, nonce) {\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n sponsorSpendingCondition,\n };\n}\nexport function setSponsor(auth, sponsorSpendingCondition) {\n const sc = {\n ...sponsorSpendingCondition,\n nonce: intToBigInt(sponsorSpendingCondition.nonce),\n fee: intToBigInt(sponsorSpendingCondition.fee),\n };\n return {\n ...auth,\n sponsorSpendingCondition: sc,\n };\n}\nexport function serializeAuthorization(auth) {\n return bytesToHex(serializeAuthorizationBytes(auth));\n}\nexport function serializeAuthorizationBytes(auth) {\n const bytesArray = [];\n bytesArray.push(auth.authType);\n switch (auth.authType) {\n case AuthType.Standard:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n break;\n case AuthType.Sponsored:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n bytesArray.push(serializeSpendingConditionBytes(auth.sponsorSpendingCondition));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializeAuthorization(bytesReader) {\n const authType = bytesReader.readUInt8Enum(AuthType, n => {\n throw new DeserializationError(`Could not parse ${n} as AuthType`);\n });\n let spendingCondition;\n switch (authType) {\n case AuthType.Standard:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n return createStandardAuth(spendingCondition);\n case AuthType.Sponsored:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n const sponsorSpendingCondition = deserializeSpendingCondition(bytesReader);\n return createSponsoredAuth(spendingCondition, sponsorSpendingCondition);\n }\n}\n//# sourceMappingURL=authorization.js.map","import { ClarityType } from './constants';\nimport { asciiToBytes, bytesToAscii, hexToBytes, utf8ToBytes } from '@stacks/common';\nexport function cvToString(val, encoding = 'hex') {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return 'true';\n case ClarityType.BoolFalse:\n return 'false';\n case ClarityType.Int:\n return val.value.toString();\n case ClarityType.UInt:\n return `u${val.value.toString()}`;\n case ClarityType.Buffer:\n if (encoding === 'tryAscii') {\n const str = bytesToAscii(hexToBytes(val.value));\n if (/[ -~]/.test(str)) {\n return JSON.stringify(str);\n }\n }\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return 'none';\n case ClarityType.OptionalSome:\n return `(some ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseErr:\n return `(err ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseOk:\n return `(ok ${cvToString(val.value, encoding)})`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return `(list ${val.value.map(v => cvToString(v, encoding)).join(' ')})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${cvToString(val.value[key], encoding)})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `\"${val.value}\"`;\n case ClarityType.StringUTF8:\n return `u\"${val.value}\"`;\n }\n}\nexport function cvToValue(val, strictJsonCompat = false) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return true;\n case ClarityType.BoolFalse:\n return false;\n case ClarityType.Int:\n case ClarityType.UInt:\n if (strictJsonCompat) {\n return val.value.toString();\n }\n return val.value;\n case ClarityType.Buffer:\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return null;\n case ClarityType.OptionalSome:\n return cvToJSON(val.value);\n case ClarityType.ResponseErr:\n return cvToJSON(val.value);\n case ClarityType.ResponseOk:\n return cvToJSON(val.value);\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return val.value.map(v => cvToJSON(v));\n case ClarityType.Tuple:\n const result = {};\n Object.keys(val.value).forEach(key => {\n result[key] = cvToJSON(val.value[key]);\n });\n return result;\n case ClarityType.StringASCII:\n return val.value;\n case ClarityType.StringUTF8:\n return val.value;\n }\n}\nexport function cvToJSON(val) {\n switch (val.type) {\n case ClarityType.ResponseErr:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: false };\n case ClarityType.ResponseOk:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: true };\n default:\n return { type: getCVTypeString(val), value: cvToValue(val, true) };\n }\n}\nexport function getCVTypeString(val) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return 'bool';\n case ClarityType.Int:\n return 'int';\n case ClarityType.UInt:\n return 'uint';\n case ClarityType.Buffer:\n return `(buff ${Math.ceil(val.value.length / 2)})`;\n case ClarityType.OptionalNone:\n return '(optional none)';\n case ClarityType.OptionalSome:\n return `(optional ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseErr:\n return `(response UnknownType ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseOk:\n return `(response ${getCVTypeString(val.value)} UnknownType)`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return 'principal';\n case ClarityType.List:\n return `(list ${val.value.length} ${val.value.length ? getCVTypeString(val.value[0]) : 'UnknownType'})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${getCVTypeString(val.value[key])})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `(string-ascii ${asciiToBytes(val.value).length})`;\n case ClarityType.StringUTF8:\n return `(string-utf8 ${utf8ToBytes(val.value).length})`;\n }\n}\nexport function isClarityType(input, withType) {\n return input.type === withType;\n}\n//# sourceMappingURL=clarityValue.js.map","import { hexToBytes, utf8ToBytes } from '@stacks/common';\nimport { ClarityType, bufferCV, bufferCVFromString, contractPrincipalCV, falseCV, getCVTypeString, intCV, noneCV, someCV, standardPrincipalCV, stringAsciiCV, stringUtf8CV, trueCV, uintCV, } from './clarity';\nimport { NotImplementedError } from './errors';\nimport { cloneDeep } from './utils';\nexport var ClarityAbiTypeId;\n(function (ClarityAbiTypeId) {\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeUInt128\"] = 1] = \"ClarityAbiTypeUInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeInt128\"] = 2] = \"ClarityAbiTypeInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBool\"] = 3] = \"ClarityAbiTypeBool\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypePrincipal\"] = 4] = \"ClarityAbiTypePrincipal\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeNone\"] = 5] = \"ClarityAbiTypeNone\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBuffer\"] = 6] = \"ClarityAbiTypeBuffer\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeResponse\"] = 7] = \"ClarityAbiTypeResponse\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeOptional\"] = 8] = \"ClarityAbiTypeOptional\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTuple\"] = 9] = \"ClarityAbiTypeTuple\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeList\"] = 10] = \"ClarityAbiTypeList\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringAscii\"] = 11] = \"ClarityAbiTypeStringAscii\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringUtf8\"] = 12] = \"ClarityAbiTypeStringUtf8\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTraitReference\"] = 13] = \"ClarityAbiTypeTraitReference\";\n})(ClarityAbiTypeId \|\| (ClarityAbiTypeId = {}));\nexport const isClarityAbiPrimitive = (val) => typeof val === 'string';\nexport const isClarityAbiBuffer = (val) => val.buffer !== undefined;\nexport const isClarityAbiStringAscii = (val) => val['string-ascii'] !== undefined;\nexport const isClarityAbiStringUtf8 = (val) => val['string-utf8'] !== undefined;\nexport const isClarityAbiResponse = (val) => val.response !== undefined;\nexport const isClarityAbiOptional = (val) => val.optional !== undefined;\nexport const isClarityAbiTuple = (val) => val.tuple !== undefined;\nexport const isClarityAbiList = (val) => val.list !== undefined;\nexport function getTypeUnion(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'uint128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeUInt128, type: val };\n }\n else if (val === 'int128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeInt128, type: val };\n }\n else if (val === 'bool') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBool, type: val };\n }\n else if (val === 'principal') {\n return { id: ClarityAbiTypeId.ClarityAbiTypePrincipal, type: val };\n }\n else if (val === 'trait_reference') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTraitReference, type: val };\n }\n else if (val === 'none') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeNone, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);\n }\n }\n else if (isClarityAbiBuffer(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBuffer, type: val };\n }\n else if (isClarityAbiResponse(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeResponse, type: val };\n }\n else if (isClarityAbiOptional(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeOptional, type: val };\n }\n else if (isClarityAbiTuple(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTuple, type: val };\n }\n else if (isClarityAbiList(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeList, type: val };\n }\n else if (isClarityAbiStringAscii(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringAscii, type: val };\n }\n else if (isClarityAbiStringUtf8(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringUtf8, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);\n }\n}\nexport function encodeAbiClarityValue(value, type) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n switch (union.id) {\n case ClarityAbiTypeId.ClarityAbiTypeUInt128:\n return uintCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeInt128:\n return intCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeBool:\n if (value === 'false' \|\| value === '0')\n return falseCV();\n else if (value === 'true' \|\| value === '1')\n return trueCV();\n else\n throw new Error(`Unexpected Clarity bool value: ${JSON.stringify(value)}`);\n case ClarityAbiTypeId.ClarityAbiTypePrincipal:\n if (value.includes('.')) {\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n }\n else {\n return standardPrincipalCV(value);\n }\n case ClarityAbiTypeId.ClarityAbiTypeTraitReference:\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n case ClarityAbiTypeId.ClarityAbiTypeNone:\n return noneCV();\n case ClarityAbiTypeId.ClarityAbiTypeBuffer:\n return bufferCV(hexToBytes(value));\n case ClarityAbiTypeId.ClarityAbiTypeStringAscii:\n return stringAsciiCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeStringUtf8:\n return stringUtf8CV(value);\n case ClarityAbiTypeId.ClarityAbiTypeOptional:\n return someCV(encodeAbiClarityValue(value, union.type.optional));\n case ClarityAbiTypeId.ClarityAbiTypeResponse:\n case ClarityAbiTypeId.ClarityAbiTypeTuple:\n case ClarityAbiTypeId.ClarityAbiTypeList:\n throw new NotImplementedError(`Unsupported encoding for Clarity type: ${union.id}`);\n default:\n throw new Error(`Unexpected Clarity type ID: ${JSON.stringify(union)}`);\n }\n}\nexport function encodeClarityValue(type, value) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n if (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer) {\n return bufferCV(utf8ToBytes(value));\n }\n return encodeAbiClarityValue(value, union);\n}\nexport function getTypeString(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'int128') {\n return 'int';\n }\n else if (val === 'uint128') {\n return 'uint';\n }\n return val;\n }\n else if (isClarityAbiBuffer(val)) {\n return `(buff ${val.buffer.length})`;\n }\n else if (isClarityAbiStringAscii(val)) {\n return `(string-ascii ${val['string-ascii'].length})`;\n }\n else if (isClarityAbiStringUtf8(val)) {\n return `(string-utf8 ${val['string-utf8'].length})`;\n }\n else if (isClarityAbiResponse(val)) {\n return `(response ${getTypeString(val.response.ok)} ${getTypeString(val.response.error)})`;\n }\n else if (isClarityAbiOptional(val)) {\n return `(optional ${getTypeString(val.optional)})`;\n }\n else if (isClarityAbiTuple(val)) {\n return `(tuple ${val.tuple.map(t => `(${t.name} ${getTypeString(t.type)})`).join(' ')})`;\n }\n else if (isClarityAbiList(val)) {\n return `(list ${val.list.length} ${getTypeString(val.list.type)})`;\n }\n else {\n throw new Error(`Type string unsupported for Clarity type: ${JSON.stringify(val)}`);\n }\n}\nexport function abiFunctionToString(func) {\n const access = func.access === 'read_only' ? 'read-only' : func.access;\n return `(define-${access} (${func.name} ${func.args\n .map(arg => `(${arg.name} ${getTypeString(arg.type)})`)\n .join(' ')}))`;\n}\nfunction matchType(cv, abiType) {\n const union = getTypeUnion(abiType);\n switch (cv.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeBool;\n case ClarityType.Int:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeInt128;\n case ClarityType.UInt:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeUInt128;\n case ClarityType.Buffer:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer &&\n union.type.buffer.length >= Math.ceil(cv.value.length / 2));\n case ClarityType.StringASCII:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringAscii &&\n union.type['string-ascii'].length >= cv.value.length);\n case ClarityType.StringUTF8:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringUtf8 &&\n union.type['string-utf8'].length >= cv.value.length);\n case ClarityType.OptionalNone:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeNone \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeOptional);\n case ClarityType.OptionalSome:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeOptional &&\n matchType(cv.value, union.type.optional));\n case ClarityType.ResponseErr:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.error));\n case ClarityType.ResponseOk:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.ok));\n case ClarityType.PrincipalContract:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeTraitReference);\n case ClarityType.PrincipalStandard:\n return union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal;\n case ClarityType.List:\n return (union.id == ClarityAbiTypeId.ClarityAbiTypeList &&\n union.type.list.length >= cv.value.length &&\n cv.value.every(val => matchType(val, union.type.list.type)));\n case ClarityType.Tuple:\n if (union.id == ClarityAbiTypeId.ClarityAbiTypeTuple) {\n const tuple = cloneDeep(cv.value);\n for (let i = 0; i < union.type.tuple.length; i++) {\n const abiTupleEntry = union.type.tuple[i];\n const key = abiTupleEntry.name;\n const val = tuple[key];\n if (val) {\n if (!matchType(val, abiTupleEntry.type)) {\n return false;\n }\n delete tuple[key];\n }\n else {\n return false;\n }\n }\n return true;\n }\n else {\n return false;\n }\n default:\n return false;\n }\n}\nexport function validateContractCall(payload, abi) {\n const filtered = abi.functions.filter(fn => fn.name === payload.functionName.content);\n if (filtered.length === 1) {\n const abiFunc = filtered[0];\n const abiArgs = abiFunc.args;\n if (payload.functionArgs.length !== abiArgs.length) {\n throw new Error(`Clarity function expects ${abiArgs.length} argument(s) but received ${payload.functionArgs.length}`);\n }\n for (let i = 0; i < payload.functionArgs.length; i++) {\n const payloadArg = payload.functionArgs[i];\n const abiArg = abiArgs[i];\n if (!matchType(payloadArg, abiArg.type)) {\n const argNum = i + 1;\n throw new Error(`Clarity function \\`${payload.functionName.content}\\` expects argument ${argNum} to be of type ${getTypeString(abiArg.type)}, not ${getCVTypeString(payloadArg)}`);\n }\n }\n return true;\n }\n else if (filtered.length === 0) {\n throw new Error(`ABI doesn't contain a function with the name ${payload.functionName.content}`);\n }\n else {\n throw new Error(`Malformed ABI. Contains multiple functions with the name ${payload.functionName.content}`);\n }\n}\nexport function parseToCV(input, type) {\n const typeString = getTypeString(type);\n if (isClarityAbiPrimitive(type)) {\n if (type === 'uint128') {\n return uintCV(input);\n }\n else if (type === 'int128') {\n return intCV(input);\n }\n else if (type === 'bool') {\n if (input.toLowerCase() === 'true') {\n return trueCV();\n }\n else if (input.toLowerCase() === 'false') {\n return falseCV();\n }\n else {\n throw new Error(`Invalid bool value: ${input}`);\n }\n }\n else if (type === 'principal') {\n if (input.includes('.')) {\n const [address, contractName] = input.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(input);\n }\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n }\n else if (isClarityAbiBuffer(type)) {\n const inputLength = utf8ToBytes(input).byteLength;\n if (inputLength > type.buffer.length) {\n throw new Error(`Input exceeds specified buffer length limit of ${type.buffer.length}`);\n }\n return bufferCVFromString(input);\n }\n else if (isClarityAbiResponse(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiOptional(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiTuple(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiList(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n}\n//# sourceMappingURL=contract-abi.js.map","import { bytesToHex, concatArray, intToBigInt, isInstance, writeUInt32BE, } from '@stacks/common';\nimport { STACKS_MAINNET, STACKS_TESTNET, TransactionVersion, networkFrom, whenTransactionVersion, } from '@stacks/network';\nimport { serializePayloadBytes } from '.';\nimport { BytesReader } from './BytesReader';\nimport { deserializeAuthorization, intoInitialSighashAuth, isSingleSig, nextSignature, serializeAuthorizationBytes, setFee, setNonce, setSponsor, setSponsorNonce, verifyOrigin, } from './authorization';\nimport { AddressHashMode, AnchorMode, AuthType, PostConditionMode, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { SerializationError, SigningError } from './errors';\nimport { createStacksPublicKey, privateKeyIsCompressed, publicKeyIsCompressed } from './keys';\nimport { cloneDeep, txidFromData } from './utils';\nimport { StacksWireType, createLPList, createMessageSignature, createTransactionAuthField, deserializeLPList, deserializePayload, serializeLPListBytes, } from './wire';\nexport class StacksTransactionWire {\n constructor({ auth, payload, postConditions = createLPList([]), postConditionMode = PostConditionMode.Deny, transactionVersion, chainId, network = 'mainnet', }) {\n network = networkFrom(network);\n this.transactionVersion = transactionVersion ?? network.transactionVersion;\n this.chainId = chainId ?? network.chainId;\n this.auth = auth;\n if ('amount' in payload) {\n this.payload = {\n ...payload,\n amount: intToBigInt(payload.amount),\n };\n }\n else {\n this.payload = payload;\n }\n this.postConditionMode = postConditionMode;\n this.postConditions = postConditions;\n this.anchorMode = AnchorMode.Any;\n }\n signBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyOrigin() {\n return verifyOrigin(this.auth, this.verifyBegin());\n }\n signNextOrigin(sigHash, privateKey) {\n if (this.auth.spendingCondition === undefined) {\n throw new Error('\"auth.spendingCondition\" is undefined');\n }\n if (this.auth.authType === undefined) {\n throw new Error('\"auth.authType\" is undefined');\n }\n return this.signAndAppend(this.auth.spendingCondition, sigHash, AuthType.Standard, privateKey);\n }\n signNextSponsor(sigHash, privateKey) {\n if (this.auth.authType === AuthType.Sponsored) {\n return this.signAndAppend(this.auth.sponsorSpendingCondition, sigHash, AuthType.Sponsored, privateKey);\n }\n else {\n throw new Error('\"auth.sponsorSpendingCondition\" is undefined');\n }\n }\n appendPubkey(publicKey) {\n const wire = typeof publicKey === 'object' && 'type' in publicKey\n ? publicKey\n : createStacksPublicKey(publicKey);\n const cond = this.auth.spendingCondition;\n if (cond && !isSingleSig(cond)) {\n const compressed = publicKeyIsCompressed(wire.data);\n cond.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, wire));\n }\n else {\n throw new Error(`Can't append public key to a singlesig condition`);\n }\n }\n signAndAppend(condition, curSigHash, authType, privateKey) {\n const { nextSig, nextSigHash } = nextSignature(curSigHash, authType, condition.fee, condition.nonce, privateKey);\n if (isSingleSig(condition)) {\n condition.signature = createMessageSignature(nextSig);\n }\n else {\n const compressed = privateKeyIsCompressed(privateKey);\n condition.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, createMessageSignature(nextSig)));\n }\n return nextSigHash;\n }\n txid() {\n const serialized = this.serializeBytes();\n return txidFromData(serialized);\n }\n setSponsor(sponsorSpendingCondition) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsor(this.auth, sponsorSpendingCondition);\n }\n setFee(amount) {\n this.auth = setFee(this.auth, amount);\n }\n setNonce(nonce) {\n this.auth = setNonce(this.auth, nonce);\n }\n setSponsorNonce(nonce) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsorNonce(this.auth, nonce);\n }\n serialize() {\n return bytesToHex(this.serializeBytes());\n }\n serializeBytes() {\n if (this.transactionVersion === undefined) {\n throw new SerializationError('\"transactionVersion\" is undefined');\n }\n if (this.chainId === undefined) {\n throw new SerializationError('\"chainId\" is undefined');\n }\n if (this.auth === undefined) {\n throw new SerializationError('\"auth\" is undefined');\n }\n if (this.payload === undefined) {\n throw new SerializationError('\"payload\" is undefined');\n }\n const bytesArray = [];\n bytesArray.push(this.transactionVersion);\n const chainIdBytes = new Uint8Array(4);\n writeUInt32BE(chainIdBytes, this.chainId, 0);\n bytesArray.push(chainIdBytes);\n bytesArray.push(serializeAuthorizationBytes(this.auth));\n bytesArray.push(this.anchorMode);\n bytesArray.push(this.postConditionMode);\n bytesArray.push(serializeLPListBytes(this.postConditions));\n bytesArray.push(serializePayloadBytes(this.payload));\n return concatArray(bytesArray);\n }\n}\nexport function deserializeTransaction(tx) {\n const bytesReader = isInstance(tx, BytesReader) ? tx : new BytesReader(tx);\n const transactionVersion = bytesReader.readUInt8Enum(TransactionVersion, n => {\n throw new Error(`Could not parse ${n} as TransactionVersion`);\n });\n const chainId = bytesReader.readUInt32BE();\n const auth = deserializeAuthorization(bytesReader);\n const anchorMode = bytesReader.readUInt8Enum(AnchorMode, n => {\n throw new Error(`Could not parse ${n} as AnchorMode`);\n });\n const postConditionMode = bytesReader.readUInt8Enum(PostConditionMode, n => {\n throw new Error(`Could not parse ${n} as PostConditionMode`);\n });\n const postConditions = deserializeLPList(bytesReader, StacksWireType.PostCondition);\n const payload = deserializePayload(bytesReader);\n const transaction = new StacksTransactionWire({\n transactionVersion,\n chainId,\n auth,\n payload,\n postConditions,\n postConditionMode,\n });\n transaction.anchorMode = anchorMode;\n return transaction;\n}\nexport function deriveNetworkFromTx(transaction) {\n return whenTransactionVersion(transaction.transactionVersion)({\n [TransactionVersion.Mainnet]: STACKS_MAINNET,\n [TransactionVersion.Testnet]: STACKS_TESTNET,\n });\n}\nexport function estimateTransactionByteLength(transaction) {\n const hashMode = transaction.auth.spendingCondition.hashMode;\n const multiSigHashModes = [AddressHashMode.P2SH, AddressHashMode.P2WSH];\n if (multiSigHashModes.includes(hashMode)) {\n const multiSigSpendingCondition = transaction.auth\n .spendingCondition;\n const existingSignatures = multiSigSpendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length;\n const totalSignatureLength = (multiSigSpendingCondition.signaturesRequired - existingSignatures) \n (RECOVERABLE_ECDSA_SIG_LENGTH_BYTES + 1);\n return transaction.serializeBytes().byteLength + totalSignatureLength;\n }\n else {\n return transaction.serializeBytes().byteLength;\n }\n}\nexport function serializeTransaction(transaction) {\n return transaction.serialize();\n}\nexport function serializeTransactionBytes(transaction) {\n return transaction.serializeBytes();\n}\nexport function transactionToHex(transaction) {\n return transaction.serialize();\n}\n//# sourceMappingURL=transaction.js.map","import { bytesToHex, validateHash256, with0x } from '@stacks/common';\nimport { clientFromNetwork, networkFrom } from '@stacks/network';\nimport { deserializeCV, serializeCV } from './clarity';\nimport { NoEstimateAvailableError } from './errors';\nimport { deriveNetworkFromTx, estimateTransactionByteLength, } from './transaction';\nimport { cvToHex, parseReadOnlyResponse } from './utils';\nimport { serializePayloadBytes } from './wire';\nexport const BROADCAST_PATH = '/v2/transactions';\nexport const TRANSFER_FEE_ESTIMATE_PATH = '/v2/fees/transfer';\nexport const TRANSACTION_FEE_ESTIMATE_PATH = '/v2/fees/transaction';\nexport const ACCOUNT_PATH = '/v2/accounts';\nexport const CONTRACT_ABI_PATH = '/v2/contracts/interface';\nexport const READONLY_FUNCTION_CALL_PATH = '/v2/contracts/call-read';\nexport const MAP_ENTRY_PATH = '/v2/map_entry';\nexport async function broadcastTransaction({ transaction: txOpt, attachment: attachOpt, network: _network, client: _client, }) {\n const tx = txOpt.serialize();\n const attachment = attachOpt\n ? typeof attachOpt === 'string'\n ? attachOpt\n : bytesToHex(attachOpt)\n : undefined;\n const json = attachOpt ? { tx, attachment } : { tx };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${BROADCAST_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n try {\n return (await response.json());\n }\n catch (e) {\n throw Error('Failed to broadcast transaction (unable to parse node response).', { cause: e });\n }\n }\n const text = await response.text();\n const txid = text.replace(/[\"]+/g, '');\n if (!validateHash256(txid))\n throw new Error(text);\n return { txid };\n}\nasync function _getNonceApi({ address, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}/extended/v1/address/${address}/nonces`;\n const response = await client.fetch(url);\n const result = await response.json();\n return BigInt(result.possible_next_nonce);\n}\nexport async function fetchNonce(opts) {\n try {\n return await _getNonceApi(opts);\n }\n catch (e) { }\n const network = networkFrom(opts.network ?? 'mainnet');\n const client = Object.assign({}, clientFromNetwork(network), opts.client);\n const url = `${client.baseUrl}${ACCOUNT_PATH}/${opts.address}?proof=0`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching nonce. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = (await response.json());\n return BigInt(json.nonce);\n}\nexport async function fetchFeeEstimateTransfer({ transaction: txOpt, network: _network, client: _client, }) {\n const network = typeof txOpt === 'number' ? 'mainnet' : _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSFER_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, {\n headers: { Accept: 'application/text' },\n });\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error estimating transfer fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const feeRateResult = await response.text();\n const txBytes = typeof txOpt === 'number'\n ? BigInt(txOpt)\n : BigInt(Math.ceil(txOpt.serializeBytes().byteLength));\n const feeRate = BigInt(feeRateResult);\n return feeRate txBytes;\n}\nexport async function fetchFeeEstimateTransaction({ payload, estimatedLength, network = 'mainnet', client: _client, }) {\n const json = {\n transaction_payload: payload,\n estimated_len: estimatedLength,\n };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSACTION_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const body = await response.text().catch(() => '');\n if (body.includes('NoEstimateAvailable')) {\n let json = {};\n try {\n json = JSON.parse(body);\n }\n catch (err) {\n }\n throw new NoEstimateAvailableError(json?.reason_data?.message ?? '');\n }\n throw new Error(`Error estimating transaction fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${body}\"`);\n }\n const data = await response.json();\n return data.estimations;\n}\nexport async function fetchFeeEstimate({ transaction: txOpt, network: _network, client: _client, }) {\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n try {\n const estimatedLength = estimateTransactionByteLength(txOpt);\n return (await fetchFeeEstimateTransaction({\n payload: bytesToHex(serializePayloadBytes(txOpt.payload)),\n estimatedLength,\n network,\n client,\n }))[1].fee;\n }\n catch (error) {\n if (!(error instanceof NoEstimateAvailableError))\n throw error;\n return await fetchFeeEstimateTransfer({ transaction: txOpt, network });\n }\n}\nexport async function fetchAbi({ contractAddress: address, contractName: name, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${CONTRACT_ABI_PATH}/${address}/${name}`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching contract ABI for contract \"${name}\" at address ${address}. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return JSON.parse(await response.text());\n}\nexport async function fetchCallReadOnlyFunction({ contractName, contractAddress, functionName, functionArgs, senderAddress, network = 'mainnet', client: _client, }) {\n const json = {\n sender: senderAddress,\n arguments: functionArgs.map(arg => cvToHex(arg)),\n };\n const options = {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(json),\n };\n const name = encodeURIComponent(functionName);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${READONLY_FUNCTION_CALL_PATH}/${contractAddress}/${contractName}/${name}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error calling read-only function. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return await response.json().then(parseReadOnlyResponse);\n}\nexport async function fetchContractMapEntry({ contractAddress, contractName, mapName, mapKey, network = 'mainnet', client: _client, }) {\n const keyHex = with0x(serializeCV(mapKey));\n const options = {\n method: 'POST',\n headers: {\n Accept: 'application/json',\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(keyHex),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${MAP_ENTRY_PATH}/${contractAddress}/${contractName}/${mapName}?proof=0`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = await response.json();\n if (!json.data) {\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${client.baseUrl} and failed with the response: \"${JSON.stringify(json)}\"`);\n }\n try {\n return deserializeCV(json.data);\n }\n catch (error) {\n throw new Error(`Error deserializing Clarity value \"${json.data}\": ${error}`);\n }\n}\n//# sourceMappingURL=fetch.js.map","import { PostConditionMode, PostConditionPrincipalId, PostConditionType, } from './constants';\nimport { StacksWireType, addressToString, parseAssetString, parsePrincipalString, serializePostConditionWire, } from './wire';\nvar PostConditionCodeWireType;\n(function (PostConditionCodeWireType) {\n PostConditionCodeWireType[PostConditionCodeWireType[\"eq\"] = 1] = \"eq\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gt\"] = 2] = \"gt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lt\"] = 4] = \"lt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gte\"] = 3] = \"gte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lte\"] = 5] = \"lte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"sent\"] = 16] = \"sent\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"not-sent\"] = 17] = \"not-sent\";\n})(PostConditionCodeWireType \|\| (PostConditionCodeWireType = {}));\nexport function postConditionToWire(postcondition) {\n switch (postcondition.type) {\n case 'stx-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n };\n case 'ft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n asset: parseAssetString(postcondition.asset),\n };\n case 'nft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n asset: parseAssetString(postcondition.asset),\n assetName: postcondition.assetId,\n };\n default:\n throw new Error('Invalid post condition type');\n }\n}\nexport function wireToPostCondition(wire) {\n switch (wire.conditionType) {\n case PostConditionType.STX:\n return {\n type: 'stx-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n };\n case PostConditionType.Fungible:\n return {\n type: 'ft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n asset: assetWireToString(wire.asset),\n };\n case PostConditionType.NonFungible:\n return {\n type: 'nft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n asset: assetWireToString(wire.asset),\n assetId: wire.assetName,\n };\n default: {\n const _exhaustiveCheck = wire;\n throw new Error(`Invalid post condition type: ${_exhaustiveCheck}`);\n }\n }\n}\nexport function conditionTypeToByte(condition) {\n return PostConditionCodeWireType[condition];\n}\nexport function conditionByteToType(wireType) {\n return PostConditionCodeWireType[wireType];\n}\nexport function postConditionToHex(postcondition) {\n const wire = postConditionToWire(postcondition);\n return serializePostConditionWire(wire);\n}\nexport function postConditionModeFrom(mode) {\n if (typeof mode === 'number')\n return mode;\n if (mode === 'allow')\n return PostConditionMode.Allow;\n if (mode === 'deny')\n return PostConditionMode.Deny;\n throw new Error(`Invalid post condition mode: ${mode}`);\n}\nfunction assetWireToString(asset) {\n const address = addressToString(asset.address);\n const contractId = `${address}.${asset.contractName.content}`;\n return `${contractId}::${asset.assetName.content}`;\n}\nfunction principalWireToString(principal) {\n switch (principal.prefix) {\n case PostConditionPrincipalId.Origin:\n return 'origin';\n case PostConditionPrincipalId.Standard:\n return addressToString(principal.address);\n case PostConditionPrincipalId.Contract:\n const address = addressToString(principal.address);\n return `${address}.${principal.contractName.content}`;\n default:\n const _exhaustiveCheck = principal;\n throw new Error(`Invalid principal type: ${_exhaustiveCheck}`);\n }\n}\n//# sourceMappingURL=postcondition.js.map","import { STACKS_MAINNET, clientFromNetwork, networkFrom, } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { createMultiSigSpendingCondition, createSingleSigSpendingCondition, createSponsoredAuth, createStandardAuth, isSingleSig, } from './authorization';\nimport { AddressHashMode, ClarityVersion, PayloadType, PostConditionMode, } from './constants';\nimport { validateContractCall } from './contract-abi';\nimport { fetchAbi, fetchFeeEstimate, fetchNonce } from './fetch';\nimport { createStacksPublicKey, privateKeyToHex, privateKeyToPublic, publicKeyToAddress, publicKeyToHex, } from './keys';\nimport { postConditionModeFrom, postConditionToWire } from './postcondition';\nimport { TransactionSigner } from './signer';\nimport { StacksTransactionWire, deriveNetworkFromTx } from './transaction';\nimport { omit } from './utils';\nimport { addressFromPublicKeys, createAddress, createContractCallPayload, createLPList, createSmartContractPayload, createTokenTransferPayload, deserializePostConditionWire, } from './wire';\nexport async function makeUnsignedSTXTokenTransfer(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n memo: '',\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n const payload = createTokenTransferPayload(options.recipient, options.amount, options.memo);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n });\n if (txOptions.fee == null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeSTXTokenTransfer(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedSTXTokenTransfer({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedSTXTokenTransfer(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeContractDeploy(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractDeploy({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractDeploy(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeUnsignedContractDeploy(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n clarityVersion: ClarityVersion.Clarity3,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createSmartContractPayload(options.contractName, options.codeBody, options.clarityVersion);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeUnsignedContractCall(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createContractCallPayload(options.contractAddress, options.contractName, options.functionName, options.functionArgs);\n if (options?.validateWithAbi) {\n let abi;\n if (typeof options.validateWithAbi === 'boolean') {\n if (options?.network) {\n abi = await fetchAbi({ ...options });\n }\n else {\n throw new Error('Network option must be provided in order to validate with ABI');\n }\n }\n else {\n abi = options.validateWithAbi;\n }\n validateContractCall(payload, abi);\n }\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeContractCall(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractCall({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractCall(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function sponsorTransaction(sponsorOptions) {\n const defaultOptions = {\n fee: 0,\n sponsorNonce: 0,\n sponsorAddressHashmode: AddressHashMode.P2PKH,\n network: deriveNetworkFromTx(sponsorOptions.transaction),\n };\n const options = Object.assign(defaultOptions, sponsorOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n const sponsorPubKey = privateKeyToPublic(options.sponsorPrivateKey);\n if (sponsorOptions.fee == null) {\n let txFee = 0;\n switch (options.transaction.payload.payloadType) {\n case PayloadType.TokenTransfer:\n case PayloadType.SmartContract:\n case PayloadType.VersionedSmartContract:\n case PayloadType.ContractCall:\n txFee = BigInt(await fetchFeeEstimate({ ...options }));\n break;\n default:\n throw new Error(`Sponsored transactions not supported for transaction type ${PayloadType[options.transaction.payload.payloadType]}`);\n }\n options.transaction.setFee(txFee);\n options.fee = txFee;\n }\n if (sponsorOptions.sponsorNonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = publicKeyToAddress(addressVersion, sponsorPubKey);\n const sponsorNonce = await fetchNonce({ address, ...options });\n options.sponsorNonce = sponsorNonce;\n }\n const sponsorSpendingCondition = createSingleSigSpendingCondition(options.sponsorAddressHashmode, sponsorPubKey, options.sponsorNonce, options.fee);\n options.transaction.setSponsor(sponsorSpendingCondition);\n const privKey = options.sponsorPrivateKey;\n const signer = TransactionSigner.createSponsorSigner(options.transaction, sponsorSpendingCondition);\n signer.signSponsor(privKey);\n return signer.transaction;\n}\nfunction mutatingSignAppendMultiSig(transaction, publicKeys, signerKeys, address) {\n if (isSingleSig(transaction.auth.spendingCondition)) {\n throw new Error('Transaction is not a multi-sig transaction');\n }\n const signer = new TransactionSigner(transaction);\n const pubs = address\n ? sortPublicKeysForAddress(publicKeys, transaction.auth.spendingCondition.signaturesRequired, transaction.auth.spendingCondition.hashMode, createAddress(address).hash160)\n : publicKeys;\n for (const publicKey of pubs) {\n const signerKey = signerKeys.find(key => privateKeyToPublic(key) === publicKey);\n if (signerKey) {\n signer.signOrigin(signerKey);\n }\n else {\n signer.appendOrigin(publicKey);\n }\n }\n}\nfunction sortPublicKeysForAddress(publicKeys, numSigs, hashMode, hash) {\n const hashUnsorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeys.map(createStacksPublicKey)).hash160;\n if (hashUnsorted === hash)\n return publicKeys;\n const publicKeysSorted = publicKeys.slice().sort();\n const hashSorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeysSorted.map(createStacksPublicKey)).hash160;\n if (hashSorted === hash)\n return publicKeysSorted;\n throw new Error('Failed to find matching multi-sig address given public-keys.');\n}\n//# sourceMappingURL=builders.js.map","import { utf8ToBytes } from '@stacks/common';\nimport { hash160 } from '@stacks/transactions';\n\n/** @ignore /\nexport function decodeFQN(fqdn: string): {\n name: string;\n namespace: string;\n subdomain?: string;\n} {\n const nameParts = fqdn.split('.');\n if (nameParts.length > 2) {\n return {\n subdomain: nameParts[0],\n name: nameParts[1],\n namespace: nameParts[2],\n };\n }\n return {\n name: nameParts[0],\n namespace: nameParts[1],\n };\n}\n\n/* @ignore /\nexport const getZonefileHash = (zonefile: string) => hash160(utf8ToBytes(zonefile));\n","import { IntegerType, PublicKey, intToBigInt, utf8ToBytes } from '@stacks/common';\nimport { NetworkClientParam, StacksNetwork } from '@stacks/network';\nimport {\n ClarityType,\n ClarityValue,\n NonFungiblePostCondition,\n PostCondition,\n ResponseErrorCV,\n StacksTransactionWire,\n StxPostCondition,\n UnsignedContractCallOptions,\n bufferCV,\n bufferCVFromString,\n cvToString,\n fetchCallReadOnlyFunction,\n getAddressFromPrivateKey,\n getCVTypeString,\n hash160,\n makeRandomPrivKey,\n makeUnsignedContractCall,\n noneCV,\n publicKeyToAddress,\n someCV,\n standardPrincipalCV,\n tupleCV,\n uintCV,\n} from '@stacks/transactions';\nimport { decodeFQN, getZonefileHash } from './utils';\n\nexport const BNS_CONTRACT_NAME = 'bns';\n\nexport interface PriceFunction {\n base: IntegerType;\n coefficient: IntegerType;\n b1: IntegerType;\n b2: IntegerType;\n b3: IntegerType;\n b4: IntegerType;\n b5: IntegerType;\n b6: IntegerType;\n b7: IntegerType;\n b8: IntegerType;\n b9: IntegerType;\n b10: IntegerType;\n b11: IntegerType;\n b12: IntegerType;\n b13: IntegerType;\n b14: IntegerType;\n b15: IntegerType;\n b16: IntegerType;\n nonAlphaDiscount: IntegerType;\n noVowelDiscount: IntegerType;\n}\n\nexport interface BnsContractCallOptions {\n functionName: string;\n functionArgs: ClarityValue[];\n publicKey: PublicKey;\n network: StacksNetwork;\n postConditions?: PostCondition[];\n}\n\nasync function makeBnsContractCall(\n options: BnsContractCallOptions\n): Promise<StacksTransactionWire> {\n const txOptions: UnsignedContractCallOptions = {\n contractAddress: options.network.bootAddress,\n contractName: BNS_CONTRACT_NAME,\n functionName: options.functionName,\n functionArgs: options.functionArgs,\n publicKey: options.publicKey,\n validateWithAbi: false,\n network: options.network,\n postConditions: options.postConditions,\n };\n\n return makeUnsignedContractCall(txOptions);\n}\n\nexport interface BnsReadOnlyOptions {\n functionName: string;\n functionArgs: ClarityValue[];\n senderAddress: string;\n network: StacksNetwork;\n}\n\nasync function callReadOnlyBnsFunction(\n options: BnsReadOnlyOptions & NetworkClientParam\n): Promise<ClarityValue> {\n return fetchCallReadOnlyFunction({\n ...options,\n contractAddress: options.network.bootAddress,\n contractName: BNS_CONTRACT_NAME,\n });\n}\n\n/\n Can register name options\n \n @param {String} fullyQualifiedName - the fully qualified name (\"name.namespace\") to check\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface CanRegisterNameOptions {\n fullyQualifiedName: string;\n network: StacksNetwork;\n}\n\n/\n Check if name can be registered\n \n @param {string} fullyQualifiedName - the fully qualified name to check\n * @param {StacksNetwork} network - the Stacks network to broadcast transaction to\n \n @returns {Promise} that resolves to true if the operation succeeds\n /\nexport async function canRegisterName({\n fullyQualifiedName,\n network,\n}: CanRegisterNameOptions): Promise<boolean> {\n const bnsFunctionName = 'can-name-be-registered';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot register a subdomain using registerName');\n }\n\n // Create a random address as input to read-only function call\n // Not used by BNS contract function but required by core node API\n // https://github.com/blockstack/stacks-blockchain/blob/master/src/net/http.rs#L1796\n const randomPrivateKey = makeRandomPrivKey();\n const randomAddress = getAddressFromPrivateKey(randomPrivateKey);\n\n return callReadOnlyBnsFunction({\n functionName: bnsFunctionName,\n senderAddress: randomAddress,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name)],\n network,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n return responseCV.value.type === ClarityType.BoolTrue;\n } else {\n return false;\n }\n });\n}\n\n/\n Get namespace price options\n \n @param {String} namespace - the namespace to get the price of\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface GetNamespacePriceOptions {\n namespace: string;\n network: StacksNetwork;\n}\n\n/\n Get price of namespace registration in microstacks\n \n @param {string} namespace - the namespace\n * @param {StacksNetwork} network - the Stacks network to use\n \n @returns {Promise} that resolves to a BN object number of microstacks if the operation succeeds\n /\nexport async function getNamespacePrice({\n namespace,\n network,\n}: GetNamespacePriceOptions): Promise<bigint> {\n const bnsFunctionName = 'get-namespace-price';\n\n // Create a random address as input to read-only function call\n // Not used by BNS contract function but required by core node API\n // https://github.com/blockstack/stacks-blockchain/blob/master/src/net/http.rs#L1796\n const randomPrivateKey = makeRandomPrivKey();\n const randomAddress = getAddressFromPrivateKey(randomPrivateKey);\n\n return callReadOnlyBnsFunction({\n functionName: bnsFunctionName,\n senderAddress: randomAddress,\n functionArgs: [bufferCVFromString(namespace)],\n network,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n if (responseCV.value.type === ClarityType.Int \|\| responseCV.value.type === ClarityType.UInt) {\n return BigInt(responseCV.value.value);\n } else {\n throw new Error('Response did not contain a number');\n }\n } else if (responseCV.type === ClarityType.ResponseErr) {\n throw new Error(cvToString(responseCV.value));\n } else {\n throw new Error(`Unexpected Clarity Value type: ${getCVTypeString(responseCV)}`);\n }\n });\n}\n\n/\n Get name price options\n \n @param {String} fullyQualifiedName - the fully qualified name (\"name.namespace\") to get the price of\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface GetNamePriceOptions {\n fullyQualifiedName: string;\n network: StacksNetwork;\n}\n\n/\n Get price of name registration in microstacks\n \n @param {string} fullyQualifiedName - the fully qualified name\n * @param {StacksNetwork} network - the Stacks network to use\n \n @returns {Promise} that resolves to a BN object number of microstacks if the operation succeeds\n /\nexport async function getNamePrice({\n fullyQualifiedName,\n network,\n}: GetNamePriceOptions): Promise<bigint> {\n const bnsFunctionName = 'get-name-price';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot get subdomain name price');\n }\n\n // Create a random address as input to read-only function call\n // Not used by BNS contract function but required by core node API\n // https://github.com/blockstack/stacks-blockchain/blob/master/src/net/http.rs#L1796\n const randomPrivateKey = makeRandomPrivKey();\n const randomAddress = getAddressFromPrivateKey(randomPrivateKey);\n\n return callReadOnlyBnsFunction({\n functionName: bnsFunctionName,\n senderAddress: randomAddress,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name)],\n network,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n if (responseCV.value.type === ClarityType.Int \|\| responseCV.value.type === ClarityType.UInt) {\n return BigInt(responseCV.value.value);\n } else {\n throw new Error('Response did not contain a number');\n }\n } else {\n const errorResponse = responseCV as ResponseErrorCV;\n throw new Error(cvToString(errorResponse.value));\n }\n });\n}\n\n/\n Preorder namespace options\n /\nexport interface PreorderNamespaceOptions {\n /* the namespace to preorder /\n namespace: string;\n /* salt used to generate the preorder namespace hash /\n salt: string;\n /* amount of STX to burn for the registration /\n stxToBurn: IntegerType;\n /* the private key to sign the transaction /\n publicKey: string;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n}\n\n/\n Generates a namespace preorder transaction.\n * First step in registering a namespace. This transaction does not reveal the namespace that is\n * about to be registered. And it sets the amount of STX to be burned for the registration.\n \n Resolves to the generated StacksTransaction\n \n @param {PreorderNamespaceOptions} options - an options object for the preorder\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildPreorderNamespaceTx({\n namespace,\n salt,\n stxToBurn,\n publicKey,\n network,\n}: PreorderNamespaceOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'namespace-preorder';\n const saltedNamespaceBytes = utf8ToBytes(`${namespace}${salt}`);\n const hashedSaltedNamespace = hash160(saltedNamespaceBytes);\n\n const burnSTXPostCondition: StxPostCondition = {\n type: 'stx-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'eq',\n amount: intToBigInt(stxToBurn),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCV(hashedSaltedNamespace), uintCV(stxToBurn)],\n publicKey,\n network,\n postConditions: [burnSTXPostCondition],\n });\n}\n\n/\n Reveal namespace options\n /\nexport interface RevealNamespaceOptions {\n /* the namespace to reveal /\n namespace: string;\n /* salt used to generate the preorder namespace hash /\n salt: string;\n /* an object containing the price function for the namespace /\n priceFunction: PriceFunction;\n /* the number of blocks name registrations are valid for in the namespace /\n lifetime: IntegerType;\n /* the STX address used for name imports /\n namespaceImportAddress: string;\n /* the key to sign the transaction /\n publicKey: string;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n}\n\n/\n Generates a namespace reveal transaction.\n * Second step in registering a namespace.\n \n Resolves to the generated StacksTransaction\n \n @param {RevealNamespaceOptions} options - an options object for the reveal\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildRevealNamespaceTx({\n namespace,\n salt,\n priceFunction,\n lifetime,\n namespaceImportAddress,\n publicKey,\n network,\n}: RevealNamespaceOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'namespace-reveal';\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [\n bufferCVFromString(namespace),\n bufferCVFromString(salt),\n uintCV(priceFunction.base),\n uintCV(priceFunction.coefficient),\n uintCV(priceFunction.b1),\n uintCV(priceFunction.b2),\n uintCV(priceFunction.b3),\n uintCV(priceFunction.b4),\n uintCV(priceFunction.b5),\n uintCV(priceFunction.b6),\n uintCV(priceFunction.b7),\n uintCV(priceFunction.b8),\n uintCV(priceFunction.b9),\n uintCV(priceFunction.b10),\n uintCV(priceFunction.b11),\n uintCV(priceFunction.b12),\n uintCV(priceFunction.b13),\n uintCV(priceFunction.b14),\n uintCV(priceFunction.b15),\n uintCV(priceFunction.b16),\n uintCV(priceFunction.nonAlphaDiscount),\n uintCV(priceFunction.noVowelDiscount),\n uintCV(lifetime),\n standardPrincipalCV(namespaceImportAddress),\n ],\n publicKey,\n network,\n });\n}\n\n/\n Namespace name import options\n \n @param {String} namespace - the namespace to import name into\n * @param {String} name - the name to import\n * @param {String} beneficiary - the address to register the name to\n * @param {String} zonefileHash - the zonefile hash to register\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface ImportNameOptions {\n namespace: string;\n name: string;\n beneficiary: string;\n zonefile: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a namespace name import transaction.\n * An optional step in namespace registration.\n \n Resolves to the generated StacksTransaction\n \n @param {ImportNameOptions} options - an options object for the name import\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildImportNameTx({\n namespace,\n name,\n beneficiary,\n zonefile,\n publicKey,\n network,\n}: ImportNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-import';\n const zonefileHash = getZonefileHash(zonefile);\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n standardPrincipalCV(beneficiary),\n bufferCV(zonefileHash),\n ],\n publicKey,\n network,\n });\n}\n\n/\n Ready namespace options\n \n @param {String} namespace - the namespace to ready\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface ReadyNamespaceOptions {\n namespace: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a ready namespace transaction.\n * Final step in namespace registration. This completes the namespace registration and\n * makes the namespace available for name registrations.\n \n Resolves to the generated StacksTransaction\n \n @param {ReadyNamespaceOptions} options - an options object for the namespace ready transaction\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildReadyNamespaceTx({\n namespace,\n publicKey,\n network,\n}: ReadyNamespaceOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'namespace-ready';\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCVFromString(namespace)],\n publicKey,\n network,\n });\n}\n\n/\n Preorder name options\n /\nexport interface PreorderNameOptions {\n /* the fully qualified name to preorder including the namespace (myName.id) /\n fullyQualifiedName: string;\n /* salt used to generate the preorder name hash /\n salt: string;\n /* amount of STX to burn for the registration /\n stxToBurn: IntegerType;\n /* the private key to sign the transaction /\n publicKey: PublicKey;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n}\n\n/\n Generates a name preorder transaction.\n * First step in registering a name. This transaction does not reveal the name that is\n * about to be registered. And it sets the amount of STX to be burned for the registration.\n \n Resolves to the generated StacksTransaction\n \n @param {PreorderNameOptions} options - an options object for the preorder\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildPreorderNameTx({\n fullyQualifiedName,\n salt,\n stxToBurn,\n publicKey,\n network,\n}: PreorderNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-preorder';\n const { subdomain } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot preorder a subdomain using preorderName()');\n }\n const saltedNamesBytes = utf8ToBytes(`${fullyQualifiedName}${salt}`);\n const hashedSaltedName = hash160(saltedNamesBytes);\n\n const burnSTXPostCondition: StxPostCondition = {\n type: 'stx-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'eq',\n amount: intToBigInt(stxToBurn),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCV(hashedSaltedName), uintCV(stxToBurn)],\n publicKey,\n network,\n postConditions: [burnSTXPostCondition],\n });\n}\n\n/\n Register name options\n \n @param {String} fullyQualifiedName - the fully qualified name to preorder including the\n * namespace (myName.id)\n * @param {String} salt - salt used to generate the preorder name hash\n * @param {String} zonefile - the zonefile to register with the name\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface RegisterNameOptions {\n fullyQualifiedName: string;\n salt: string;\n zonefile: string;\n publicKey: PublicKey;\n network: StacksNetwork;\n}\n\n/\n Generates a name registration transaction.\n * Second and final step in registering a name.\n \n Resolves to the generated StacksTransaction\n \n @param {RegisterNameOptions} options - an options object for the registration\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildRegisterNameTx({\n fullyQualifiedName,\n salt,\n zonefile,\n publicKey,\n network,\n}: RegisterNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-register';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot register a subdomain using registerName()');\n }\n\n const zonefileHash = getZonefileHash(zonefile);\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n bufferCVFromString(salt),\n bufferCV(zonefileHash),\n ],\n network,\n publicKey,\n });\n}\n\n/\n Update name options\n \n @param {String} fullyQualifiedName - the fully qualified name to update including the\n * namespace (myName.id)\n * @param {String} zonefile - the zonefile to register with the name\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface UpdateNameOptions {\n fullyQualifiedName: string;\n zonefile: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a name update transaction.\n * This changes the zonefile for the registered name.\n \n Resolves to the generated StacksTransaction\n \n @param {UpdateNameOptions} options - an options object for the update\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildUpdateNameTx({\n fullyQualifiedName,\n zonefile,\n publicKey,\n network,\n}: UpdateNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-update';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot update a subdomain using updateName()');\n }\n const zonefileHash = getZonefileHash(zonefile);\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name), bufferCV(zonefileHash)],\n publicKey,\n network,\n });\n}\n\n/\n Transfer name options\n \n @param {String} fullyQualifiedName - the fully qualified name to transfer including the\n * namespace (myName.id)\n * @param {String} newOwnerAddress - the recipient address of the name transfer\n * @param {String} zonefile - the optional zonefile to register with the name\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface TransferNameOptions {\n fullyQualifiedName: string;\n newOwnerAddress: string;\n publicKey: string;\n network: StacksNetwork;\n zonefile?: string;\n}\n\n/\n Generates a name transfer transaction.\n * This changes the owner of the registered name.\n \n Since the underlying NFT will be transferred,\n * you will be required to add a post-condition to this\n * transaction before broadcasting it.\n \n Resolves to the generated StacksTransaction\n \n @param {TransferNameOptions} options - an options object for the transfer\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildTransferNameTx({\n fullyQualifiedName,\n newOwnerAddress,\n zonefile,\n publicKey,\n network,\n}: TransferNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-transfer';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot transfer a subdomain using transferName()');\n }\n\n const functionArgs = [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n standardPrincipalCV(newOwnerAddress),\n zonefile ? someCV(bufferCV(getZonefileHash(zonefile))) : noneCV(),\n ];\n const postConditionSender: NonFungiblePostCondition = {\n type: 'nft-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'sent',\n asset: `${network.bootAddress}.bns::names`,\n assetId: tupleCV({\n name: bufferCVFromString(name),\n namespace: bufferCVFromString(namespace),\n }),\n };\n const postConditionReceiver: NonFungiblePostCondition = {\n type: 'nft-postcondition',\n address: newOwnerAddress,\n condition: 'not-sent',\n asset: `${network.bootAddress}.bns::names`,\n assetId: tupleCV({\n name: bufferCVFromString(name),\n namespace: bufferCVFromString(namespace),\n }),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs,\n publicKey,\n network,\n postConditions: [postConditionSender, postConditionReceiver],\n });\n}\n\n/\n Revoke name options\n \n @param {String} fullyQualifiedName - the fully qualified name to revoke including the\n * namespace (myName.id)\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface RevokeNameOptions {\n fullyQualifiedName: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a name revoke transaction.\n * This revokes a name registration.\n \n Resolves to the generated StacksTransaction\n \n @param {RevokeNameOptions} options - an options object for the revoke\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildRevokeNameTx({\n fullyQualifiedName,\n publicKey,\n network,\n}: RevokeNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-revoke';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot revoke a subdomain using revokeName()');\n }\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name)],\n publicKey,\n network,\n });\n}\n\n/\n Renew name options\n /\nexport interface RenewNameOptions {\n /* the fully qualified name to renew including the namespace (myName.id) /\n fullyQualifiedName: string;\n /* amount of STX to burn for the registration /\n stxToBurn: IntegerType;\n /* the private key to sign the transaction /\n publicKey: string;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n /* optionally choose a new owner address /\n newOwnerAddress?: string;\n /* optionally update the zonefile hash /\n zonefile?: string;\n}\n\n/\n Generates a name renew transaction.\n * This renews a name registration.\n \n Resolves to the generated StacksTransaction\n \n @param {RenewNameOptions} options - an options object for the renew\n \n @return {Promise<StacksTransactionWire>}\n */\nexport async function buildRenewNameTx({\n fullyQualifiedName,\n stxToBurn,\n newOwnerAddress,\n zonefile,\n publicKey,\n network,\n}: RenewNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-renewal';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot renew a subdomain using renewName()');\n }\n\n const functionArgs = [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n uintCV(stxToBurn),\n newOwnerAddress ? someCV(standardPrincipalCV(newOwnerAddress)) : noneCV(),\n zonefile ? someCV(bufferCV(getZonefileHash(zonefile))) : noneCV(),\n ];\n const burnSTXPostCondition: StxPostCondition = {\n type: 'stx-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'eq',\n amount: intToBigInt(stxToBurn),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs,\n publicKey,\n network,\n postConditions: [burnSTXPostCondition],\n });\n}\n"],"names":["root","factory","exports","module","define","amd","this","leafPrototypes","getProto","number","n","Number","isSafeInteger","Error","bool","b","bytes","lengths","Uint8Array","TypeError","length","includes","hash","create","outputLen","blockLen","exists","instance","checkFinished","destroyed","finished","output","out","min","Object","defineProperty","value","assert","SHA2","_assert_js_1","utils_js_1","Hash","constructor","padOffset","isLE","super","pos","buffer","view","createView","update","data","default","len","toBytes","take","Math","set","subarray","process","dataView","roundClean","digestInto","fill","i","byteOffset","setBigUint64","_32n","BigInt","_u32_max","wh","wl","h","l","setUint32","oview","outLen","state","get","digest","res","slice","destroy","_cloneInto","to","crypto","node","undefined","web","self","sha224","sha256","_sha2_js_1","Maj","a","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","A","B","C","D","E","F","G","H","offset","getUint32","W15","W2","s0","rotr","s1","T1","T2","SHA224","wrapConstructor","randomBytes","wrapConstructorWithOpts","checkOpts","concatBytes","utf8ToBytes","asyncLoop","nextTick","hexToBytes","bytesToHex","u32","u8","crypto_1","arr","byteLength","floor","DataView","word","shift","hexes","Array","from","v","toString","padStart","str","TextEncoder","encode","uint8a","hex","array","j","hexByte","byte","parseInt","isNaN","async","iters","tick","cb","ts","Date","now","diff","arrays","every","reduce","result","pad","clone","defaults","opts","obj","prototype","call","assign","hashConstructor","hashC","message","tmp","hashCons","msg","bytesLength","getRandomValues","ALPHABET","BASE_MAP","x","charAt","xc","charCodeAt","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","source","psz","zeroes","size","b256","carry","it3","it4","vch","ArrayBuffer","isView","isArray","pbegin","pend","b58","it1","it2","repeat","decode","string","c32ToB58","b58ToC32","c32addressDecode","c32address","versions","checksum_1","base58check","utils_1","mainnet","p2pkh","p2sh","testnet","ADDR_BITCOIN_TO_STACKS","ADDR_STACKS_TO_BITCOIN","version","hash160hex","match","c32checkEncode","c32addr","c32checkDecode","b58check","addrInfo","hash160String","addrVersion","prefix","stacksVersion","c32string","bitcoinVersion","sha256_1","basex","dataBytes","prefixBytes","checksum","forEach","check","index","encoding_1","c32checksum","dataHex","dataHash","toLowerCase","versionHex","checksumHex","c32str","c32encode","c32","c32data","c32normalize","c32decode","versionChar","indexOf","substring","c32input","toUpperCase","replace","inputHex","minLength","currentCode","nextCode","nextBits","nextLowBits","curC32Digit","unshift","C32leadingZeros","zeroPrefix","TextDecoder","numLeadingZeroBytesInHex","count","join","numLeadingZeroBytes","carryBits","currentValue","currentHexDigit","hexLeadingZeros","hexStr","address_1","enumerable","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","boolTag","dateTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","g","freeSelf","Function","freeExports","nodeType","freeModule","moduleExports","addMapEntry","map","pair","addSetEntry","add","arrayReduce","iteratee","accumulator","initAccum","isHostObject","e","mapToArray","key","overArg","func","transform","arg","setToArray","uid","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","exec","keys","IE_PROTO","funcToString","hasOwnProperty","objectToString","reIsNative","RegExp","Buffer","Symbol","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","splice","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","entries","clear","entry","ListCache","MapCache","Stack","__data__","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","input","initCloneArray","copyArray","tag","getTag","isFunc","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","symbol","Ctor","cloneArrayBuffer","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","initCloneByTag","stacked","props","keysFunc","symbolsFunc","values","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","arrayBuffer","newValue","getMapData","type","getValue","isFunction","test","baseIsNative","has","pop","push","cache","pairs","LARGE_ARRAY_SIZE","isIndex","other","resolve","ctorString","isArrayLike","isLength","inherited","isObjectLike","isArrayLikeObject","isArguments","baseTimes","String","skipIndexes","arrayLikeKeys","baseKeys","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","d","t","mode","then","ns","r","def","current","getOwnPropertyNames","definition","o","globalThis","window","prop","toStringTag","nmd","paths","children","intToBytes","bigIntToBytes","isInteger","RangeError","hexToBigInt","intToHex","integer","bytesToTwosBigInt","width","nthBit","_","u","asciiToBytes","byteArray","bytesToAscii","fromCharCode","apply","isNotOctet","octet","octetsToBytes","numbers","some","elements","clazz","name","PRIVATE_KEY_BYTES_COMPRESSED","defaultFetchOpts","referrerPolicy","headers","fetchWrapper","init","fetchOpts","fetch","createFetchFn","args","fetchLib","middlewares","argsForCreateFetchFn","url","fetchParams","middleware","pre","response","post","ChainId","PeerNetworkId","AddressVersion","TransactionVersion","Mainnet","chainId","transactionVersion","peerNetworkId","magicBytes","bootAddress","addressVersion","singleSig","MainnetSingleSig","multiSig","MainnetMultiSig","client","baseUrl","STACKS_TESTNET","Testnet","TestnetSingleSig","TestnetMultiSig","STACKS_DEVNET","STACKS_MOCKNET","network","networkFromName","writeUInt32BE","destination","MAX_STRING_LENGTH_BYTES","CLARITY_INT_SIZE","CLARITY_INT_BYTE_SIZE","AnchorMode","ClarityVersion","PayloadType","FungibleConditionCode","NonFungibleConditionCode","AssetType","TxRejectedReason","AuthFieldType","TenureChangeCause","PostConditionPrincipalId","PubKeyEncoding","AddressHashMode","AuthType","PostConditionType","PostConditionMode","OnChainOnly","OffChainOnly","Any","TransactionError","captureStackTrace","SerializationError","NoEstimateAvailableError","SigningError","HMAC","_key","iHash","oHash","buf","hmac","_0n","_1n","_2n","_3n","_8n","CURVE","freeze","P","Gx","Gy","beta","divNearest","endo","splitScalar","k","a1","b1","a2","b2","POW_2_128","c1","c2","k1","mod","k2","k1neg","k2neg","fieldLen","groupLen","compressedLen","uncompressedLen","weierstrass","x2","x3","USE_ENDOMORPHISM","ShaError","assertJacPoint","JacobianPoint","y","z","fromAffine","p","equals","ZERO","toAffineBatch","points","toInv","nums","scratch","inverted","invert","acc","num","reduceRight","invertBatch","toAffine","normalizeZ","X1","Y1","Z1","X2","Y2","Z2","Z1Z1","Z2Z2","U1","U2","S1","S2","negate","double","x1b","X3","Y3","Z3","HH","HHH","V","subtract","multiplyUnsafe","scalar","P0","normalizeScalar","k1p","k2p","precomputeWindow","W","windows","base","wNAF","affinePoint","_WINDOW_SIZE","precomputes","pointPrecomputes","f","windowSize","mask","maxNumber","shiftBy","wbits","offset1","offset2","abs","cond1","cond2","constTimeNegate","multiply","point","fake","f1p","f2p","invZ","is0","iz1","iz2","iz3","ax","ay","zz","condition","item","neg","_setWindowSize","delete","hasEvenY","fromCompressedHex","isShort","bytesToNumber","isValidFieldElement","_6n","_11n","_22n","_23n","_44n","_88n","b3","b6","pow2","b9","b11","b22","b44","b88","b176","b220","b223","t1","t2","rt","sqrtMod","isYOdd","assertValidity","fromUncompressedHex","fromHex","ensureBytes","header","fromPrivateKey","privateKey","normalizePrivateKey","fromSignature","msgHash","signature","recovery","s","Signature","fromDER","error","fromCompact","normalizeSignature","truncateHash","radj","rinv","u1","u2","R","numTo32bStr","Q","multiplyAndAddUnsafe","toRawBytes","isCompressed","toHex","toHexX","toRawX","left","aP","bQ","sum","sliceDER","parseDERInt","hexToNumber","sBytes","rBytesLeft","parseDERSignature","isWithinCurveOrder","hasHighS","HALF","normalizeS","toDERRawBytes","toDERHex","sHex","numberToHexUnpadded","rHex","sHexL","rHexL","sLen","rLen","toCompactRawBytes","toCompactHex","POW_2_256","numTo32b","power","modulo","q","m","truncateOnly","delta","bits2int_2","_sha256Sync","_hmacSha256Sync","HmacDrbg","hashLen","qByteLen","counter","hmacSha256","hmacSync","checkSync","incr","reseed","seed","reseedSync","generate","sl","generateSync","kmdToSig","kBytes","lowS","kinv","sig","bits2int","bits2octets","z1","z2","int2octets","TAGGED_HASH_PREFIXES","isValidPrivateKey","_bigintTo32Bytes","_normalizePrivateKey","hashToPrivateKey","minLen","randomPrivateKey","precompute","cached","messages","subtle","createHash","ckey","importKey","sign","createHmac","sha256Sync","hmacSha256Sync","taggedHash","tagP","tagH","taggedHashSync","_JacobianPoint","defineProperties","configurable","val","COORDINATE_BYTES","privateKeyToBytes","privateKeyBuffer","Rho","Id","Pi","idxL","idxR","shifts","shiftsL","idx","shiftsR","Kl","Kr","rotl","group","BUF","RIPEMD160","h0","h1","h2","h3","h4","al","ar","bl","br","cl","cr","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sr","tl","tr","ripemd160","U32_MASK64","fromBig","le","lst","Ah","Al","Bh","Bl","Cl","low","Ch","Dl","Dh","Eh","El","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","SHA512_224","SHA512_256","SHA384","sha512_256","enumCheckFunctions","isEnum","enumVariable","checker","newChecker","enumValues","filter","enumValueSet","createEnumChecker","consumed","readBytes","readUInt32BE","readUInt8","readUInt16BE","readBigUIntLE","reverse","readBigUIntBE","readOffset","internalBytes","readUInt8Enum","invalidEnumErrorFormatter","ClarityWireType","ClarityType","clarityTypeToByte","MAX_U128","MIN_U128","MAX_I128","MIN_I128","startsWith","bigInt","Int","UInt","BoolTrue","BoolFalse","StacksWireType","lengthPrefixBytes","LengthPrefixedList","MessageSignature","content","maxLengthBytes","prefixLength","maxLength","LengthPrefixedString","c32AddressString","addressData","Address","hash160","pubKeyEncoding","contents","TransactionAuthField","addressFromPublicKeys","hashMode","numSigs","publicKeys","P2PKH","P2WPKH","P2WSH","P2WSHNonSequential","addressFromVersionHash","hashP2PKH","hashP2WPKH","P2SH","P2SHNonSequential","hashP2SH","serializePublicKeyBytes","hashP2WSH","address","parseAssetString","assetAddress","assetContractName","assetTokenName","split","addressString","contractName","assetName","Asset","parsePrincipalString","principalString","addr","Principal","Contract","createContractPrincipal","Standard","createStandardPrincipal","PrincipalStandard","OptionalNone","OptionalSome","tupleCV","Tuple","StringASCII","StringUTF8","serializedClarityValue","bytesReader","hasHexPrefix","int","uint","bufferLength","true","false","deserializeAddress","contract","PrincipalContract","contractPrincipalCVFromAddress","deserializeLPString","ok","ResponseOk","err","ResponseErr","responseErrorCV","none","list","listLength","listContents","List","tuple","tupleLength","tupleContents","clarityName","ascii","asciiStrLen","asciiStr","utf8","utf8StrLen","utf8Str","serializeStacksWireBytes","wire","serializeAddressBytes","serializePrincipalBytes","serializeLPStringBytes","MemoString","memoString","bytesArray","contentBytes","paddedContent","rightPadHexToLength","serializeMemoStringBytes","serializeAssetBytes","PostCondition","postCondition","conditionType","principal","Fungible","NonFungible","asset","serializeCVBytes","conditionCode","STX","amount","serializePostConditionWireBytes","PublicKey","serializeLPListBytes","Payload","serializePayloadBytes","field","Compressed","PublicKeyCompressed","PublicKeyUncompressed","publicKey","SignatureCompressed","SignatureUncompressed","serializeMessageSignatureBytes","serializeTransactionAuthFieldBytes","serialized","lps","info","deserializeAsset","lpList","postConditionType","Origin","deserializePrincipal","payload","payloadType","TokenTransfer","recipient","memo","ContractCall","contractAddress","functionName","numArgs","functionArgs","SmartContract","codeBody","VersionedSmartContract","clarityVersion","PoisonMicroblock","Coinbase","coinbaseBytes","CoinbaseToAltRecipient","NakamotoCoinbase","vrfProof","TenureChange","tenureHash","previousTenureHash","burnViewHash","previousTenureEnd","previousTenureBlocks","writeUInt8","cause","publicKeyHash","messageSignature","bytesWithTypeID","typeId","serializeStringCV","cv","encoding","serializeBoolCV","ceil","serializeBufferCV","serializeUIntCV","toTwos","serializeIntCV","serializeStandardPrincipalCV","contractId","parseContractId","serializeContractPrincipalCV","serializeResponseCV","serializedValue","serializeListCV","lexicographicOrder","sort","localeCompare","nameWithLength","serializeTupleCV","serializeStringAsciiCV","serializeStringUtf8CV","leftPadHex","hexString","padEnd","cloneDeep","txidFromData","keyHash","redeemScript","pubKeys","pubKey","scriptArray","script","parseReadOnlyResponse","okay","getAddressFromPrivateKey","addrVer","addressHashModeToVersion","getAddressFromPublicKey","msgs","privateKeyIsCompressed","makeRandomPrivKey","signWithKey","messageHash","rawSignature","recoveryId","privKey","extraEntropy","seedArgs","initSigArgs","drbg","canonical","recSig","der","recovered","hashed","finalizeSig","signSync","_publicKeyToAddress","publicKeyToAddressSingleSig","emptyMessageSignature","nonce","fee","signer","keyEncoding","Uncompressed","isSequentialMultiSig","clearCondition","cloned","fields","serializeSpendingConditionBytes","serializeSingleSigSpendingConditionBytes","writeUInt16BE","signaturesRequired","serializeMultiSigSpendingConditionBytes","sigHashPreSign","curSigHash","authType","sigHash","sigHashPostSign","hashLength","sigHashBytes","nextVerification","initialSigHash","sigHashPre","parsedSignature","recoveryIdHex","parseRecoverableSignatureVrs","compressed","publicKeyFromSignatureVrs","nextSigHash","spendingCondition","sponsorSpendingCondition","Sponsored","intoInitialSighashAuth","auth","newInitialSigHash","cvToString","JSON","stringify","getCVTypeString","ClarityAbiTypeId","isClarityAbiPrimitive","isClarityAbiBuffer","isClarityAbiStringAscii","isClarityAbiStringUtf8","isClarityAbiResponse","isClarityAbiOptional","optional","isClarityAbiTuple","isClarityAbiList","getTypeString","matchType","abiType","union","ClarityAbiTypeUInt128","ClarityAbiTypeInt128","ClarityAbiTypeBool","ClarityAbiTypePrincipal","ClarityAbiTypeTraitReference","ClarityAbiTypeNone","ClarityAbiTypeBuffer","ClarityAbiTypeResponse","ClarityAbiTypeOptional","ClarityAbiTypeTuple","ClarityAbiTypeList","ClarityAbiTypeStringAscii","ClarityAbiTypeStringUtf8","getTypeUnion","abiTupleEntry","postConditions","postConditionMode","Deny","anchorMode","signBegin","tx","txid","verifyBegin","verifyOrigin","addrBytes","verifySingleSig","haveUncompressed","verifyMultiSig","signNextOrigin","signAndAppend","signNextSponsor","appendPubkey","cond","nextSig","nextSignature","serializeBytes","setSponsor","setFee","setNonce","setSponsorNonce","serialize","chainIdBytes","serializeAuthorizationBytes","transaction","TRANSFER_FEE_ESTIMATE_PATH","TRANSACTION_FEE_ESTIMATE_PATH","ACCOUNT_PATH","CONTRACT_ABI_PATH","READONLY_FUNCTION_CALL_PATH","PostConditionCodeWireType","conditionTypeToByte","makeUnsignedContractCall","txOptions","defaultOptions","sponsored","options","Allow","validateWithAbi","abi","_client","text","catch","status","statusText","parse","fetchAbi","filtered","functions","fn","abiArgs","payloadArg","abiArg","argNum","validateContractCall","useNonSequentialMultiSig","publicKeysSorted","sortPublicKeysForAddress","numSignatures","authorization","lpPostConditions","pc","postcondition","assetId","txOpt","_network","estimatedLength","multiSigSpendingCondition","existingSignatures","totalSignatureLength","estimateTransactionByteLength","json","transaction_payload","estimated_len","method","body","reason_data","estimations","fetchFeeEstimateTransaction","Accept","feeRateResult","txBytes","fetchFeeEstimateTransfer","txNonce","possible_next_nonce","_getNonceApi","decodeFQN","fqdn","nameParts","subdomain","namespace","getZonefileHash","zonefile","BNS_CONTRACT_NAME","makeBnsContractCall","callReadOnlyBnsFunction","senderAddress","sender","arguments","encodeURIComponent","fetchCallReadOnlyFunction","canRegisterName","fullyQualifiedName","responseCV","getNamespacePrice","getNamePrice","buildPreorderNamespaceTx","salt","stxToBurn","saltedNamespaceBytes","hashedSaltedNamespace","burnSTXPostCondition","buildRevealNamespaceTx","priceFunction","lifetime","namespaceImportAddress","coefficient","b4","b5","b7","b8","b10","b12","b13","b14","b15","b16","nonAlphaDiscount","noVowelDiscount","buildImportNameTx","beneficiary","zonefileHash","buildReadyNamespaceTx","buildPreorderNameTx","saltedNamesBytes","hashedSaltedName","buildRegisterNameTx","buildUpdateNameTx","buildTransferNameTx","newOwnerAddress","buildRevokeNameTx","buildRenewNameTx"],"sourceRoot":""}
1	+ {"version":3,"file":"index.js","mappings":";CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAmB,UAAID,IAEvBD,EAAgB,UAAIC,GACrB,CATD,CASGK,MAAM,cCRLC,EADAC,8BCGJ,SAASC,EAAOC,GACZ,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAChC,MAAM,IAAIG,MAAM,2BAA2BH,IACnD,CAEA,SAASI,EAAKC,GACV,GAAiB,kBAANA,EACP,MAAM,IAAIF,MAAM,yBAAyBE,IACjD,CAEA,SAASC,EAAMD,KAAME,GACjB,KAAMF,aAAaG,YACf,MAAM,IAAIC,UAAU,uBACxB,GAAIF,EAAQG,OAAS,IAAMH,EAAQI,SAASN,EAAEK,QAC1C,MAAM,IAAID,UAAU,iCAAiCF,oBAA0BF,EAAEK,SACzF,CAEA,SAASE,EAAKA,GACV,GAAoB,mBAATA,GAA8C,mBAAhBA,EAAKC,OAC1C,MAAM,IAAIV,MAAM,mDACpBJ,EAAOa,EAAKE,WACZf,EAAOa,EAAKG,SAChB,CAEA,SAASC,EAAOC,EAAUC,GAAgB,GACtC,GAAID,EAASE,UACT,MAAM,IAAIhB,MAAM,oCACpB,GAAIe,GAAiBD,EAASG,SAC1B,MAAM,IAAIjB,MAAM,wCACxB,CAEA,SAASkB,EAAOC,EAAKL,GACjBX,EAAMgB,GACN,MAAMC,EAAMN,EAASH,UACrB,GAAIQ,EAAIZ,OAASa,EACb,MAAM,IAAIpB,MAAM,yDAAyDoB,IAEjF,CAvCAC,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQ6B,OAAS7B,EAAQwB,OAASxB,EAAQoB,KAAOpB,EAAQc,MAAQd,EAAQY,KAAOZ,EAAQO,YAAS,EAKjGP,EAAQO,OAASA,EAKjBP,EAAQY,KAAOA,EAOfZ,EAAQc,MAAQA,EAOhBd,EAAQoB,KAAOA,EAOfpB,EAAQwB,OAASA,EAQjBxB,EAAQ6B,OAASA,EACjB,MAAMM,EAAS,CACX5B,SACAK,OACAE,QACAM,OACAI,SACAK,UAEJ7B,EAAA,QAAkBmC,8BCjDlBH,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQoC,UAAO,EACf,MAAMC,EAAe,EAAQ,KACvBC,EAAa,EAAQ,IAe3B,MAAMF,UAAaE,EAAWC,KAC1B,WAAAC,CAAYjB,EAAUD,EAAWmB,EAAWC,GACxCC,QACAvC,KAAKmB,SAAWA,EAChBnB,KAAKkB,UAAYA,EACjBlB,KAAKqC,UAAYA,EACjBrC,KAAKsC,KAAOA,EACZtC,KAAKwB,UAAW,EAChBxB,KAAKc,OAAS,EACdd,KAAKwC,IAAM,EACXxC,KAAKuB,WAAY,EACjBvB,KAAKyC,OAAS,IAAI7B,WAAWO,GAC7BnB,KAAK0C,MAAO,EAAIR,EAAWS,YAAY3C,KAAKyC,OAChD,CACA,MAAAG,CAAOC,GACHZ,EAAaa,QAAQ1B,OAAOpB,MAC5B,MAAM,KAAE0C,EAAI,OAAED,EAAM,SAAEtB,GAAanB,KAE7B+C,GADNF,GAAO,EAAIX,EAAWc,SAASH,IACd/B,OACjB,IAAK,IAAI0B,EAAM,EAAGA,EAAMO,GAAM,CAC1B,MAAME,EAAOC,KAAKvB,IAAIR,EAAWnB,KAAKwC,IAAKO,EAAMP,GAEjD,GAAIS,IAAS9B,EAMbsB,EAAOU,IAAIN,EAAKO,SAASZ,EAAKA,EAAMS,GAAOjD,KAAKwC,KAChDxC,KAAKwC,KAAOS,EACZT,GAAOS,EACHjD,KAAKwC,MAAQrB,IACbnB,KAAKqD,QAAQX,EAAM,GACnB1C,KAAKwC,IAAM,OAXf,CACI,MAAMc,GAAW,EAAIpB,EAAWS,YAAYE,GAC5C,KAAO1B,GAAY4B,EAAMP,EAAKA,GAAOrB,EACjCnB,KAAKqD,QAAQC,EAAUd,EAE/B,CAQJ,CAGA,OAFAxC,KAAKc,QAAU+B,EAAK/B,OACpBd,KAAKuD,aACEvD,IACX,CACA,UAAAwD,CAAW9B,GACPO,EAAaa,QAAQ1B,OAAOpB,MAC5BiC,EAAaa,QAAQrB,OAAOC,EAAK1B,MACjCA,KAAKwB,UAAW,EAIhB,MAAM,OAAEiB,EAAM,KAAEC,EAAI,SAAEvB,EAAQ,KAAEmB,GAAStC,KACzC,IAAI,IAAEwC,GAAQxC,KAEdyC,EAAOD,KAAS,IAChBxC,KAAKyC,OAAOW,SAASZ,GAAKiB,KAAK,GAE3BzD,KAAKqC,UAAYlB,EAAWqB,IAC5BxC,KAAKqD,QAAQX,EAAM,GACnBF,EAAM,GAGV,IAAK,IAAIkB,EAAIlB,EAAKkB,EAAIvC,EAAUuC,IAC5BjB,EAAOiB,GAAK,GAxExB,SAAsBhB,EAAMiB,EAAY7B,EAAOQ,GAC3C,GAAiC,mBAAtBI,EAAKkB,aACZ,OAAOlB,EAAKkB,aAAaD,EAAY7B,EAAOQ,GAChD,MAAMuB,EAAOC,OAAO,IACdC,EAAWD,OAAO,YAClBE,EAAK3D,OAAQyB,GAAS+B,EAAQE,GAC9BE,EAAK5D,OAAOyB,EAAQiC,GACpBG,EAAI5B,EAAO,EAAI,EACf6B,EAAI7B,EAAO,EAAI,EACrBI,EAAK0B,UAAUT,EAAaO,EAAGF,EAAI1B,GACnCI,EAAK0B,UAAUT,EAAaQ,EAAGF,EAAI3B,EACvC,CAiEQsB,CAAalB,EAAMvB,EAAW,EAAG2C,OAAqB,EAAd9D,KAAKc,QAAawB,GAC1DtC,KAAKqD,QAAQX,EAAM,GACnB,MAAM2B,GAAQ,EAAInC,EAAWS,YAAYjB,GACnCqB,EAAM/C,KAAKkB,UAEjB,GAAI6B,EAAM,EACN,MAAM,IAAIxC,MAAM,+CACpB,MAAM+D,EAASvB,EAAM,EACfwB,EAAQvE,KAAKwE,MACnB,GAAIF,EAASC,EAAMzD,OACf,MAAM,IAAIP,MAAM,sCACpB,IAAK,IAAImD,EAAI,EAAGA,EAAIY,EAAQZ,IACxBW,EAAMD,UAAU,EAAIV,EAAGa,EAAMb,GAAIpB,EACzC,CACA,MAAAmC,GACI,MAAM,OAAEhC,EAAM,UAAEvB,GAAclB,KAC9BA,KAAKwD,WAAWf,GAChB,MAAMiC,EAAMjC,EAAOkC,MAAM,EAAGzD,GAE5B,OADAlB,KAAK4E,UACEF,CACX,CACA,UAAAG,CAAWC,GACPA,IAAOA,EAAK,IAAI9E,KAAKoC,aACrB0C,EAAG3B,OAAOnD,KAAKwE,OACf,MAAM,SAAErD,EAAQ,OAAEsB,EAAM,OAAE3B,EAAM,SAAEU,EAAQ,UAAED,EAAS,IAAEiB,GAAQxC,KAO/D,OANA8E,EAAGhE,OAASA,EACZgE,EAAGtC,IAAMA,EACTsC,EAAGtD,SAAWA,EACdsD,EAAGvD,UAAYA,EACXT,EAASK,GACT2D,EAAGrC,OAAOU,IAAIV,GACXqC,CACX,EAEJlF,EAAQoC,KAAOA,4BCnHfJ,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQmF,YAAS,EACjBnF,EAAQmF,OAAS,CACbC,UAAMC,EACNC,IAAqB,iBAATC,MAAqB,WAAYA,KAAOA,KAAKJ,YAASE,8BCJtErD,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQwF,OAASxF,EAAQyF,YAAS,EAClC,MAAMC,EAAa,EAAQ,KACrBpD,EAAa,EAAQ,IAIrBqD,EAAM,CAACC,EAAG/E,EAAGgF,IAAOD,EAAI/E,EAAM+E,EAAIC,EAAMhF,EAAIgF,EAI5CC,EAAW,IAAIC,YAAY,CAC7B,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WACpF,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UACpF,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UACpF,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,aAIlFC,EAAK,IAAID,YAAY,CACvB,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,aAIlFE,EAAW,IAAIF,YAAY,IACjC,MAAMG,UAAeR,EAAWtD,KAC5B,WAAAI,GACIG,MAAM,GAAI,GAAI,GAAG,GAGjBvC,KAAK+F,EAAY,EAARH,EAAG,GACZ5F,KAAKgG,EAAY,EAARJ,EAAG,GACZ5F,KAAKiG,EAAY,EAARL,EAAG,GACZ5F,KAAKkG,EAAY,EAARN,EAAG,GACZ5F,KAAKmG,EAAY,EAARP,EAAG,GACZ5F,KAAKoG,EAAY,EAARR,EAAG,GACZ5F,KAAKqG,EAAY,EAART,EAAG,GACZ5F,KAAKsG,EAAY,EAARV,EAAG,EAChB,CACA,GAAApB,GACI,MAAM,EAAEuB,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,GAAMtG,KACnC,MAAO,CAAC+F,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EACjC,CAEA,GAAAnD,CAAI4C,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GACrBtG,KAAK+F,EAAQ,EAAJA,EACT/F,KAAKgG,EAAQ,EAAJA,EACThG,KAAKiG,EAAQ,EAAJA,EACTjG,KAAKkG,EAAQ,EAAJA,EACTlG,KAAKmG,EAAQ,EAAJA,EACTnG,KAAKoG,EAAQ,EAAJA,EACTpG,KAAKqG,EAAQ,EAAJA,EACTrG,KAAKsG,EAAQ,EAAJA,CACb,CACA,OAAAjD,CAAQX,EAAM6D,GAEV,IAAK,IAAI7C,EAAI,EAAGA,EAAI,GAAIA,IAAK6C,GAAU,EACnCV,EAASnC,GAAKhB,EAAK8D,UAAUD,GAAQ,GACzC,IAAK,IAAI7C,EAAI,GAAIA,EAAI,GAAIA,IAAK,CAC1B,MAAM+C,EAAMZ,EAASnC,EAAI,IACnBgD,EAAKb,EAASnC,EAAI,GAClBiD,GAAK,EAAIzE,EAAW0E,MAAMH,EAAK,IAAK,EAAIvE,EAAW0E,MAAMH,EAAK,IAAOA,IAAQ,EAC7EI,GAAK,EAAI3E,EAAW0E,MAAMF,EAAI,KAAM,EAAIxE,EAAW0E,MAAMF,EAAI,IAAOA,IAAO,GACjFb,EAASnC,GAAMmD,EAAKhB,EAASnC,EAAI,GAAKiD,EAAKd,EAASnC,EAAI,IAAO,CACnE,CAEA,IAAI,EAAEqC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,GAAMtG,KACjC,IAAK,IAAI0D,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,MACMoD,EAAMR,IADG,EAAIpE,EAAW0E,MAAMT,EAAG,IAAK,EAAIjE,EAAW0E,MAAMT,EAAG,KAAM,EAAIjE,EAAW0E,MAAMT,EAAG,OAnEjGX,EAoE4BW,GAAGC,GApEPZ,EAoEUa,GAAKX,EAAShC,GAAKmC,EAASnC,GAAM,EAE/DqD,IADS,EAAI7E,EAAW0E,MAAMb,EAAG,IAAK,EAAI7D,EAAW0E,MAAMb,EAAG,KAAM,EAAI7D,EAAW0E,MAAMb,EAAG,KAC7ER,EAAIQ,EAAGC,EAAGC,GAAM,EACrCK,EAAID,EACJA,EAAID,EACJA,EAAID,EACJA,EAAKD,EAAIY,EAAM,EACfZ,EAAID,EACJA,EAAID,EACJA,EAAID,EACJA,EAAKe,EAAKC,EAAM,CACpB,CA/EI,IAACvB,EAiFLO,EAAKA,EAAI/F,KAAK+F,EAAK,EACnBC,EAAKA,EAAIhG,KAAKgG,EAAK,EACnBC,EAAKA,EAAIjG,KAAKiG,EAAK,EACnBC,EAAKA,EAAIlG,KAAKkG,EAAK,EACnBC,EAAKA,EAAInG,KAAKmG,EAAK,EACnBC,EAAKA,EAAIpG,KAAKoG,EAAK,EACnBC,EAAKA,EAAIrG,KAAKqG,EAAK,EACnBC,EAAKA,EAAItG,KAAKsG,EAAK,EACnBtG,KAAKmD,IAAI4C,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAClC,CACA,UAAA/C,GACIsC,EAASpC,KAAK,EAClB,CACA,OAAAmB,GACI5E,KAAKmD,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAC9BnD,KAAKyC,OAAOgB,KAAK,EACrB,EAGJ,MAAMuD,UAAelB,EACjB,WAAA1D,GACIG,QACAvC,KAAK+F,GAAI,WACT/F,KAAKgG,EAAI,UACThG,KAAKiG,EAAI,UACTjG,KAAKkG,GAAI,UACTlG,KAAKmG,GAAI,QACTnG,KAAKoG,EAAI,WACTpG,KAAKqG,EAAI,WACTrG,KAAKsG,GAAI,WACTtG,KAAKkB,UAAY,EACrB,EAMJtB,EAAQyF,QAAS,EAAInD,EAAW+E,kBAAiB,IAAM,IAAInB,IAC3DlG,EAAQwF,QAAS,EAAIlD,EAAW+E,kBAAiB,IAAM,IAAID,+BC3H3DpF,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQsH,YAActH,EAAQuH,wBAA0BvH,EAAQqH,gBAAkBrH,EAAQwH,UAAYxH,EAAQuC,KAAOvC,EAAQyH,YAAczH,EAAQoD,QAAUpD,EAAQ0H,YAAc1H,EAAQ2H,UAAY3H,EAAQ4H,SAAW5H,EAAQ6H,WAAa7H,EAAQ8H,WAAa9H,EAAQ0C,KAAO1C,EAAQgH,KAAOhH,EAAQ+C,WAAa/C,EAAQ+H,IAAM/H,EAAQgI,QAAK,EAGlV,MAAMC,EAAW,EAAQ,KAezB,GAZAjI,EAAQgI,GADIE,GAAQ,IAAIlH,WAAWkH,EAAIrF,OAAQqF,EAAInE,WAAYmE,EAAIC,YAGnEnI,EAAQ+H,IADKG,GAAQ,IAAInC,YAAYmC,EAAIrF,OAAQqF,EAAInE,WAAYT,KAAK8E,MAAMF,EAAIC,WAAa,IAI7FnI,EAAQ+C,WADYmF,GAAQ,IAAIG,SAASH,EAAIrF,OAAQqF,EAAInE,WAAYmE,EAAIC,YAIzEnI,EAAQgH,KADK,CAACsB,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,EAEjEvI,EAAQ0C,KAAmE,KAA5D,IAAI1B,WAAW,IAAI+E,YAAY,CAAC,YAAalD,QAAQ,IAG/D7C,EAAQ0C,KACT,MAAM,IAAI/B,MAAM,+CACpB,MAAM6H,EAAQC,MAAMC,KAAK,CAAExH,OAAQ,MAAO,CAACyH,EAAG7E,IAAMA,EAAE8E,SAAS,IAAIC,SAAS,EAAG,OAsD/E,SAASnB,EAAYoB,GACjB,GAAmB,iBAARA,EACP,MAAM,IAAI7H,UAAU,2CAA2C6H,GAEnE,OAAO,IAAIC,aAAcC,OAAOF,EACpC,CAEA,SAAS1F,EAAQH,GAGb,GAFoB,iBAATA,IACPA,EAAOyE,EAAYzE,MACjBA,aAAgBjC,YAClB,MAAM,IAAIC,UAAU,iDAAiDgC,MACzE,OAAOA,CACX,CArDAjD,EAAQ8H,WAVR,SAAoBmB,GAEhB,KAAMA,aAAkBjI,YACpB,MAAM,IAAIL,MAAM,uBACpB,IAAIuI,EAAM,GACV,IAAK,IAAIpF,EAAI,EAAGA,EAAImF,EAAO/H,OAAQ4C,IAC/BoF,GAAOV,EAAMS,EAAOnF,IAExB,OAAOoF,CACX,EAsBAlJ,EAAQ6H,WAjBR,SAAoBqB,GAChB,GAAmB,iBAARA,EACP,MAAM,IAAIjI,UAAU,2CAA6CiI,GAErE,GAAIA,EAAIhI,OAAS,EACb,MAAM,IAAIP,MAAM,6CACpB,MAAMwI,EAAQ,IAAInI,WAAWkI,EAAIhI,OAAS,GAC1C,IAAK,IAAI4C,EAAI,EAAGA,EAAIqF,EAAMjI,OAAQ4C,IAAK,CACnC,MAAMsF,EAAQ,EAAJtF,EACJuF,EAAUH,EAAInE,MAAMqE,EAAGA,EAAI,GAC3BE,EAAO7I,OAAO8I,SAASF,EAAS,IACtC,GAAI5I,OAAO+I,MAAMF,IAASA,EAAO,EAC7B,MAAM,IAAI3I,MAAM,yBACpBwI,EAAMrF,GAAKwF,CACf,CACA,OAAOH,CACX,EAKAnJ,EAAQ4H,SADS6B,YAejBzJ,EAAQ2H,UAZR8B,eAAyBC,EAAOC,EAAMC,GAClC,IAAIC,EAAKC,KAAKC,MACd,IAAK,IAAIjG,EAAI,EAAGA,EAAI4F,EAAO5F,IAAK,CAC5B8F,EAAG9F,GAEH,MAAMkG,EAAOF,KAAKC,MAAQF,EACtBG,GAAQ,GAAKA,EAAOL,UAElB,EAAI3J,EAAQ4H,YAClBiC,GAAMG,EACV,CACJ,EAQAhK,EAAQ0H,YAAcA,EAQtB1H,EAAQoD,QAAUA,EAmBlBpD,EAAQyH,YAdR,YAAwBwC,GACpB,IAAKA,EAAOC,OAAOtE,GAAMA,aAAa5E,aAClC,MAAM,IAAIL,MAAM,4BACpB,GAAsB,IAAlBsJ,EAAO/I,OACP,OAAO+I,EAAO,GAClB,MAAM/I,EAAS+I,EAAOE,QAAO,CAACvE,EAAGsC,IAAQtC,EAAIsC,EAAIhH,QAAQ,GACnDkJ,EAAS,IAAIpJ,WAAWE,GAC9B,IAAK,IAAI4C,EAAI,EAAGuG,EAAM,EAAGvG,EAAImG,EAAO/I,OAAQ4C,IAAK,CAC7C,MAAMoE,EAAM+B,EAAOnG,GACnBsG,EAAO7G,IAAI2E,EAAKmC,GAChBA,GAAOnC,EAAIhH,MACf,CACA,OAAOkJ,CACX,EASApK,EAAQuC,KANR,MAEI,KAAA+H,GACI,OAAOlK,KAAK6E,YAChB,GAWJjF,EAAQwH,UANR,SAAmB+C,EAAUC,GACzB,QAAanF,IAATmF,IAAuC,iBAATA,IAFfC,EAEmDD,EAFH,oBAAxCxI,OAAO0I,UAAU9B,SAAS+B,KAAKF,IAA8BA,EAAIjI,cAAgBR,SAGxG,MAAM,IAAIf,UAAU,yCAHN,IAACwJ,EAKnB,OADezI,OAAO4I,OAAOL,EAAUC,EAE3C,EAUAxK,EAAQqH,gBARR,SAAyBwD,GACrB,MAAMC,EAASC,GAAYF,IAAkB7H,OAAOI,EAAQ2H,IAAUlG,SAChEmG,EAAMH,IAIZ,OAHAC,EAAMxJ,UAAY0J,EAAI1J,UACtBwJ,EAAMvJ,SAAWyJ,EAAIzJ,SACrBuJ,EAAMzJ,OAAS,IAAMwJ,IACdC,CACX,EAUA9K,EAAQuH,wBARR,SAAiC0D,GAC7B,MAAMH,EAAQ,CAACI,EAAKV,IAASS,EAAST,GAAMxH,OAAOI,EAAQ8H,IAAMrG,SAC3DmG,EAAMC,EAAS,CAAC,GAItB,OAHAH,EAAMxJ,UAAY0J,EAAI1J,UACtBwJ,EAAMvJ,SAAWyJ,EAAIzJ,SACrBuJ,EAAMzJ,OAAUmJ,GAASS,EAAST,GAC3BM,CACX,EAgBA9K,EAAQsH,YAXR,SAAqB6D,EAAc,IAC/B,GAAIlD,EAAS9C,OAAOG,IAChB,OAAO2C,EAAS9C,OAAOG,IAAI8F,gBAAgB,IAAIpK,WAAWmK,IAEzD,GAAIlD,EAAS9C,OAAOC,KACrB,OAAO,IAAIpE,WAAWiH,EAAS9C,OAAOC,KAAKkC,YAAY6D,GAAatI,QAGpE,MAAM,IAAIlC,MAAM,oDAExB,wBCvCAV,EAAOD,QAlHP,SAAeqL,GACb,GAAIA,EAASnK,QAAU,IAAO,MAAM,IAAID,UAAU,qBAElD,IADA,IAAIqK,EAAW,IAAItK,WAAW,KACrBoI,EAAI,EAAGA,EAAIkC,EAASpK,OAAQkI,IACnCkC,EAASlC,GAAK,IAEhB,IAAK,IAAItF,EAAI,EAAGA,EAAIuH,EAASnK,OAAQ4C,IAAK,CACxC,IAAIyH,EAAIF,EAASG,OAAO1H,GACpB2H,EAAKF,EAAEG,WAAW,GACtB,GAAqB,MAAjBJ,EAASG,GAAe,MAAM,IAAIxK,UAAUsK,EAAI,iBACpDD,EAASG,GAAM3H,CACjB,CACA,IAAI6H,EAAON,EAASnK,OAChB0K,EAASP,EAASG,OAAO,GACzBK,EAASvI,KAAKwI,IAAIH,GAAQrI,KAAKwI,IAAI,KACnCC,EAAUzI,KAAKwI,IAAI,KAAOxI,KAAKwI,IAAIH,GA8CvC,SAASK,EAAcC,GACrB,GAAsB,iBAAXA,EAAuB,MAAM,IAAIhL,UAAU,mBACtD,GAAsB,IAAlBgL,EAAO/K,OAAgB,OAAO,IAAIF,WAKtC,IAJA,IAAIkL,EAAM,EAENC,EAAS,EACTjL,EAAS,EACN+K,EAAOC,KAASN,GACrBO,IACAD,IAMF,IAHA,IAAIE,GAAUH,EAAO/K,OAASgL,GAAOL,EAAU,IAAO,EAClDQ,EAAO,IAAIrL,WAAWoL,GAEnBH,EAAOC,IAAM,CAElB,IAAII,EAAQhB,EAASW,EAAOP,WAAWQ,IAEvC,GAAc,MAAVI,EAAiB,OAErB,IADA,IAAIxI,EAAI,EACCyI,EAAMH,EAAO,GAAc,IAAVE,GAAexI,EAAI5C,KAAqB,IAATqL,EAAaA,IAAOzI,IAC3EwI,GAAUX,EAAOU,EAAKE,KAAU,EAChCF,EAAKE,GAAQD,EAAQ,MAAS,EAC9BA,EAASA,EAAQ,MAAS,EAE5B,GAAc,IAAVA,EAAe,MAAM,IAAI3L,MAAM,kBACnCO,EAAS4C,EACToI,GACF,CAGA,IADA,IAAIM,EAAMJ,EAAOlL,EACVsL,IAAQJ,GAAsB,IAAdC,EAAKG,IAC1BA,IAIF,IAFA,IAAIC,EAAM,IAAIzL,WAAWmL,GAAUC,EAAOI,IACtCpD,EAAI+C,EACDK,IAAQJ,GACbK,EAAIrD,KAAOiD,EAAKG,KAElB,OAAOC,CACT,CAMA,MAAO,CACLzD,OA7FF,SAAiBiD,GAOf,GANIA,aAAkBjL,aACX0L,YAAYC,OAAOV,GAC5BA,EAAS,IAAIjL,WAAWiL,EAAOpJ,OAAQoJ,EAAOlI,WAAYkI,EAAO9D,YACxDM,MAAMmE,QAAQX,KACvBA,EAASjL,WAAW0H,KAAKuD,OAErBA,aAAkBjL,YAAe,MAAM,IAAIC,UAAU,uBAC3D,GAAsB,IAAlBgL,EAAO/K,OAAgB,MAAO,GAMlC,IAJA,IAAIiL,EAAS,EACTjL,EAAS,EACT2L,EAAS,EACTC,EAAOb,EAAO/K,OACX2L,IAAWC,GAA2B,IAAnBb,EAAOY,IAC/BA,IACAV,IAMF,IAHA,IAAIC,GAASU,EAAOD,GAAUd,EAAU,IAAO,EAC3CgB,EAAM,IAAI/L,WAAWoL,GAElBS,IAAWC,GAAM,CAItB,IAHA,IAAIR,EAAQL,EAAOY,GAEf/I,EAAI,EACCkJ,EAAMZ,EAAO,GAAc,IAAVE,GAAexI,EAAI5C,KAAqB,IAAT8L,EAAaA,IAAOlJ,IAC3EwI,GAAU,IAAMS,EAAIC,KAAU,EAC9BD,EAAIC,GAAQV,EAAQX,IAAU,EAC9BW,EAASA,EAAQX,IAAU,EAE7B,GAAc,IAAVW,EAAe,MAAM,IAAI3L,MAAM,kBACnCO,EAAS4C,EACT+I,GACF,CAGA,IADA,IAAII,EAAMb,EAAOlL,EACV+L,IAAQb,GAAqB,IAAbW,EAAIE,IACzBA,IAIF,IADA,IAAInE,EAAM8C,EAAOsB,OAAOf,GACjBc,EAAMb,IAAQa,EAAOnE,GAAOuC,EAASG,OAAOuB,EAAIE,IACvD,OAAOnE,CACT,EAkDEkD,aAAcA,EACdmB,OARF,SAAiBC,GACf,IAAIvK,EAASmJ,EAAaoB,GAC1B,GAAIvK,EAAU,OAAOA,EACrB,MAAM,IAAIlC,MAAM,WAAagL,EAAO,aACtC,EAMF,6BCtHA3J,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQqN,SAAWrN,EAAQsN,SAAWtN,EAAQuN,iBAAmBvN,EAAQwN,WAAaxN,EAAQyN,cAAW,EACzG,MAAMC,EAAa,EAAQ,KACrBC,EAAc,EAAQ,KACtBC,EAAU,EAAQ,IACxB5N,EAAQyN,SAAW,CACfI,QAAS,CACLC,MAAO,GACPC,KAAM,IAEVC,QAAS,CACLF,MAAO,GACPC,KAAM,KAId,MAAME,EAAyB,CAAC,EAChCA,EAAuB,GAAKjO,EAAQyN,SAASI,QAAQC,MACrDG,EAAuB,GAAKjO,EAAQyN,SAASI,QAAQE,KACrDE,EAAuB,KAAOjO,EAAQyN,SAASO,QAAQF,MACvDG,EAAuB,KAAOjO,EAAQyN,SAASO,QAAQD,KAEvD,MAAMG,EAAyB,CAAC,EAahC,SAASV,EAAWW,EAASC,GACzB,IAAKA,EAAWC,MAAM,qBAClB,MAAM,IAAI1N,MAAM,8CAGpB,MAAO,KADW,EAAI+M,EAAWY,gBAAgBH,EAASC,IAE9D,CAOA,SAASb,EAAiBgB,GACtB,GAAIA,EAAQrN,QAAU,EAClB,MAAM,IAAIP,MAAM,uCAEpB,GAAkB,KAAd4N,EAAQ,GACR,MAAM,IAAI5N,MAAM,4CAEpB,OAAO,EAAI+M,EAAWc,gBAAgBD,EAAQxJ,MAAM,GACxD,CAjCAmJ,EAAuBlO,EAAQyN,SAASI,QAAQC,OAAS,EACzDI,EAAuBlO,EAAQyN,SAASI,QAAQE,MAAQ,EACxDG,EAAuBlO,EAAQyN,SAASO,QAAQF,OAAS,IACzDI,EAAuBlO,EAAQyN,SAASO,QAAQD,MAAQ,IAgBxD/N,EAAQwN,WAAaA,EAerBxN,EAAQuN,iBAAmBA,EAyB3BvN,EAAQsN,SAhBR,SAAkBmB,EAAUN,GAAU,GAClC,MAAMO,EAAWf,EAAYR,OAAOsB,GAC9BE,GAAgB,EAAIf,EAAQ9F,YAAY4G,EAASzL,MACjD2L,EAAcrF,UAAS,EAAIqE,EAAQ9F,YAAY4G,EAASG,QAAS,IACvE,IAAIC,EAUJ,OATIX,EAAU,GACVW,EAAgBF,OAC4BvJ,IAAxC4I,EAAuBW,KACvBE,EAAgBb,EAAuBW,KAI3CE,EAAgBX,EAEbX,EAAWsB,EAAeH,EACrC,EA6BA3O,EAAQqN,SApBR,SAAkB0B,EAAWZ,GAAU,GACnC,MAAMO,EAAWnB,EAAiBwB,GAC5BD,EAAgBJ,EAAS,GACzBC,EAAgBD,EAAS,GAC/B,IAAIM,EACAb,EAAU,GACVa,EAAiBF,OAC6BzJ,IAA1C6I,EAAuBY,KACvBE,EAAiBd,EAAuBY,KAI5CE,EAAiBb,EAErB,IAAIU,EAASG,EAAepG,SAAS,IAIrC,OAHsB,IAAlBiG,EAAO3N,SACP2N,EAAS,IAAIA,KAEVlB,EAAY3E,OAAO2F,EAAeE,EAC7C,8BCxGA7M,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQmN,OAASnN,EAAQgJ,YAAS,EAClC,MAAMiG,EAAW,EAAQ,IACnBrB,EAAU,EAAQ,IAClBsB,EAAQ,EAAQ,KAChB7D,EAAW,6DAUjBrL,EAAQgJ,OATR,SAAgB/F,EAAM4L,EAAS,MAC3B,MAAMM,EAA4B,iBAATlM,GAAoB,EAAI2K,EAAQ/F,YAAY5E,GAAQA,EACvEmM,EAAgC,iBAAXP,GAAsB,EAAIjB,EAAQ/F,YAAYgH,GAAU5L,EACnF,KAAMkM,aAAqBnO,YAAiBoO,aAAuBpO,YAC/D,MAAM,IAAIC,UAAU,iDAExB,MAAMoO,GAAW,EAAIJ,EAASxJ,SAAQ,EAAIwJ,EAASxJ,QAAQ,IAAIzE,WAAW,IAAIoO,KAAgBD,MAC9F,OAAOD,EAAM7D,GAAUrC,OAAO,IAAIoG,KAAgBD,KAAcE,EAAStK,MAAM,EAAG,IACtF,EAeA/E,EAAQmN,OAbR,SAAgBC,GACZ,MAAMtM,EAAQoO,EAAM7D,GAAU8B,OAAOC,GAC/BgC,EAActO,EAAMiE,MAAM,EAAG,GAC7BoK,EAAYrO,EAAMiE,MAAM,GAAI,GAE5BsK,GAAW,EAAIJ,EAASxJ,SAAQ,EAAIwJ,EAASxJ,QAAQ,IAAIzE,WAAW,IAAIoO,KAAgBD,MAM9F,OALArO,EAAMiE,OAAO,GAAGuK,SAAQ,CAACC,EAAOC,KAC5B,GAAID,IAAUF,EAASG,GACnB,MAAM,IAAI7O,MAAM,mBACpB,IAEG,CAAEkO,OAAQO,EAAanM,KAAMkM,EACxC,8BCjCAnN,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQwO,eAAiBxO,EAAQsO,oBAAiB,EAClD,MAAMW,EAAW,EAAQ,IACnBrB,EAAU,EAAQ,IAClB6B,EAAa,EAAQ,KAM3B,SAASC,EAAYC,GACjB,MAAMC,GAAW,EAAIX,EAASxJ,SAAQ,EAAIwJ,EAASxJ,SAAQ,EAAImI,EAAQ/F,YAAY8H,KAEnF,OADiB,EAAI/B,EAAQ9F,YAAY8H,EAAS7K,MAAM,EAAG,GAE/D,CA+BA/E,EAAQsO,eAnBR,SAAwBH,EAASlL,GAC7B,GAAIkL,EAAU,GAAKA,GAAW,GAC1B,MAAM,IAAIxN,MAAM,8CAEpB,IAAKsC,EAAKoL,MAAM,kBACZ,MAAM,IAAI1N,MAAM,oCAEpBsC,EAAOA,EAAK4M,eACH3O,OAAS,GAAM,IACpB+B,EAAO,IAAIA,KAEf,IAAI6M,EAAa3B,EAAQvF,SAAS,IACR,IAAtBkH,EAAW5O,SACX4O,EAAa,IAAIA,KAErB,MAAMC,EAAcL,EAAY,GAAGI,IAAa7M,KAC1C+M,GAAS,EAAIP,EAAWQ,WAAW,GAAGhN,IAAO8M,KACnD,MAAO,GAAGN,EAAWS,IAAI/B,KAAW6B,GACxC,EA6BAhQ,EAAQwO,eAfR,SAAwB2B,GACpBA,GAAU,EAAIV,EAAWW,cAAcD,GACvC,MAAMR,GAAU,EAAIF,EAAWY,WAAWF,EAAQpL,MAAM,IAClDuL,EAAcH,EAAQ,GACtBhC,EAAUsB,EAAWS,IAAIK,QAAQD,GACjCjB,EAAWM,EAAQ5K,OAAO,GAChC,IAAI+K,EAAa3B,EAAQvF,SAAS,IAIlC,GAH0B,IAAtBkH,EAAW5O,SACX4O,EAAa,IAAIA,KAEjBJ,EAAY,GAAGI,IAAaH,EAAQa,UAAU,EAAGb,EAAQzO,OAAS,QAAUmO,EAC5E,MAAM,IAAI1O,MAAM,8CAEpB,MAAO,CAACwN,EAASwB,EAAQa,UAAU,EAAGb,EAAQzO,OAAS,GAC3D,8BCxEAc,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,IACtDlC,EAAQqQ,UAAYrQ,EAAQoQ,aAAepQ,EAAQiQ,UAAYjQ,EAAQkQ,SAAM,EAC7E,MAAMtC,EAAU,EAAQ,IACxB5N,EAAQkQ,IAAM,mCACd,MAAMhH,EAAM,mBAkEZ,SAASkH,EAAaK,GAIlB,OAAOA,EAASC,cAAcC,QAAQ,KAAM,KAAKA,QAAQ,OAAQ,IACrE,CAXA3Q,EAAQiQ,UApDR,SAAmBW,EAAUC,GAEzB,IAAKD,EAASvC,MAAM,kBAChB,MAAM,IAAI1N,MAAM,4BAEhBiQ,EAAS1P,OAAS,GAAM,IACxB0P,EAAW,IAAIA,KAGnB,IAAI9L,EAAM,GACNwH,EAAQ,EACZ,IAAK,IAAIxI,GAHT8M,EAAWA,EAASf,eAGE3O,OAAS,EAAG4C,GAAK,EAAGA,IACtC,GAAIwI,EAAQ,EAAG,CACX,MAAMwE,EAAc5H,EAAIqH,QAAQK,EAAS9M,KAAOwI,EAChD,IAAIyE,EAAW,EACL,IAANjN,IACAiN,EAAW7H,EAAIqH,QAAQK,EAAS9M,EAAI,KAGxC,MAAMkN,EAAW,EAAI1E,EACf2E,EAAcF,GAAY,GAAKC,IAAc,EAAIA,EACjDE,EAAclR,EAAQkQ,IAAIY,EAAcG,GAC9C3E,EAAQ0E,EACRlM,EAAIqM,QAAQD,EAChB,MAEI5E,EAAQ,EAGhB,IAAI8E,EAAkB,EACtB,IAAK,IAAItN,EAAI,EAAGA,EAAIgB,EAAI5D,QACL,MAAX4D,EAAIhB,GADoBA,IAKxBsN,IAGRtM,EAAMA,EAAIC,MAAMqM,GAChB,MAAMC,GAAa,IAAIC,aAAcnE,QAAO,EAAIS,EAAQ/F,YAAY+I,IAAWvC,MAAM,YAC/EkD,EAA2BF,EAAaA,EAAW,GAAGnQ,OAAS,EACrE,IAAK,IAAI4C,EAAI,EAAGA,EAAIyN,EAA0BzN,IAC1CgB,EAAIqM,QAAQnR,EAAQkQ,IAAI,IAE5B,GAAIW,EAAW,CACX,MAAMW,EAAQX,EAAY/L,EAAI5D,OAC9B,IAAK,IAAI4C,EAAI,EAAGA,EAAI0N,EAAO1N,IACvBgB,EAAIqM,QAAQnR,EAAQkQ,IAAI,GAEhC,CACA,OAAOpL,EAAI2M,KAAK,GACpB,EAaAzR,EAAQoQ,aAAeA,EA+DvBpQ,EAAQqQ,UAtDR,SAAmBI,EAAUI,GAGzB,KAFAJ,EAAWL,EAAaK,IAEVpC,MAAM,KAAKrO,EAAQkQ,UAC7B,MAAM,IAAIvP,MAAM,4BAEpB,MAAM0Q,EAAaZ,EAASpC,MAAM,IAAIrO,EAAQkQ,IAAI,OAC5CwB,EAAsBL,EAAaA,EAAW,GAAGnQ,OAAS,EAChE,IAAI4D,EAAM,GACNwH,EAAQ,EACRqF,EAAY,EAChB,IAAK,IAAI7N,EAAI2M,EAASvP,OAAS,EAAG4C,GAAK,EAAGA,IAAK,CACzB,IAAd6N,IACA7M,EAAIqM,QAAQjI,EAAIoD,IAChBqF,EAAY,EACZrF,EAAQ,GAEZ,MACMsF,GADc5R,EAAQkQ,IAAIK,QAAQE,EAAS3M,KAAO6N,GACrBrF,EAC7BuF,EAAkB3I,EAAI0I,EAAe,IAG3C,GAFAD,GAAa,EACbrF,EAAQsF,GAAgB,EACpBtF,EAAQ,GAAKqF,EACb,MAAM,IAAIhR,MAAM,4BAEpBmE,EAAIqM,QAAQU,EAChB,CAEA/M,EAAIqM,QAAQjI,EAAIoD,IACZxH,EAAI5D,OAAS,GAAM,GACnB4D,EAAIqM,QAAQ,KAEhB,IAAIW,EAAkB,EACtB,IAAK,IAAIhO,EAAI,EAAGA,EAAIgB,EAAI5D,QACL,MAAX4D,EAAIhB,GADoBA,IAKxBgO,IAGRhN,EAAMA,EAAIC,MAAM+M,EAAmBA,EAAkB,GACrD,IAAIC,EAASjN,EAAI2M,KAAK,IACtB,IAAK,IAAI3N,EAAI,EAAGA,EAAI4N,EAAqB5N,IACrCiO,EAAS,KAAKA,IAElB,GAAIlB,EAAW,CACX,MAAMW,EAAoB,EAAZX,EAAgBkB,EAAO7Q,OACrC,IAAK,IAAI4C,EAAI,EAAGA,EAAI0N,EAAO1N,GAAK,EAC5BiO,EAAS,KAAKA,GAEtB,CACA,OAAOA,CACX,8BCzIgF/R,EAAQ,GAAmBA,EAAQ,QAAuG,EACvM,EAAQ,KAIR,EAAQ,KAJ3B,MAOMgS,EAAY,EAAQ,IAC1BhQ,OAAOC,eAAejC,EAAS,KAA/B,CAA+CiS,YAAY,EAAMrN,IAAK,WAAc,OAAOoN,EAAUxE,UAAY,IACjHxL,OAAOC,eAAejC,EAAS,KAA/B,CAAqDiS,YAAY,EAAMrN,IAAK,WAAc,OAAOoN,EAAUzE,gBAAkB,8BCF7H,IAGI2E,EAAiB,4BAGjBC,EAAmB,iBAGnBC,EAAU,qBAEVC,EAAU,mBACVC,EAAU,gBAEVC,EAAU,oBACVC,EAAS,6BACTC,EAAS,eACTC,EAAY,kBACZC,EAAY,kBACZC,EAAa,mBACbC,EAAY,kBACZC,EAAS,eACTC,EAAY,kBACZC,EAAY,kBACZC,EAAa,mBAEbC,EAAiB,uBACjBC,EAAc,oBACdC,EAAa,wBACbC,EAAa,wBACbC,EAAU,qBACVC,EAAW,sBACXC,EAAW,sBACXC,EAAW,sBACXC,EAAkB,6BAClBC,EAAY,uBACZC,EAAY,uBASZC,EAAU,OAGVC,EAAe,8BAGfC,EAAW,mBAGXC,EAAgB,CAAC,EACrBA,EAAc5B,GAAW4B,EA7CV,kBA8CfA,EAAcd,GAAkBc,EAAcb,GAC9Ca,EAAc3B,GAAW2B,EAAc1B,GACvC0B,EAAcZ,GAAcY,EAAcX,GAC1CW,EAAcV,GAAWU,EAAcT,GACvCS,EAAcR,GAAYQ,EAAcvB,GACxCuB,EAActB,GAAasB,EAAcrB,GACzCqB,EAAcnB,GAAamB,EAAclB,GACzCkB,EAAcjB,GAAaiB,EAAchB,GACzCgB,EAAcP,GAAYO,EAAcN,GACxCM,EAAcL,GAAaK,EAAcJ,IAAa,EACtDI,EArDe,kBAqDWA,EAAczB,GACxCyB,EAAcf,IAAc,EAG5B,IAAIgB,EAA8B,iBAAV,EAAAC,GAAsB,EAAAA,GAAU,EAAAA,EAAOlS,SAAWA,QAAU,EAAAkS,EAGhFC,EAA0B,iBAAR5O,MAAoBA,MAAQA,KAAKvD,SAAWA,QAAUuD,KAGxEzF,EAAOmU,GAAcE,GAAYC,SAAS,cAATA,GAGjCC,EAA4CrU,IAAYA,EAAQsU,UAAYtU,EAG5EuU,EAAaF,GAA4CpU,IAAWA,EAAOqU,UAAYrU,EAGvFuU,EAAgBD,GAAcA,EAAWvU,UAAYqU,EAUzD,SAASI,EAAYC,EAAKC,GAGxB,OADAD,EAAInR,IAAIoR,EAAK,GAAIA,EAAK,IACfD,CACT,CAUA,SAASE,EAAYrR,EAAKrB,GAGxB,OADAqB,EAAIsR,IAAI3S,GACDqB,CACT,CAsDA,SAASuR,EAAY3L,EAAO4L,EAAUC,EAAaC,GACjD,IAAIzF,GAAS,EACTtO,EAASiI,EAAQA,EAAMjI,OAAS,EAKpC,IAHI+T,GAAa/T,IACf8T,EAAc7L,IAAQqG,MAEfA,EAAQtO,GACf8T,EAAcD,EAASC,EAAa7L,EAAMqG,GAAQA,EAAOrG,GAE3D,OAAO6L,CACT,CAwCA,SAASE,EAAahT,GAGpB,IAAIkI,GAAS,EACb,GAAa,MAATlI,GAA0C,mBAAlBA,EAAM0G,SAChC,IACEwB,KAAYlI,EAAQ,GACtB,CAAE,MAAOiT,GAAI,CAEf,OAAO/K,CACT,CASA,SAASgL,EAAWV,GAClB,IAAIlF,GAAS,EACTpF,EAAS3B,MAAMiM,EAAItI,MAKvB,OAHAsI,EAAIpF,SAAQ,SAASpN,EAAOmT,GAC1BjL,IAASoF,GAAS,CAAC6F,EAAKnT,EAC1B,IACOkI,CACT,CAUA,SAASkL,EAAQC,EAAMC,GACrB,OAAO,SAASC,GACd,OAAOF,EAAKC,EAAUC,GACxB,CACF,CASA,SAASC,EAAWnS,GAClB,IAAIiM,GAAS,EACTpF,EAAS3B,MAAMlF,EAAI6I,MAKvB,OAHA7I,EAAI+L,SAAQ,SAASpN,GACnBkI,IAASoF,GAAStN,CACpB,IACOkI,CACT,CAGA,IASMuL,EATFC,EAAanN,MAAMiC,UACnBmL,EAAYzB,SAAS1J,UACrBoL,EAAc9T,OAAO0I,UAGrBqL,EAAajW,EAAK,sBAGlBkW,GACEL,EAAM,SAASM,KAAKF,GAAcA,EAAWG,MAAQH,EAAWG,KAAKC,UAAY,KACvE,iBAAmBR,EAAO,GAItCS,EAAeP,EAAUjN,SAGzByN,GAAiBP,EAAYO,eAO7BC,GAAiBR,EAAYlN,SAG7B2N,GAAaC,OAAO,IACtBJ,EAAazL,KAAK0L,IAAgB1F,QAzQjB,sBAyQuC,QACvDA,QAAQ,yDAA0D,SAAW,KAI5E8F,GAASjC,EAAgB1U,EAAK2W,YAASpR,EACvCqR,GAAS5W,EAAK4W,OACd1V,GAAalB,EAAKkB,WAClB2V,GAAerB,EAAQtT,OAAO4U,eAAgB5U,QAC9C6U,GAAe7U,OAAOX,OACtByV,GAAuBhB,EAAYgB,qBACnCC,GAASnB,EAAWmB,OAGpBC,GAAmBhV,OAAOiV,sBAC1BC,GAAiBT,GAASA,GAAOU,cAAW9R,EAC5C+R,GAAa9B,EAAQtT,OAAOkU,KAAMlU,QAGlCqG,GAAWgP,GAAUvX,EAAM,YAC3BwX,GAAMD,GAAUvX,EAAM,OACtByX,GAAUF,GAAUvX,EAAM,WAC1B0X,GAAMH,GAAUvX,EAAM,OACtB2X,GAAUJ,GAAUvX,EAAM,WAC1B4X,GAAeL,GAAUrV,OAAQ,UAGjC2V,GAAqBC,GAASvP,IAC9BwP,GAAgBD,GAASN,IACzBQ,GAAoBF,GAASL,IAC7BQ,GAAgBH,GAASJ,IACzBQ,GAAoBJ,GAASH,IAG7BQ,GAAcvB,GAASA,GAAOhM,eAAYrF,EAC1C6S,GAAgBD,GAAcA,GAAYE,aAAU9S,EASxD,SAAS9C,GAAK6V,GACZ,IAAI5I,GAAS,EACTtO,EAASkX,EAAUA,EAAQlX,OAAS,EAGxC,IADAd,KAAKiY,UACI7I,EAAQtO,GAAQ,CACvB,IAAIoX,EAAQF,EAAQ5I,GACpBpP,KAAKmD,IAAI+U,EAAM,GAAIA,EAAM,GAC3B,CACF,CAyFA,SAASC,GAAUH,GACjB,IAAI5I,GAAS,EACTtO,EAASkX,EAAUA,EAAQlX,OAAS,EAGxC,IADAd,KAAKiY,UACI7I,EAAQtO,GAAQ,CACvB,IAAIoX,EAAQF,EAAQ5I,GACpBpP,KAAKmD,IAAI+U,EAAM,GAAIA,EAAM,GAC3B,CACF,CAuGA,SAASE,GAASJ,GAChB,IAAI5I,GAAS,EACTtO,EAASkX,EAAUA,EAAQlX,OAAS,EAGxC,IADAd,KAAKiY,UACI7I,EAAQtO,GAAQ,CACvB,IAAIoX,EAAQF,EAAQ5I,GACpBpP,KAAKmD,IAAI+U,EAAM,GAAIA,EAAM,GAC3B,CACF,CAqFA,SAASG,GAAML,GACbhY,KAAKsY,SAAW,IAAIH,GAAUH,EAChC,CAwHA,SAASO,GAAYC,EAAQvD,EAAKnT,GAChC,IAAI2W,EAAWD,EAAOvD,GAChBgB,GAAe1L,KAAKiO,EAAQvD,IAAQyD,GAAGD,EAAU3W,UACxCmD,IAAVnD,GAAyBmT,KAAOuD,KACnCA,EAAOvD,GAAOnT,EAElB,CAUA,SAAS6W,GAAa5P,EAAOkM,GAE3B,IADA,IAAInU,EAASiI,EAAMjI,OACZA,KACL,GAAI4X,GAAG3P,EAAMjI,GAAQ,GAAImU,GACvB,OAAOnU,EAGX,OAAQ,CACV,CA6BA,SAAS8X,GAAU9W,EAAO+W,EAAQC,EAAQC,EAAY9D,EAAKuD,EAAQQ,GACjE,IAAIhP,EAIJ,GAHI+O,IACF/O,EAASwO,EAASO,EAAWjX,EAAOmT,EAAKuD,EAAQQ,GAASD,EAAWjX,SAExDmD,IAAX+E,EACF,OAAOA,EAET,IAAKiP,GAASnX,GACZ,OAAOA,EAET,IAAIoX,EAAQ1M,GAAQ1K,GACpB,GAAIoX,GAEF,GADAlP,EA2XJ,SAAwBjB,GACtB,IAAIjI,EAASiI,EAAMjI,OACfkJ,EAASjB,EAAM3G,YAAYtB,GAO/B,OAJIA,GAA6B,iBAAZiI,EAAM,IAAkBkN,GAAe1L,KAAKxB,EAAO,WACtEiB,EAAOoF,MAAQrG,EAAMqG,MACrBpF,EAAOmP,MAAQpQ,EAAMoQ,OAEhBnP,CACT,CArYaoP,CAAetX,IACnB+W,EACH,OA6ON,SAAmBhN,EAAQ9C,GACzB,IAAIqG,GAAS,EACTtO,EAAS+K,EAAO/K,OAGpB,IADAiI,IAAUA,EAAQV,MAAMvH,MACfsO,EAAQtO,GACfiI,EAAMqG,GAASvD,EAAOuD,GAExB,OAAOrG,CACT,CAtPasQ,CAAUvX,EAAOkI,OAErB,CACL,IAAIsP,EAAMC,GAAOzX,GACb0X,EAASF,GAAOnH,GAAWmH,GAAOlH,EAEtC,GAAI2E,GAASjV,GACX,OA0HN,SAAqBW,EAAQoW,GAC3B,GAAIA,EACF,OAAOpW,EAAOkC,QAEhB,IAAIqF,EAAS,IAAIvH,EAAOL,YAAYK,EAAO3B,QAE3C,OADA2B,EAAOgX,KAAKzP,GACLA,CACT,CAjIa0P,CAAY5X,EAAO+W,GAE5B,GAAIS,GAAO/G,GAAa+G,GAAOtH,GAAYwH,IAAWhB,EAAS,CAC7D,GAAI1D,EAAahT,GACf,OAAO0W,EAAS1W,EAAQ,CAAC,EAG3B,GADAkI,EA+XN,SAAyBwO,GACvB,MAAqC,mBAAtBA,EAAOpW,aAA8BuX,GAAYnB,GAE5D,CAAC,EAxVES,GADWW,EAwVHrD,GAAaiC,IAvVH/B,GAAamD,GAAS,CAAC,EADlD,IAAoBA,CA0VpB,CAnYeC,CAAgBL,EAAS,CAAC,EAAI1X,IAClC+W,EACH,OA6QR,SAAqBhN,EAAQ2M,GAC3B,OAAOsB,GAAWjO,EAAQkO,GAAWlO,GAAS2M,EAChD,CA/QewB,CAAYlY,EAhD3B,SAAoB0W,EAAQ3M,GAC1B,OAAO2M,GAAUsB,GAAWjO,EAAQiK,GAAKjK,GAAS2M,EACpD,CA8CkCyB,CAAWjQ,EAAQlI,GAEjD,KAAO,CACL,IAAK8R,EAAc0F,GACjB,OAAOd,EAAS1W,EAAQ,CAAC,EAE3BkI,EA0YN,SAAwBwO,EAAQc,EAAKY,EAAWrB,GAC9C,IA5MmBsB,EA4MfC,EAAO5B,EAAOpW,YAClB,OAAQkX,GACN,KAAKxG,EACH,OAAOuH,GAAiB7B,GAE1B,KAAKvG,EACL,KAAKC,EACH,OAAO,IAAIkI,GAAM5B,GAEnB,KAAKzF,EACH,OA3QN,SAAuBzP,EAAUuV,GAC/B,IAAIpW,EAASoW,EAASwB,GAAiB/W,EAASb,QAAUa,EAASb,OACnE,OAAO,IAAIa,EAASlB,YAAYK,EAAQa,EAASK,WAAYL,EAASyE,WACxE,CAwQauS,CAAc9B,EAAQK,GAE/B,KAAK7F,EAAY,KAAKC,EACtB,KAAKC,EAAS,KAAKC,EAAU,KAAKC,EAClC,KAAKC,EAAU,KAAKC,EAAiB,KAAKC,EAAW,KAAKC,EACxD,OA/MN,SAAyB+G,EAAY1B,GACnC,IAAIpW,EAASoW,EAASwB,GAAiBE,EAAW9X,QAAU8X,EAAW9X,OACvE,OAAO,IAAI8X,EAAWnY,YAAYK,EAAQ8X,EAAW5W,WAAY4W,EAAWzZ,OAC9E,CA4Ma0Z,CAAgBhC,EAAQK,GAEjC,KAAKxG,EACH,OArQN,SAAkBiC,EAAKuE,EAAQqB,GAE7B,OAAOxF,EADKmE,EAASqB,EAAUlF,EAAWV,IAAM,GAAQU,EAAWV,GACzCD,EAAa,IAAIC,EAAIlS,YACjD,CAkQaqY,CAASjC,EAAQK,EAAQqB,GAElC,KAAK5H,EACL,KAAKK,EACH,OAAO,IAAIyH,EAAK5B,GAElB,KAAK/F,EACH,OAhQN,SAAqBiI,GACnB,IAAI1Q,EAAS,IAAI0Q,EAAOtY,YAAYsY,EAAO7O,OAAQ4H,EAAQoC,KAAK6E,IAEhE,OADA1Q,EAAO2Q,UAAYD,EAAOC,UACnB3Q,CACT,CA4Pa4Q,CAAYpC,GAErB,KAAK9F,EACH,OApPN,SAAkBvP,EAAK0V,EAAQqB,GAE7B,OAAOxF,EADKmE,EAASqB,EAAU5E,EAAWnS,IAAM,GAAQmS,EAAWnS,GACzCqR,EAAa,IAAIrR,EAAIf,YACjD,CAiPayY,CAASrC,EAAQK,EAAQqB,GAElC,KAAKtH,EACH,OA3OeuH,EA2OI3B,EA1OhBV,GAAgBlW,OAAOkW,GAAcvN,KAAK4P,IAAW,CAAC,EA4O/D,CA5aeW,CAAehZ,EAAOwX,EAAKV,GAAWC,EACjD,CACF,CAEAG,IAAUA,EAAQ,IAAIX,IACtB,IAAI0C,EAAU/B,EAAMxU,IAAI1C,GACxB,GAAIiZ,EACF,OAAOA,EAIT,GAFA/B,EAAM7V,IAAIrB,EAAOkI,IAEZkP,EACH,IAAI8B,EAAQlC,EAsQhB,SAAoBN,GAClB,OAnOF,SAAwBA,EAAQyC,EAAUC,GACxC,IAAIlR,EAASiR,EAASzC,GACtB,OAAOhM,GAAQgM,GAAUxO,EApwB3B,SAAmBjB,EAAOoS,GAKxB,IAJA,IAAI/L,GAAS,EACTtO,EAASqa,EAAOra,OAChByF,EAASwC,EAAMjI,SAEVsO,EAAQtO,GACfiI,EAAMxC,EAAS6I,GAAS+L,EAAO/L,GAEjC,OAAOrG,CACT,CA2vBoCqS,CAAUpR,EAAQkR,EAAY1C,GAClE,CAgOS6C,CAAe7C,EAAQ1C,GAAMiE,GACtC,CAxQyBuB,CAAWxZ,GAASgU,GAAKhU,GAUhD,OA5vBF,SAAmBiH,EAAO4L,GAIxB,IAHA,IAAIvF,GAAS,EACTtO,EAASiI,EAAQA,EAAMjI,OAAS,IAE3BsO,EAAQtO,IAC8B,IAAzC6T,EAAS5L,EAAMqG,GAAQA,KAK/B,CA0uBEmM,CAAUP,GAASlZ,GAAO,SAAS0Z,EAAUvG,GACvC+F,IAEFQ,EAAW1Z,EADXmT,EAAMuG,IAIRjD,GAAYvO,EAAQiL,EAAK2D,GAAU4C,EAAU3C,EAAQC,EAAQC,EAAY9D,EAAKnT,EAAOkX,GACvF,IACOhP,CACT,CAqGA,SAASqQ,GAAiBoB,GACxB,IAAIzR,EAAS,IAAIyR,EAAYrZ,YAAYqZ,EAAY1T,YAErD,OADA,IAAInH,GAAWoJ,GAAQ7G,IAAI,IAAIvC,GAAW6a,IACnCzR,CACT,CA6GA,SAAS8P,GAAWjO,EAAQmP,EAAOxC,EAAQO,GACzCP,IAAWA,EAAS,CAAC,GAKrB,IAHA,IAAIpJ,GAAS,EACTtO,EAASka,EAAMla,SAEVsO,EAAQtO,GAAQ,CACvB,IAAImU,EAAM+F,EAAM5L,GAEZsM,EAAW3C,EACXA,EAAWP,EAAOvD,GAAMpJ,EAAOoJ,GAAMA,EAAKuD,EAAQ3M,QAClD5G,EAEJsT,GAAYC,EAAQvD,OAAkBhQ,IAAbyW,EAAyB7P,EAAOoJ,GAAOyG,EAClE,CACA,OAAOlD,CACT,CAiCA,SAASmD,GAAWrH,EAAKW,GACvB,IAqKiBnT,EACb8Z,EAtKA/Y,EAAOyR,EAAIgE,SACf,OAsKgB,WADZsD,SADa9Z,EApKAmT,KAsKmB,UAAR2G,GAA4B,UAARA,GAA4B,WAARA,EACrD,cAAV9Z,EACU,OAAVA,GAvKDe,EAAmB,iBAAPoS,EAAkB,SAAW,QACzCpS,EAAKyR,GACX,CAUA,SAAS2C,GAAUuB,EAAQvD,GACzB,IAAInT,EAj8BN,SAAkB0W,EAAQvD,GACxB,OAAiB,MAAVuD,OAAiBvT,EAAYuT,EAAOvD,EAC7C,CA+7Bc4G,CAASrD,EAAQvD,GAC7B,OAvOF,SAAsBnT,GACpB,SAAKmX,GAASnX,KAyYEqT,EAzYiBrT,EA0YxB8T,GAAeA,KAAcT,MAvYvB2G,GAAWha,IAAUgT,EAAahT,GAAUqU,GAAazC,GACzDqI,KAAKvE,GAAS1V,IAqY/B,IAAkBqT,CApYlB,CAiOS6G,CAAala,GAASA,OAAQmD,CACvC,CA9tBA9C,GAAKmI,UAAU2N,MAnEf,WACEjY,KAAKsY,SAAWhB,GAAeA,GAAa,MAAQ,CAAC,CACvD,EAkEAnV,GAAKmI,UAAkB,OAtDvB,SAAoB2K,GAClB,OAAOjV,KAAKic,IAAIhH,WAAejV,KAAKsY,SAASrD,EAC/C,EAqDA9S,GAAKmI,UAAU9F,IA1Cf,SAAiByQ,GACf,IAAIpS,EAAO7C,KAAKsY,SAChB,GAAIhB,GAAc,CAChB,IAAItN,EAASnH,EAAKoS,GAClB,OAAOjL,IAAW8H,OAAiB7M,EAAY+E,CACjD,CACA,OAAOiM,GAAe1L,KAAK1H,EAAMoS,GAAOpS,EAAKoS,QAAOhQ,CACtD,EAoCA9C,GAAKmI,UAAU2R,IAzBf,SAAiBhH,GACf,IAAIpS,EAAO7C,KAAKsY,SAChB,OAAOhB,QAA6BrS,IAAdpC,EAAKoS,GAAqBgB,GAAe1L,KAAK1H,EAAMoS,EAC5E,EAuBA9S,GAAKmI,UAAUnH,IAXf,SAAiB8R,EAAKnT,GAGpB,OAFW9B,KAAKsY,SACXrD,GAAQqC,SAA0BrS,IAAVnD,EAAuBgQ,EAAiBhQ,EAC9D9B,IACT,EAmHAmY,GAAU7N,UAAU2N,MAjFpB,WACEjY,KAAKsY,SAAW,EAClB,EAgFAH,GAAU7N,UAAkB,OArE5B,SAAyB2K,GACvB,IAAIpS,EAAO7C,KAAKsY,SACZlJ,EAAQuJ,GAAa9V,EAAMoS,GAE/B,QAAI7F,EAAQ,IAIRA,GADYvM,EAAK/B,OAAS,EAE5B+B,EAAKqZ,MAELvF,GAAOpM,KAAK1H,EAAMuM,EAAO,GAEpB,GACT,EAwDA+I,GAAU7N,UAAU9F,IA7CpB,SAAsByQ,GACpB,IAAIpS,EAAO7C,KAAKsY,SACZlJ,EAAQuJ,GAAa9V,EAAMoS,GAE/B,OAAO7F,EAAQ,OAAInK,EAAYpC,EAAKuM,GAAO,EAC7C,EAyCA+I,GAAU7N,UAAU2R,IA9BpB,SAAsBhH,GACpB,OAAO0D,GAAa3Y,KAAKsY,SAAUrD,IAAQ,CAC7C,EA6BAkD,GAAU7N,UAAUnH,IAjBpB,SAAsB8R,EAAKnT,GACzB,IAAIe,EAAO7C,KAAKsY,SACZlJ,EAAQuJ,GAAa9V,EAAMoS,GAO/B,OALI7F,EAAQ,EACVvM,EAAKsZ,KAAK,CAAClH,EAAKnT,IAEhBe,EAAKuM,GAAO,GAAKtN,EAEZ9B,IACT,EAiGAoY,GAAS9N,UAAU2N,MA/DnB,WACEjY,KAAKsY,SAAW,CACd,KAAQ,IAAInW,GACZ,IAAO,IAAK+U,IAAOiB,IACnB,OAAU,IAAIhW,GAElB,EA0DAiW,GAAS9N,UAAkB,OA/C3B,SAAwB2K,GACtB,OAAO0G,GAAW3b,KAAMiV,GAAa,OAAEA,EACzC,EA8CAmD,GAAS9N,UAAU9F,IAnCnB,SAAqByQ,GACnB,OAAO0G,GAAW3b,KAAMiV,GAAKzQ,IAAIyQ,EACnC,EAkCAmD,GAAS9N,UAAU2R,IAvBnB,SAAqBhH,GACnB,OAAO0G,GAAW3b,KAAMiV,GAAKgH,IAAIhH,EACnC,EAsBAmD,GAAS9N,UAAUnH,IAVnB,SAAqB8R,EAAKnT,GAExB,OADA6Z,GAAW3b,KAAMiV,GAAK9R,IAAI8R,EAAKnT,GACxB9B,IACT,EA+FAqY,GAAM/N,UAAU2N,MApEhB,WACEjY,KAAKsY,SAAW,IAAIH,EACtB,EAmEAE,GAAM/N,UAAkB,OAxDxB,SAAqB2K,GACnB,OAAOjV,KAAKsY,SAAiB,OAAErD,EACjC,EAuDAoD,GAAM/N,UAAU9F,IA5ChB,SAAkByQ,GAChB,OAAOjV,KAAKsY,SAAS9T,IAAIyQ,EAC3B,EA2CAoD,GAAM/N,UAAU2R,IAhChB,SAAkBhH,GAChB,OAAOjV,KAAKsY,SAAS2D,IAAIhH,EAC3B,EA+BAoD,GAAM/N,UAAUnH,IAnBhB,SAAkB8R,EAAKnT,GACrB,IAAIsa,EAAQpc,KAAKsY,SACjB,GAAI8D,aAAiBjE,GAAW,CAC9B,IAAIkE,EAAQD,EAAM9D,SAClB,IAAKpB,IAAQmF,EAAMvb,OAASwb,IAE1B,OADAD,EAAMF,KAAK,CAAClH,EAAKnT,IACV9B,KAEToc,EAAQpc,KAAKsY,SAAW,IAAIF,GAASiE,EACvC,CAEA,OADAD,EAAMjZ,IAAI8R,EAAKnT,GACR9B,IACT,EAgcA,IAAI+Z,GAAanD,GAAmB1B,EAAQ0B,GAAkBhV,QAyhB9D,WACE,MAAO,EACT,EAlhBI2X,GAtQJ,SAAoBzX,GAClB,OAAOoU,GAAe3L,KAAKzI,EAC7B,EAwXA,SAASya,GAAQza,EAAOhB,GAEtB,SADAA,EAAmB,MAAVA,EAAiBiR,EAAmBjR,KAE1B,iBAATgB,GAAqB6R,EAASoI,KAAKja,KAC1CA,GAAS,GAAKA,EAAQ,GAAK,GAAKA,EAAQhB,CAC7C,CAkCA,SAAS6Y,GAAY7X,GACnB,IAAIsY,EAAOtY,GAASA,EAAMM,YAG1B,OAAON,KAFqB,mBAARsY,GAAsBA,EAAK9P,WAAcoL,EAG/D,CASA,SAAS8B,GAASrC,GAChB,GAAY,MAARA,EAAc,CAChB,IACE,OAAOa,EAAazL,KAAK4K,EAC3B,CAAE,MAAOJ,GAAI,CACb,IACE,OAAQI,EAAO,EACjB,CAAE,MAAOJ,GAAI,CACf,CACA,MAAO,EACT,CAwDA,SAAS2D,GAAG5W,EAAO0a,GACjB,OAAO1a,IAAU0a,GAAU1a,GAAUA,GAAS0a,GAAUA,CAC1D,EAzOKvU,IAAYsR,GAAO,IAAItR,GAAS,IAAIqE,YAAY,MAAQyG,GACxDmE,IAAOqC,GAAO,IAAIrC,KAAQ7E,GAC1B8E,IAAWoC,GAAOpC,GAAQsF,YAAcjK,GACxC4E,IAAOmC,GAAO,IAAInC,KAAQ1E,GAC1B2E,IAAWkC,GAAO,IAAIlC,KAAYxE,KACrC0G,GAAS,SAASzX,GAChB,IAAIkI,EAASkM,GAAe3L,KAAKzI,GAC7BsY,EAAOpQ,GAAUuI,EAAYzQ,EAAMM,iBAAc6C,EACjDyX,EAAatC,EAAO5C,GAAS4C,QAAQnV,EAEzC,GAAIyX,EACF,OAAQA,GACN,KAAKnF,GAAoB,OAAOxE,EAChC,KAAK0E,GAAe,OAAOpF,EAC3B,KAAKqF,GAAmB,OAAOlF,EAC/B,KAAKmF,GAAe,OAAOjF,EAC3B,KAAKkF,GAAmB,OAAO/E,EAGnC,OAAO7I,CACT,GAsQF,IAAIwC,GAAUnE,MAAMmE,QA2BpB,SAASmQ,GAAY7a,GACnB,OAAgB,MAATA,GAqGT,SAAkBA,GAChB,MAAuB,iBAATA,GACZA,GAAS,GAAKA,EAAQ,GAAK,GAAKA,GAASiQ,CAC7C,CAxG0B6K,CAAS9a,EAAMhB,UAAYgb,GAAWha,EAChE,CAgDA,IAAIiV,GAAWD,IAsLf,WACE,OAAO,CACT,EArKA,SAASgF,GAAWha,GAGlB,IAAIwX,EAAML,GAASnX,GAASoU,GAAe3L,KAAKzI,GAAS,GACzD,OAAOwX,GAAOnH,GAAWmH,GAAOlH,CAClC,CA0DA,SAAS6G,GAASnX,GAChB,IAAI8Z,SAAc9Z,EAClB,QAASA,IAAkB,UAAR8Z,GAA4B,YAARA,EACzC,CA0DA,SAAS9F,GAAK0C,GACZ,OAAOmE,GAAYnE,GAn7BrB,SAAuB1W,EAAO+a,GAG5B,IAAI7S,EAAUwC,GAAQ1K,IAsrBxB,SAAqBA,GAEnB,OAmFF,SAA2BA,GACzB,OAmIF,SAAsBA,GACpB,QAASA,GAAyB,iBAATA,CAC3B,CArISgb,CAAahb,IAAU6a,GAAY7a,EAC5C,CArFSib,CAAkBjb,IAAUmU,GAAe1L,KAAKzI,EAAO,aAC1D4U,GAAqBnM,KAAKzI,EAAO,WAAaoU,GAAe3L,KAAKzI,IAAUkQ,EAClF,CA1rBkCgL,CAAYlb,GAljB9C,SAAmB1B,EAAGuU,GAIpB,IAHA,IAAIvF,GAAS,EACTpF,EAAS3B,MAAMjI,KAEVgP,EAAQhP,GACf4J,EAAOoF,GAASuF,EAASvF,GAE3B,OAAOpF,CACT,CA2iBMiT,CAAUnb,EAAMhB,OAAQoc,QACxB,GAEApc,EAASkJ,EAAOlJ,OAChBqc,IAAgBrc,EAEpB,IAAK,IAAImU,KAAOnT,GACT+a,IAAa5G,GAAe1L,KAAKzI,EAAOmT,IACvCkI,IAAuB,UAAPlI,GAAmBsH,GAAQtH,EAAKnU,KACpDkJ,EAAOmS,KAAKlH,GAGhB,OAAOjL,CACT,CAk6B+BoT,CAAc5E,GAtuB7C,SAAkBA,GAChB,IAAKmB,GAAYnB,GACf,OAAOxB,GAAWwB,GAEpB,IAAIxO,EAAS,GACb,IAAK,IAAIiL,KAAOrT,OAAO4W,GACjBvC,GAAe1L,KAAKiO,EAAQvD,IAAe,eAAPA,GACtCjL,EAAOmS,KAAKlH,GAGhB,OAAOjL,CACT,CA2tBuDqT,CAAS7E,EAChE,CAyCA3Y,EAAOD,QA9VP,SAAmBkC,GACjB,OAAO8W,GAAU9W,GAAO,GAAM,EAChC,eCt3CIwb,EAA2B,CAAC,EAGhC,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqBvY,IAAjBwY,EACH,OAAOA,EAAa7d,QAGrB,IAAIC,EAASyd,EAAyBE,GAAY,CACjDE,GAAIF,EACJG,QAAQ,EACR/d,QAAS,CAAC,GAUX,OANAge,EAAoBJ,GAAU3d,EAAQA,EAAOD,QAAS2d,GAGtD1d,EAAO8d,QAAS,EAGT9d,EAAOD,OACf,CCxBA2d,EAAoBnd,EAAKP,IACxB,IAAIge,EAAShe,GAAUA,EAAOie,WAC7B,IAAOje,EAAiB,QACxB,IAAM,EAEP,OADA0d,EAAoBQ,EAAEF,EAAQ,CAAErY,EAAGqY,IAC5BA,CAAM,EdNV3d,EAAW0B,OAAO4U,eAAkBnM,GAASzI,OAAO4U,eAAenM,GAASA,GAASA,EAAa,UAQtGkT,EAAoBS,EAAI,SAASlc,EAAOmc,GAEvC,GADU,EAAPA,IAAUnc,EAAQ9B,KAAK8B,IAChB,EAAPmc,EAAU,OAAOnc,EACpB,GAAoB,iBAAVA,GAAsBA,EAAO,CACtC,GAAW,EAAPmc,GAAanc,EAAMgc,WAAY,OAAOhc,EAC1C,GAAW,GAAPmc,GAAoC,mBAAfnc,EAAMoc,KAAqB,OAAOpc,CAC5D,CACA,IAAIqc,EAAKvc,OAAOX,OAAO,MACvBsc,EAAoBa,EAAED,GACtB,IAAIE,EAAM,CAAC,EACXpe,EAAiBA,GAAkB,CAAC,KAAMC,EAAS,CAAC,GAAIA,EAAS,IAAKA,EAASA,IAC/E,IAAI,IAAIoe,EAAiB,EAAPL,GAAYnc,EAAyB,iBAAXwc,KAAyBre,EAAekQ,QAAQmO,GAAUA,EAAUpe,EAASoe,GACxH1c,OAAO2c,oBAAoBD,GAASpP,SAAS+F,GAASoJ,EAAIpJ,GAAO,IAAOnT,EAAMmT,KAI/E,OAFAoJ,EAAa,QAAI,IAAM,EACvBd,EAAoBQ,EAAEI,EAAIE,GACnBF,CACR,EexBAZ,EAAoBQ,EAAI,CAACne,EAAS4e,KACjC,IAAI,IAAIvJ,KAAOuJ,EACXjB,EAAoBkB,EAAED,EAAYvJ,KAASsI,EAAoBkB,EAAE7e,EAASqV,IAC5ErT,OAAOC,eAAejC,EAASqV,EAAK,CAAEpD,YAAY,EAAMrN,IAAKga,EAAWvJ,IAE1E,ECNDsI,EAAoBzJ,EAAI,WACvB,GAA0B,iBAAf4K,WAAyB,OAAOA,WAC3C,IACC,OAAO1e,MAAQ,IAAIgU,SAAS,cAAb,EAChB,CAAE,MAAOe,GACR,GAAsB,iBAAX4J,OAAqB,OAAOA,MACxC,CACA,CAPuB,GCAxBpB,EAAoBkB,EAAI,CAACpU,EAAKuU,IAAUhd,OAAO0I,UAAU2L,eAAe1L,KAAKF,EAAKuU,GCClFrB,EAAoBa,EAAKxe,IACH,oBAAX0W,QAA0BA,OAAOuI,aAC1Cjd,OAAOC,eAAejC,EAAS0W,OAAOuI,YAAa,CAAE/c,MAAO,WAE7DF,OAAOC,eAAejC,EAAS,aAAc,CAAEkC,OAAO,GAAO,ECL9Dyb,EAAoBuB,IAAOjf,IAC1BA,EAAOkf,MAAQ,GACVlf,EAAOmf,WAAUnf,EAAOmf,SAAW,IACjCnf,qCC4KD,SAASof,EAAWnd,EAAOiG,GAC9B,OAAOmX,EAAc,EAAYpd,GAAQiG,EAC7C,CACO,SAAS,EAAYjG,GACxB,GAAqB,iBAAVA,EACP,OAAOA,EACX,GAAqB,iBAAVA,EACP,OAAOgC,OAAOhC,GAClB,GAAqB,iBAAVA,EAAoB,CAC3B,IAAKzB,OAAO8e,UAAUrd,GAClB,MAAM,IAAIsd,WAAW,8DAEzB,GAAItd,EAAQzB,OAAO0R,iBACf,MAAM,IAAIqN,WAAW,wEAAwE/e,OAAO0R,oEAExG,OAAOjO,OAAOhC,EAClB,CACA,GAAI,EAAWA,EAAOlB,YAClB,OAAOkD,OAAO,KAAK,EAAWhC,MAClC,MAAM,IAAIjB,UAAU,sGACxB,CAWO,SAASwe,EAAYvW,GACxB,GAAmB,iBAARA,EACP,MAAM,IAAIjI,UAAU,4CAA4CiI,GACpE,OAAOhF,OAAO,KAAKgF,IACvB,CACO,SAASwW,EAASC,EAASxX,EAAa,GAE3C,OADiC,iBAAZwX,EAAuBA,EAAU,EAAYA,IACrD/W,SAAS,IAAIC,SAAsB,EAAbV,EAAgB,IACvD,CACO,SAAS,EAASe,GACrB,OAAOK,SAASL,EAAK,GACzB,CACO,SAASoW,EAAcpd,EAAOhB,EAAS,IAE1C,OAAO,EADKwe,EAASxd,EAAOhB,GAEhC,CAcO,SAAS0e,EAAkB9e,GAC9B,OAEqBoB,EAFLgC,OAAO,KAAK,EAAWpD,MAEX+e,EAFsB3b,OAA0B,EAAnBpD,EAAMqH,YAJnE,SAAgBjG,EAAO1B,GACnB,OAAO0B,EAASgC,OAAO,IAAM1D,CACjC,CAKQsf,CAAO5d,EAAO2d,EAAQ3b,OAAO,IACtBhC,GAASgC,OAAO,IAAM2b,GAE1B3d,EAJJ,IAAkBA,EAAO2d,CADhC,6XAOA,MAAMrX,EAAQC,MAAMC,KAAK,CAAExH,OAAQ,MAAO,CAAC6e,EAAGjc,IAAMA,EAAE8E,SAAS,IAAIC,SAAS,EAAG,OACxE,SAAS,EAAWI,GACvB,KAAMA,aAAkBjI,YACpB,MAAM,IAAIL,MAAM,uBACpB,IAAIuI,EAAM,GACV,IAAK,MAAM8W,KAAK/W,EACZC,GAAOV,EAAMwX,GAEjB,OAAO9W,CACX,CACO,SAAS,EAAWA,GACvB,GAAmB,iBAARA,EACP,MAAM,IAAIjI,UAAU,2CAA2CiI,GAvDhE,IAAmBhH,EA0DtBgH,GA1DsBhH,EAyDNgH,EAAhBA,EAxDO,OAAOiT,KAAKja,GACbA,EAAM6C,MAAM,GACZ7C,GAuDIhB,OAAS,EAAI,IAAIgI,IAAQA,EACnC,MAAMC,EAAQ,IAAInI,WAAWkI,EAAIhI,OAAS,GAC1C,IAAK,IAAI4C,EAAI,EAAGA,EAAIqF,EAAMjI,OAAQ4C,IAAK,CACnC,MAAMsF,EAAQ,EAAJtF,EACJuF,EAAUH,EAAInE,MAAMqE,EAAGA,EAAI,GAC3BE,EAAO7I,OAAO8I,SAASF,EAAS,IACtC,GAAI5I,OAAO+I,MAAMF,IAASA,EAAO,EAC7B,MAAM,IAAI3I,MAAM,yBACpBwI,EAAMrF,GAAKwF,CACf,CACA,OAAOH,CACX,CACO,SAAS,EAAYL,GACxB,OAAO,IAAIC,aAAcC,OAAOF,EACpC,CACO,SAAS,EAAYZ,GACxB,OAAO,IAAIoJ,aAAcnE,OAAOjF,EACpC,CACO,SAAS+X,EAAanX,GACzB,MAAMoX,EAAY,GAClB,IAAK,IAAIpc,EAAI,EAAGA,EAAIgF,EAAI5H,OAAQ4C,IAC5Boc,EAAU3D,KAAyB,IAApBzT,EAAI4C,WAAW5H,IAElC,OAAO,IAAI9C,WAAWkf,EAC1B,CACO,SAASC,EAAajY,GACzB,OAAOoV,OAAO8C,aAAaC,MAAM,KAAMnY,EAC3C,CACA,SAASoY,EAAWC,GAChB,OAAQ9f,OAAO8e,UAAUgB,IAAUA,EAAQ,GAAKA,EAAQ,GAC5D,CACO,SAASC,EAAcC,GAC1B,GAAIA,EAAQC,KAAKJ,GACb,MAAM,IAAI3f,MAAM,kCACpB,OAAO,IAAIK,WAAWyf,EAC1B,CACO,SAAShZ,KAAewC,GAC3B,IAAKA,EAAOC,OAAMtE,GAAKA,aAAa5E,aAChC,MAAM,IAAIL,MAAM,4BACpB,GAAsB,IAAlBsJ,EAAO/I,OACP,OAAO+I,EAAO,GAClB,MAAM/I,EAAS+I,EAAOE,QAAO,CAACvE,EAAGsC,IAAQtC,EAAIsC,EAAIhH,QAAQ,GACnDkJ,EAAS,IAAIpJ,WAAWE,GAC9B,IAAK,IAAI4C,EAAI,EAAGuG,EAAM,EAAGvG,EAAImG,EAAO/I,OAAQ4C,IAAK,CAC7C,MAAMoE,EAAM+B,EAAOnG,GACnBsG,EAAO7G,IAAI2E,EAAKmC,GAChBA,GAAOnC,EAAIhH,MACf,CACA,OAAOkJ,CACX,CACO,SAAS,EAAYuW,GACxB,OAAOlZ,KAAekZ,EAASjM,KAAIS,GACd,iBAANA,EACAqL,EAAc,CAACrL,IACtBA,aAAa1M,MACN+X,EAAcrL,GAClBA,IAEf,CACO,SAAS,EAAWyD,EAAQgI,GAC/B,OAAOhI,aAAkBgI,GAAShI,GAAQpW,aAAaqe,MAAMhR,gBAAkB+Q,EAAMC,IACzF,CChUO,MAIMC,EAA+B,GCJtCC,EAAmB,CACrBC,eAAgB,SAChBC,QAAS,CACL,iBAAkB,aASnBxX,eAAeyX,EAAa3H,EAAO4H,GACtC,MAAMC,EAAY,CAAC,EAGnB,OAFApf,OAAO4I,OAAOwW,EAAWL,EAAkBI,SACjBE,MAAM9H,EAAO6H,EAE3C,CA8BO,SAAS,KAAiBE,GAC7B,MAAM,SAAEC,EAAQ,YAAEC,GAZtB,SAA8BF,GAC1B,IAAIC,EAAWL,EACXM,EAAc,GAOlB,OANIF,EAAKpgB,OAAS,GAAwB,mBAAZogB,EAAK,KAC/BC,EAAWD,EAAK/Y,SAEhB+Y,EAAKpgB,OAAS,IACdsgB,EAAcF,GAEX,CAAEC,WAAUC,cACvB,CAEsCC,CAAqBH,GA0BvD,OAzBgB7X,MAAOiY,EAAKP,KACxB,IAAIQ,EAAc,CAAED,MAAKP,KAAMA,GAAQ,CAAC,GACxC,IAAK,MAAMS,KAAcJ,EACS,mBAAnBI,EAAWC,MAKlBF,QAJqBpK,QAAQsF,QAAQ+E,EAAWC,IAAI,CAChDR,MAAOE,KACJI,MAEiBA,GAGhC,IAAIG,QAAiBP,EAASI,EAAYD,IAAKC,EAAYR,MAC3D,IAAK,MAAMS,KAAcJ,EACrB,GAA+B,mBAApBI,EAAWG,KAAqB,CACvC,MAAM3X,QAAemN,QAAQsF,QAAQ+E,EAAWG,KAAK,CACjDV,MAAOE,EACPG,IAAKC,EAAYD,IACjBP,KAAMQ,EAAYR,KAClBW,SAAUA,GAAUxX,SAAWwX,KAEnCA,EAAW1X,GAAU0X,CACzB,CAEJ,OAAOA,CAAQ,CAGvB,CC3EO,IAAIE,EAKAC,EAMA,EAKAC,EAJAC,GAXX,SAAWH,GACPA,EAAQA,EAAiB,QAAI,GAAK,UAClCA,EAAQA,EAAiB,QAAI,YAAc,SAC9C,CAHD,CAGGA,IAAYA,EAAU,CAAC,IAE1B,SAAWC,GACPA,EAAcA,EAAuB,QAAI,WAAa,UACtDA,EAAcA,EAAuB,QAAI,YAAc,SAC1D,CAHD,CAGGA,IAAkBA,EAAgB,CAAC,IACND,EAAQI,SAE7BD,EAGR,IAAuB,EAAqB,CAAC,IAFzBA,EAA4B,QAAI,GAAK,UACxDA,EAAmBA,EAA4B,QAAI,KAAO,UAG9D,SAAWD,GACPA,EAAeA,EAAiC,iBAAI,IAAM,mBAC1DA,EAAeA,EAAgC,gBAAI,IAAM,kBACzDA,EAAeA,EAAiC,iBAAI,IAAM,mBAC1DA,EAAeA,EAAgC,gBAAI,IAAM,iBAC5D,CALD,CAKGA,IAAmBA,EAAiB,CAAC,IACG,EAAmBE,QCrBvD,MAAM,EAAiB,CAC1BC,QAASL,EAAQI,QACjBE,mBAAoB,EAAmBF,QACvCG,cAAeN,EAAcG,QAC7BI,WAAY,KACZC,YAAa,gCACbC,eAAgB,CACZC,UAAWT,EAAeU,iBAC1BC,SAAUX,EAAeY,iBAE7BC,OAAQ,CAAEC,QHZkB,gCGcnBC,EAAiB,CAC1BZ,QAASL,EAAQkB,QACjBZ,mBAAoB,EAAmBY,QACvCX,cAAeN,EAAciB,QAC7BV,WAAY,KACZC,YAAa,gCACbC,eAAgB,CACZC,UAAWT,EAAeiB,iBAC1BN,SAAUX,EAAekB,iBAE7BL,OAAQ,CAAEC,QHvBkB,gCGyBnBK,EAAgB,IACtBJ,EACHP,eAAgB,IAAKO,EAAeP,gBACpCF,WAAY,KACZO,OAAQ,CAAEC,QH5BY,0BG8BbM,EAAiB,IACvBD,EACHX,eAAgB,IAAKW,EAAcX,gBACnCK,OAAQ,IAAKM,EAAcN,SAiBxB,SAAS,EAAYQ,GACxB,MAAuB,iBAAZA,EAfR,SAAyB1C,GAC5B,OAAQA,GACJ,IAAK,UACD,OAAO,EACX,IAAK,UACD,OAAOoC,EACX,IAAK,SACD,OAAOI,EACX,IAAK,UACD,OAAOC,EACX,QACI,MAAM,IAAI3iB,MAAM,yBAAyBkgB,KAErD,CAGe2C,CAAgBD,GACpBA,CACX,CAWO,SAAS,EAAkBA,GAC9B,OAAIA,EAAQR,OAAO1B,MACRkC,EAAQR,OACZ,IACAQ,EAAQR,OACX1B,MAAO,IAEf,cC5BO,SAASoC,EAAcC,EAAaxhB,EAAOyE,EAAS,GAQvD,OAPA+c,EAAY/c,EAAS,GAAKzE,EAC1BA,KAAW,EACXwhB,EAAY/c,EAAS,GAAKzE,EAC1BA,KAAW,EACXwhB,EAAY/c,EAAS,GAAKzE,EAC1BA,KAAW,EACXwhB,EAAY/c,GAAUzE,EACfwhB,CACX,CCvDO,MACMC,EAA0B,IAC1BC,EAAmB,IACnBC,EAAwB,GAGxB,EAAqC,GAGrC,EAAwB,GAS9B,IAAI,EAYA,EAMA,EACAC,EANAC,EAZAC,KAUR,IAAgB,EAAc,CAAC,IATlBA,EAA2B,cAAI,GAAK,gBAChDA,EAAYA,EAA2B,cAAI,GAAK,gBAChDA,EAAYA,EAAoC,uBAAI,GAAK,yBACzDA,EAAYA,EAA0B,aAAI,GAAK,eAC/CA,EAAYA,EAA8B,iBAAI,GAAK,mBACnDA,EAAYA,EAAsB,SAAI,GAAK,WAC3CA,EAAYA,EAAoC,uBAAI,GAAK,yBACzDA,EAAYA,EAA0B,aAAI,GAAK,eAC/CA,EAAYA,EAA8B,iBAAI,GAAK,oBAG5CD,EAIR,IAAmB,EAAiB,CAAC,IAHrBA,EAAyB,SAAI,GAAK,WACjDA,EAAeA,EAAyB,SAAI,GAAK,WACjDA,EAAeA,EAAyB,SAAI,GAAK,YAG1CD,EAIR,IAAe,EAAa,CAAC,IAHjBA,EAAwB,YAAI,GAAK,cAC5CA,EAAWA,EAAyB,aAAI,GAAK,eAC7CA,EAAWA,EAAgB,IAAI,GAAK,MAgBjC,IAAI,EAKA,EAMA,EAKA,EAUA,EAKAG,GAQAC,GAKA,GAMAC,GAMA,GAKA,GAOAC,GANAC,GALAC,GAZAC,GAlBAC,GAVAC,GALAC,GANAC,GALAC,GAbe,EAAWC,YACX,EAAWC,aACX,EAAWC,IAChC,EAAWF,YAAc,EAAWA,YACpC,EAAWC,aAAe,EAAWA,aACrC,EAAWC,IAAM,EAAWA,KAQtBH,GAGR,IAAsB,EAAoB,CAAC,IAFxBA,GAAyB,MAAI,GAAK,QACpDA,GAAkBA,GAAwB,KAAI,GAAK,QAG5CD,GAIR,IAAsB,EAAoB,CAAC,IAHxBA,GAAuB,IAAI,GAAK,MAClDA,GAAkBA,GAA4B,SAAI,GAAK,WACvDA,GAAkBA,GAA+B,YAAI,GAAK,eAGnDD,GAGR,IAAa,EAAW,CAAC,IAFfA,GAAmB,SAAI,GAAK,WACrCA,GAASA,GAAoB,UAAI,GAAK,aAG/BD,GAOR,IAAoB,EAAkB,CAAC,IANtBA,GAAuB,MAAI,GAAK,QAChDA,GAAgBA,GAAsB,KAAI,GAAK,OAC/CA,GAAgBA,GAAwB,OAAI,GAAK,SACjDA,GAAgBA,GAAuB,MAAI,GAAK,QAChDA,GAAgBA,GAAmC,kBAAI,GAAK,oBAC5DA,GAAgBA,GAAoC,mBAAI,GAAK,sBAItDD,GAGR,IAAmB,EAAiB,CAAC,IAFrBA,GAA2B,WAAI,GAAK,aACnDA,GAAeA,GAA6B,aAAI,GAAK,eAGzD,SAAWP,GACPA,EAAsBA,EAA6B,MAAI,GAAK,QAC5DA,EAAsBA,EAA+B,QAAI,GAAK,UAC9DA,EAAsBA,EAAoC,aAAI,GAAK,eACnEA,EAAsBA,EAA4B,KAAI,GAAK,OAC3DA,EAAsBA,EAAiC,UAAI,GAAK,WACnE,CAND,CAMGA,KAA0BA,GAAwB,CAAC,IAEtD,SAAWC,GACPA,EAAyBA,EAAgC,MAAI,IAAM,QACnEA,EAAyBA,EAAsC,YAAI,IAAM,aAC5E,CAHD,CAGGA,KAA6BA,GAA2B,CAAC,KAEjDK,GAIR,KAA6B,GAA2B,CAAC,IAH/BA,GAAiC,OAAI,GAAK,SACnEA,GAAyBA,GAAmC,SAAI,GAAK,WACrEA,GAAyBA,GAAmC,SAAI,GAAK,WAGzE,SAAWJ,GACPA,EAAUA,EAAe,IAAI,GAAK,MAClCA,EAAUA,EAAoB,SAAI,GAAK,WACvCA,EAAUA,EAAuB,YAAI,GAAK,aAC7C,CAJD,CAIGA,KAAcA,GAAY,CAAC,KAEnBG,GAGR,KAAsB,GAAoB,CAAC,IAFxBA,GAA8B,WAAI,GAAK,aACzDA,GAAkBA,GAA4B,SAAI,GAAK,YAGhDD,GAKR,KAAkB,GAAgB,CAAC,IAJpBA,GAAmC,oBAAI,GAAK,sBAC1DA,GAAcA,GAAqC,sBAAI,GAAK,wBAC5DA,GAAcA,GAAmC,oBAAI,GAAK,sBAC1DA,GAAcA,GAAqC,sBAAI,GAAK,wBAGhE,SAAWD,GACPA,EAAgC,cAAI,gBACpCA,EAAkC,gBAAI,kBACtCA,EAAsC,oBAAI,sBAC1CA,EAA4B,UAAI,YAChCA,EAA2B,SAAI,WAC/BA,EAAiC,eAAI,iBACrCA,EAAiC,eAAI,iBACrCA,EAAuC,qBAAI,uBAC3CA,EAAsC,oBAAI,sBAC1CA,EAAwC,sBAAI,wBAC5CA,EAAiD,+BAAI,iCACrDA,EAAuD,qCAAI,uCAC3DA,EAA4C,0BAAI,4BAChDA,EAAwC,sBAAI,wBAC5CA,EAAuC,qBAAI,uBAC3CA,EAA8C,4BAAI,8BAClDA,EAAwC,sBAAI,wBAC5CA,EAAqC,mBAAI,oBAC5C,CAnBD,CAmBGA,KAAqBA,GAAmB,CAAC,IChJ5C,MAAMY,WAAyBrkB,MAC3B,WAAA6B,CAAYuI,GACRpI,MAAMoI,GACN3K,KAAK2K,QAAUA,EACf3K,KAAKygB,KAAOzgB,KAAKoC,YAAYqe,KACzBlgB,MAAMskB,mBACNtkB,MAAMskB,kBAAkB7kB,KAAMA,KAAKoC,YAE3C,EAEG,MAAM0iB,WAA2BF,GACpC,WAAAxiB,CAAYuI,GACRpI,MAAMoI,EACV,EAEG,MAAM,WAA6Bia,GACtC,WAAAxiB,CAAYuI,GACRpI,MAAMoI,EACV,EAEG,MAAMoa,WAAiCH,GAC1C,WAAAxiB,CAAYuI,GACRpI,MAAMoI,EACV,EAOG,MAAMqa,WAAqBJ,GAC9B,WAAAxiB,CAAYuI,GACRpI,MAAMoI,EACV,EAEG,MAAM,WAA0Bia,GACnC,WAAAxiB,CAAYuI,GACRpI,MAAMoI,EACV,ECtCG,SAASxK,GAAOC,GACnB,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAChC,MAAM,IAAIG,MAAM,2BAA2BH,IACnD,CAKO,SAASM,GAAMD,KAAME,GACxB,KAAMF,aAAaG,YACf,MAAM,IAAIC,UAAU,uBACxB,GAAIF,EAAQG,OAAS,IAAMH,EAAQI,SAASN,EAAEK,QAC1C,MAAM,IAAID,UAAU,iCAAiCF,oBAA0BF,EAAEK,SACzF,CAoBA,MAQA,GARe,CACXX,UACAK,KA/BG,SAAcC,GACjB,GAAiB,kBAANA,EACP,MAAM,IAAIF,MAAM,yBAAyBE,IACjD,EA6BIC,SACAM,KAvBG,SAAcA,GACjB,GAAoB,mBAATA,GAA8C,mBAAhBA,EAAKC,OAC1C,MAAM,IAAIV,MAAM,mDACpBJ,GAAOa,EAAKE,WACZf,GAAOa,EAAKG,SAChB,EAmBIC,OAlBG,SAAgBC,EAAUC,GAAgB,GAC7C,GAAID,EAASE,UACT,MAAM,IAAIhB,MAAM,oCACpB,GAAIe,GAAiBD,EAASG,SAC1B,MAAM,IAAIjB,MAAM,wCACxB,EAcIkB,OAbG,SAAgBC,EAAKL,GACxBX,GAAMgB,GACN,MAAMC,EAAMN,EAASH,UACrB,GAAIQ,EAAIZ,OAASa,EACb,MAAM,IAAIpB,MAAM,yDAAyDoB,IAEjF,GCxBagB,ICNY,iBAATwC,MAAqB,WAAYA,MAAOA,KAAKJ,ODMlC+C,GAAQ,IAAIG,SAASH,EAAIrF,OAAQqF,EAAInE,WAAYmE,EAAIC,aAEnEnB,GAAO,CAACsB,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,EAIxE,GAHgF,KAA5D,IAAIvH,WAAW,IAAI+E,YAAY,CAAC,YAAalD,QAAQ,GAIrE,MAAM,IAAIlC,MAAM,+CAyDb,SAASyC,GAAQH,GAGpB,GAFoB,iBAATA,IACPA,EARD,SAAqB6F,GACxB,GAAmB,iBAARA,EACP,MAAM,IAAI7H,UAAU,2CAA2C6H,GAEnE,OAAO,IAAIC,aAAcC,OAAOF,EACpC,CAGe,CAAY7F,MACjBA,aAAgBjC,YAClB,MAAM,IAAIC,UAAU,iDAAiDgC,MACzE,OAAOA,CACX,CA9DcwF,MAAMC,KAAK,CAAExH,OAAQ,MAAO,CAACyH,EAAG7E,IAAMA,EAAE8E,SAAS,IAAIC,SAAS,EAAG,OAkFxE,MAAMtG,GAET,KAAA+H,GACI,OAAOlK,KAAK6E,YAChB,EAUG,SAASoC,GAAgBwD,GAC5B,MAAMC,EAASC,GAAYF,IAAkB7H,OAAOI,GAAQ2H,IAAUlG,SAChEmG,EAAMH,IAIZ,OAHAC,EAAMxJ,UAAY0J,EAAI1J,UACtBwJ,EAAMvJ,SAAWyJ,EAAIzJ,SACrBuJ,EAAMzJ,OAAS,IAAMwJ,IACdC,CACX,CEpHA,MAAMua,WAAa9iB,GACf,WAAAC,CAAYpB,EAAMkkB,GACd3iB,QACAvC,KAAKwB,UAAW,EAChBxB,KAAKuB,WAAY,EACjB,QAAYP,GACZ,MAAMiU,EAAMjS,GAAQkiB,GAEpB,GADAllB,KAAKmlB,MAAQnkB,EAAKC,SACe,mBAAtBjB,KAAKmlB,MAAMviB,OAClB,MAAM,IAAI/B,UAAU,uDACxBb,KAAKmB,SAAWnB,KAAKmlB,MAAMhkB,SAC3BnB,KAAKkB,UAAYlB,KAAKmlB,MAAMjkB,UAC5B,MAAMC,EAAWnB,KAAKmB,SAChB8I,EAAM,IAAIrJ,WAAWO,GAE3B8I,EAAI9G,IAAI8R,EAAInU,OAASK,EAAWH,EAAKC,SAAS2B,OAAOqS,GAAKxQ,SAAWwQ,GACrE,IAAK,IAAIvR,EAAI,EAAGA,EAAIuG,EAAInJ,OAAQ4C,IAC5BuG,EAAIvG,IAAM,GACd1D,KAAKmlB,MAAMviB,OAAOqH,GAElBjK,KAAKolB,MAAQpkB,EAAKC,SAElB,IAAK,IAAIyC,EAAI,EAAGA,EAAIuG,EAAInJ,OAAQ4C,IAC5BuG,EAAIvG,IAAM,IACd1D,KAAKolB,MAAMxiB,OAAOqH,GAClBA,EAAIxG,KAAK,EACb,CACA,MAAAb,CAAOyiB,GAGH,OAFA,UAAcrlB,MACdA,KAAKmlB,MAAMviB,OAAOyiB,GACXrlB,IACX,CACA,UAAAwD,CAAW9B,GACP,UAAc1B,MACd,SAAa0B,EAAK1B,KAAKkB,WACvBlB,KAAKwB,UAAW,EAChBxB,KAAKmlB,MAAM3hB,WAAW9B,GACtB1B,KAAKolB,MAAMxiB,OAAOlB,GAClB1B,KAAKolB,MAAM5hB,WAAW9B,GACtB1B,KAAK4E,SACT,CACA,MAAAH,GACI,MAAM/C,EAAM,IAAId,WAAWZ,KAAKolB,MAAMlkB,WAEtC,OADAlB,KAAKwD,WAAW9B,GACTA,CACX,CACA,UAAAmD,CAAWC,GAEPA,IAAOA,EAAKlD,OAAOX,OAAOW,OAAO4U,eAAexW,MAAO,CAAC,IACxD,MAAM,MAAEolB,EAAK,MAAED,EAAK,SAAE3jB,EAAQ,UAAED,EAAS,SAAEJ,EAAQ,UAAED,GAAclB,KAQnE,OANA8E,EAAGtD,SAAWA,EACdsD,EAAGvD,UAAYA,EACfuD,EAAG3D,SAAWA,EACd2D,EAAG5D,UAAYA,EACf4D,EAAGsgB,MAAQA,EAAMvgB,WAAWC,EAAGsgB,OAC/BtgB,EAAGqgB,MAAQA,EAAMtgB,WAAWC,EAAGqgB,OACxBrgB,CACX,CACA,OAAAF,GACI5E,KAAKuB,WAAY,EACjBvB,KAAKolB,MAAMxgB,UACX5E,KAAKmlB,MAAMvgB,SACf,EAQG,MAAM0gB,GAAO,CAACtkB,EAAMiU,EAAKtK,IAAY,IAAIsa,GAAKjkB,EAAMiU,GAAKrS,OAAO+H,GAASlG,SAChF6gB,GAAKrkB,OAAS,CAACD,EAAMiU,IAAQ,IAAIgQ,GAAKjkB,EAAMiU,GC3DrC,MAAMjT,WAAaG,GACtB,WAAAC,CAAYjB,EAAUD,EAAWmB,EAAWC,GACxCC,QACAvC,KAAKmB,SAAWA,EAChBnB,KAAKkB,UAAYA,EACjBlB,KAAKqC,UAAYA,EACjBrC,KAAKsC,KAAOA,EACZtC,KAAKwB,UAAW,EAChBxB,KAAKc,OAAS,EACdd,KAAKwC,IAAM,EACXxC,KAAKuB,WAAY,EACjBvB,KAAKyC,OAAS,IAAI7B,WAAWO,GAC7BnB,KAAK0C,KAAOC,GAAW3C,KAAKyC,OAChC,CACA,MAAAG,CAAOC,GACH,UAAc7C,MACd,MAAM,KAAE0C,EAAI,OAAED,EAAM,SAAEtB,GAAanB,KAE7B+C,GADNF,EAAOG,GAAQH,IACE/B,OACjB,IAAK,IAAI0B,EAAM,EAAGA,EAAMO,GAAM,CAC1B,MAAME,EAAOC,KAAKvB,IAAIR,EAAWnB,KAAKwC,IAAKO,EAAMP,GAEjD,GAAIS,IAAS9B,EAMbsB,EAAOU,IAAIN,EAAKO,SAASZ,EAAKA,EAAMS,GAAOjD,KAAKwC,KAChDxC,KAAKwC,KAAOS,EACZT,GAAOS,EACHjD,KAAKwC,MAAQrB,IACbnB,KAAKqD,QAAQX,EAAM,GACnB1C,KAAKwC,IAAM,OAXf,CACI,MAAMc,EAAWX,GAAWE,GAC5B,KAAO1B,GAAY4B,EAAMP,EAAKA,GAAOrB,EACjCnB,KAAKqD,QAAQC,EAAUd,EAE/B,CAQJ,CAGA,OAFAxC,KAAKc,QAAU+B,EAAK/B,OACpBd,KAAKuD,aACEvD,IACX,CACA,UAAAwD,CAAW9B,GACP,UAAc1B,MACd,UAAc0B,EAAK1B,MACnBA,KAAKwB,UAAW,EAIhB,MAAM,OAAEiB,EAAM,KAAEC,EAAI,SAAEvB,EAAQ,KAAEmB,GAAStC,KACzC,IAAI,IAAEwC,GAAQxC,KAEdyC,EAAOD,KAAS,IAChBxC,KAAKyC,OAAOW,SAASZ,GAAKiB,KAAK,GAE3BzD,KAAKqC,UAAYlB,EAAWqB,IAC5BxC,KAAKqD,QAAQX,EAAM,GACnBF,EAAM,GAGV,IAAK,IAAIkB,EAAIlB,EAAKkB,EAAIvC,EAAUuC,IAC5BjB,EAAOiB,GAAK,GAxExB,SAAsBhB,EAAMiB,EAAY7B,EAAOQ,GAC3C,GAAiC,mBAAtBI,EAAKkB,aACZ,OAAOlB,EAAKkB,aAAaD,EAAY7B,EAAOQ,GAChD,MAAMuB,EAAOC,OAAO,IACdC,EAAWD,OAAO,YAClBE,EAAK3D,OAAQyB,GAAS+B,EAAQE,GAC9BE,EAAK5D,OAAOyB,EAAQiC,GACpBG,EAAI5B,EAAO,EAAI,EACf6B,EAAI7B,EAAO,EAAI,EACrBI,EAAK0B,UAAUT,EAAaO,EAAGF,EAAI1B,GACnCI,EAAK0B,UAAUT,EAAaQ,EAAGF,EAAI3B,EACvC,CAiEQsB,CAAalB,EAAMvB,EAAW,EAAG2C,OAAqB,EAAd9D,KAAKc,QAAawB,GAC1DtC,KAAKqD,QAAQX,EAAM,GACnB,MAAM2B,EAAQ1B,GAAWjB,GACnBqB,EAAM/C,KAAKkB,UAEjB,GAAI6B,EAAM,EACN,MAAM,IAAIxC,MAAM,+CACpB,MAAM+D,EAASvB,EAAM,EACfwB,EAAQvE,KAAKwE,MACnB,GAAIF,EAASC,EAAMzD,OACf,MAAM,IAAIP,MAAM,sCACpB,IAAK,IAAImD,EAAI,EAAGA,EAAIY,EAAQZ,IACxBW,EAAMD,UAAU,EAAIV,EAAGa,EAAMb,GAAIpB,EACzC,CACA,MAAAmC,GACI,MAAM,OAAEhC,EAAM,UAAEvB,GAAclB,KAC9BA,KAAKwD,WAAWf,GAChB,MAAMiC,EAAMjC,EAAOkC,MAAM,EAAGzD,GAE5B,OADAlB,KAAK4E,UACEF,CACX,CACA,UAAAG,CAAWC,GACPA,IAAOA,EAAK,IAAI9E,KAAKoC,aACrB0C,EAAG3B,OAAOnD,KAAKwE,OACf,MAAM,SAAErD,EAAQ,OAAEsB,EAAM,OAAE3B,EAAM,SAAEU,EAAQ,UAAED,EAAS,IAAEiB,GAAQxC,KAO/D,OANA8E,EAAGhE,OAASA,EACZgE,EAAGtC,IAAMA,EACTsC,EAAGtD,SAAWA,EACdsD,EAAGvD,UAAYA,EACXT,EAASK,GACT2D,EAAGrC,OAAOU,IAAIV,GACXqC,CACX,EC5GJ,MAEMS,GAAM,CAACC,EAAG/E,EAAGgF,IAAOD,EAAI/E,EAAM+E,EAAIC,EAAMhF,EAAIgF,EAI5CC,GAAW,IAAIC,YAAY,CAC7B,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WACpF,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UACpF,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UACpF,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,aAIlFC,GAAK,IAAID,YAAY,CACvB,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,aAIlFE,GAAW,IAAIF,YAAY,IACjC,MAAMG,WAAe9D,GACjB,WAAAI,GACIG,MAAM,GAAI,GAAI,GAAG,GAGjBvC,KAAK+F,EAAY,EAARH,GAAG,GACZ5F,KAAKgG,EAAY,EAARJ,GAAG,GACZ5F,KAAKiG,EAAY,EAARL,GAAG,GACZ5F,KAAKkG,EAAY,EAARN,GAAG,GACZ5F,KAAKmG,EAAY,EAARP,GAAG,GACZ5F,KAAKoG,EAAY,EAARR,GAAG,GACZ5F,KAAKqG,EAAY,EAART,GAAG,GACZ5F,KAAKsG,EAAY,EAARV,GAAG,EAChB,CACA,GAAApB,GACI,MAAM,EAAEuB,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,GAAMtG,KACnC,MAAO,CAAC+F,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EACjC,CAEA,GAAAnD,CAAI4C,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GACrBtG,KAAK+F,EAAQ,EAAJA,EACT/F,KAAKgG,EAAQ,EAAJA,EACThG,KAAKiG,EAAQ,EAAJA,EACTjG,KAAKkG,EAAQ,EAAJA,EACTlG,KAAKmG,EAAQ,EAAJA,EACTnG,KAAKoG,EAAQ,EAAJA,EACTpG,KAAKqG,EAAQ,EAAJA,EACTrG,KAAKsG,EAAQ,EAAJA,CACb,CACA,OAAAjD,CAAQX,EAAM6D,GAEV,IAAK,IAAI7C,EAAI,EAAGA,EAAI,GAAIA,IAAK6C,GAAU,EACnCV,GAASnC,GAAKhB,EAAK8D,UAAUD,GAAQ,GACzC,IAAK,IAAI7C,EAAI,GAAIA,EAAI,GAAIA,IAAK,CAC1B,MAAM+C,EAAMZ,GAASnC,EAAI,IACnBgD,EAAKb,GAASnC,EAAI,GAClBiD,EAAKC,GAAKH,EAAK,GAAKG,GAAKH,EAAK,IAAOA,IAAQ,EAC7CI,EAAKD,GAAKF,EAAI,IAAME,GAAKF,EAAI,IAAOA,IAAO,GACjDb,GAASnC,GAAMmD,EAAKhB,GAASnC,EAAI,GAAKiD,EAAKd,GAASnC,EAAI,IAAO,CACnE,CAEA,IAAI,EAAEqC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,EAAC,EAAEC,GAAMtG,KACjC,IAAK,IAAI0D,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,MACMoD,EAAMR,GADGM,GAAKT,EAAG,GAAKS,GAAKT,EAAG,IAAMS,GAAKT,EAAG,OAnEjDX,EAoE4BW,GAAGC,GApEPZ,EAoEUa,GAAKX,GAAShC,GAAKmC,GAASnC,GAAM,EAE/DqD,GADSH,GAAKb,EAAG,GAAKa,GAAKb,EAAG,IAAMa,GAAKb,EAAG,KAC7BR,GAAIQ,EAAGC,EAAGC,GAAM,EACrCK,EAAID,EACJA,EAAID,EACJA,EAAID,EACJA,EAAKD,EAAIY,EAAM,EACfZ,EAAID,EACJA,EAAID,EACJA,EAAID,EACJA,EAAKe,EAAKC,EAAM,CACpB,CA/EI,IAACvB,EAiFLO,EAAKA,EAAI/F,KAAK+F,EAAK,EACnBC,EAAKA,EAAIhG,KAAKgG,EAAK,EACnBC,EAAKA,EAAIjG,KAAKiG,EAAK,EACnBC,EAAKA,EAAIlG,KAAKkG,EAAK,EACnBC,EAAKA,EAAInG,KAAKmG,EAAK,EACnBC,EAAKA,EAAIpG,KAAKoG,EAAK,EACnBC,EAAKA,EAAIrG,KAAKqG,EAAK,EACnBC,EAAKA,EAAItG,KAAKsG,EAAK,EACnBtG,KAAKmD,IAAI4C,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAClC,CACA,UAAA/C,GACIsC,GAASpC,KAAK,EAClB,CACA,OAAAmB,GACI5E,KAAKmD,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAC9BnD,KAAKyC,OAAOgB,KAAK,EACrB,EAGJ,MAAMuD,WAAelB,GACjB,WAAA1D,GACIG,QACAvC,KAAK+F,GAAI,WACT/F,KAAKgG,EAAI,UACThG,KAAKiG,EAAI,UACTjG,KAAKkG,GAAI,UACTlG,KAAKmG,GAAI,QACTnG,KAAKoG,EAAI,WACTpG,KAAKqG,EAAI,WACTrG,KAAKsG,GAAI,WACTtG,KAAKkB,UAAY,EACrB,EAMG,MAAMmE,GAAS4B,IAAgB,IAAM,IAAInB,KAC1BmB,IAAgB,IAAM,IAAID,gCCxHhD,MAAMue,GAAMzhB,OAAO,GACb0hB,GAAM1hB,OAAO,GACb2hB,GAAM3hB,OAAO,GACb4hB,GAAM5hB,OAAO,GACb6hB,GAAM7hB,OAAO,GACb8hB,GAAQhkB,OAAOikB,OAAO,CACxBrgB,EAAG+f,GACH9kB,EAAGqD,OAAO,GACVgiB,EAAGhiB,OAAO,sEACV1D,EAAG0D,OAAO,sEACVI,EAAGshB,GACHO,GAAIjiB,OAAO,iFACXkiB,GAAIliB,OAAO,iFACXmiB,KAAMniB,OAAO,wEAEXoiB,GAAa,CAAC1gB,EAAG/E,KAAO+E,EAAI/E,EAAIglB,IAAOhlB,EACvC0lB,GAAO,CACTF,KAAMniB,OAAO,sEACb,WAAAsiB,CAAYC,GACR,MAAM,EAAEjmB,GAAMwlB,GACRU,EAAKxiB,OAAO,sCACZyiB,GAAMf,GAAM1hB,OAAO,sCACnB0iB,EAAK1iB,OAAO,uCACZ2iB,EAAKH,EACLI,EAAY5iB,OAAO,uCACnB6iB,EAAKT,GAAWO,EAAKJ,EAAGjmB,GACxBwmB,EAAKV,IAAYK,EAAKF,EAAGjmB,GAC/B,IAAIymB,EAAKC,GAAIT,EAAIM,EAAKL,EAAKM,EAAKJ,EAAIpmB,GAChC2mB,EAAKD,IAAKH,EAAKJ,EAAKK,EAAKH,EAAIrmB,GACjC,MAAM4mB,EAAQH,EAAKH,EACbO,EAAQF,EAAKL,EAKnB,GAJIM,IACAH,EAAKzmB,EAAIymB,GACTI,IACAF,EAAK3mB,EAAI2mB,GACTF,EAAKH,GAAaK,EAAKL,EACvB,MAAM,IAAInmB,MAAM,2CAA6C8lB,GAEjE,MAAO,CAAEW,QAAOH,KAAII,QAAOF,KAC/B,GAEEG,GAAW,GACXC,GAAW,GAEXC,GAAgBF,GAAW,EAC3BG,GAAkB,EAAIH,GAAW,EAEvC,SAASI,GAAYnc,GACjB,MAAM,EAAE3F,EAAC,EAAE/E,GAAMmlB,GACX2B,EAAKT,GAAI3b,EAAIA,GACbqc,EAAKV,GAAIS,EAAKpc,GACpB,OAAO2b,GAAIU,EAAKhiB,EAAI2F,EAAI1K,EAC5B,CACA,MAAMgnB,GAAmB7B,GAAMpgB,IAAM+f,GACrC,MAAMmC,WAAiBnnB,MACnB,WAAA6B,CAAYuI,GACRpI,MAAMoI,EACV,EAEJ,SAASgd,GAAenL,GACpB,KAAMA,aAAiBoL,IACnB,MAAM,IAAI/mB,UAAU,yBAC5B,CACA,MAAM+mB,GACF,WAAAxlB,CAAY+I,EAAG0c,EAAGC,GACd9nB,KAAKmL,EAAIA,EACTnL,KAAK6nB,EAAIA,EACT7nB,KAAK8nB,EAAIA,CACb,CACA,iBAAOC,CAAWC,GACd,KAAMA,aAAa,IACf,MAAM,IAAInnB,UAAU,4CAExB,OAAImnB,EAAEC,OAAO,GAAMC,MACRN,GAAcM,KAClB,IAAIN,GAAcI,EAAE7c,EAAG6c,EAAEH,EAAGrC,GACvC,CACA,oBAAO2C,CAAcC,GACjB,MAAMC,EAkkBd,SAAqBC,EAAMN,EAAIpC,GAAME,GACjC,MAAMyC,EAAU,IAAIlgB,MAAMigB,EAAKxnB,QAOzB0nB,EAAWC,GANMH,EAAKve,QAAO,CAAC2e,EAAKC,EAAKjlB,IACtCilB,IAAQpD,GACDmD,GACXH,EAAQ7kB,GAAKglB,EACN5B,GAAI4B,EAAMC,EAAKX,KACvBxC,IACqCwC,GAOxC,OANAM,EAAKM,aAAY,CAACF,EAAKC,EAAKjlB,IACpBilB,IAAQpD,GACDmD,GACXH,EAAQ7kB,GAAKojB,GAAI4B,EAAMH,EAAQ7kB,GAAIskB,GAC5BlB,GAAI4B,EAAMC,EAAKX,KACvBQ,GACID,CACX,CAllBsBM,CAAYT,EAAO9T,KAAK0T,GAAMA,EAAEF,KAC9C,OAAOM,EAAO9T,KAAI,CAAC0T,EAAGtkB,IAAMskB,EAAEc,SAAST,EAAM3kB,KACjD,CACA,iBAAOqlB,CAAWX,GACd,OAAOR,GAAcO,cAAcC,GAAQ9T,IAAIsT,GAAcG,WACjE,CACA,MAAAE,CAAOzL,GACHmL,GAAenL,GACf,MAAQrR,EAAG6d,EAAInB,EAAGoB,EAAInB,EAAGoB,GAAOlpB,MACxBmL,EAAGge,EAAItB,EAAGuB,EAAItB,EAAGuB,GAAO7M,EAC1B8M,EAAOxC,GAAIoC,EAAKA,GAChBK,EAAOzC,GAAIuC,EAAKA,GAChBG,EAAK1C,GAAIkC,EAAKO,GACdE,EAAK3C,GAAIqC,EAAKG,GACdI,EAAK5C,GAAIA,GAAImC,EAAKI,GAAME,GACxBI,EAAK7C,GAAIA,GAAIsC,EAAKF,GAAMI,GAC9B,OAAOE,IAAOC,GAAMC,IAAOC,CAC/B,CACA,MAAAC,GACI,OAAO,IAAIhC,GAAc5nB,KAAKmL,EAAG2b,IAAK9mB,KAAK6nB,GAAI7nB,KAAK8nB,EACxD,CACA,MAAA+B,GACI,MAAQ1e,EAAG6d,EAAInB,EAAGoB,EAAInB,EAAGoB,GAAOlpB,KAC1B+F,EAAI+gB,GAAIkC,EAAKA,GACbhjB,EAAI8gB,GAAImC,EAAKA,GACbhjB,EAAI6gB,GAAI9gB,EAAIA,GACZ8jB,EAAMd,EAAKhjB,EACXE,EAAI4gB,GAAIrB,IAAOqB,GAAIgD,EAAMA,GAAO/jB,EAAIE,IACpCE,EAAI2gB,GAAIpB,GAAM3f,GACdK,EAAI0gB,GAAI3gB,EAAIA,GACZ4jB,EAAKjD,GAAI1gB,EAAIqf,GAAMvf,GACnB8jB,EAAKlD,GAAI3gB,GAAKD,EAAI6jB,GAAMpE,GAAM1f,GAC9BgkB,EAAKnD,GAAIrB,GAAMwD,EAAKC,GAC1B,OAAO,IAAItB,GAAcmC,EAAIC,EAAIC,EACrC,CACA,GAAAxV,CAAI+H,GACAmL,GAAenL,GACf,MAAQrR,EAAG6d,EAAInB,EAAGoB,EAAInB,EAAGoB,GAAOlpB,MACxBmL,EAAGge,EAAItB,EAAGuB,EAAItB,EAAGuB,GAAO7M,EAChC,GAAI2M,IAAO5D,IAAO6D,IAAO7D,GACrB,OAAOvlB,KACX,GAAIgpB,IAAOzD,IAAO0D,IAAO1D,GACrB,OAAO/I,EACX,MAAM8M,EAAOxC,GAAIoC,EAAKA,GAChBK,EAAOzC,GAAIuC,EAAKA,GAChBG,EAAK1C,GAAIkC,EAAKO,GACdE,EAAK3C,GAAIqC,EAAKG,GACdI,EAAK5C,GAAIA,GAAImC,EAAKI,GAAME,GACxBI,EAAK7C,GAAIA,GAAIsC,EAAKF,GAAMI,GACxBhjB,EAAIwgB,GAAI2C,EAAKD,GACbpL,EAAI0I,GAAI6C,EAAKD,GACnB,GAAIpjB,IAAMif,GACN,OAAInH,IAAMmH,GACCvlB,KAAK6pB,SAGLjC,GAAcM,KAG7B,MAAMgC,EAAKpD,GAAIxgB,EAAIA,GACb6jB,EAAMrD,GAAIxgB,EAAI4jB,GACdE,EAAItD,GAAI0C,EAAKU,GACbH,EAAKjD,GAAI1I,EAAIA,EAAI+L,EAAM1E,GAAM2E,GAC7BJ,EAAKlD,GAAI1I,GAAKgM,EAAIL,GAAML,EAAKS,GAC7BF,EAAKnD,GAAIoC,EAAKG,EAAK/iB,GACzB,OAAO,IAAIshB,GAAcmC,EAAIC,EAAIC,EACrC,CACA,QAAAI,CAAS7N,GACL,OAAOxc,KAAKyU,IAAI+H,EAAMoN,SAC1B,CACA,cAAAU,CAAeC,GACX,MAAMC,EAAK5C,GAAcM,KACzB,GAAsB,iBAAXqC,GAAuBA,IAAWhF,GACzC,OAAOiF,EACX,IAAIpqB,EAAIqqB,GAAgBF,GACxB,GAAInqB,IAAMolB,GACN,OAAOxlB,KACX,IAAKynB,GAAkB,CACnB,IAAIO,EAAIwC,EACJzM,EAAI/d,KACR,KAAOI,EAAImlB,IACHnlB,EAAIolB,KACJwC,EAAIA,EAAEvT,IAAIsJ,IACdA,EAAIA,EAAE8L,SACNzpB,IAAMolB,GAEV,OAAOwC,CACX,CACA,IAAI,MAAEhB,EAAK,GAAEH,EAAE,MAAEI,EAAK,GAAEF,GAAOZ,GAAKC,YAAYhmB,GAC5CsqB,EAAMF,EACNG,EAAMH,EACNzM,EAAI/d,KACR,KAAO6mB,EAAKtB,IAAOwB,EAAKxB,IAChBsB,EAAKrB,KACLkF,EAAMA,EAAIjW,IAAIsJ,IACdgJ,EAAKvB,KACLmF,EAAMA,EAAIlW,IAAIsJ,IAClBA,EAAIA,EAAE8L,SACNhD,IAAOrB,GACPuB,IAAOvB,GAOX,OALIwB,IACA0D,EAAMA,EAAId,UACV3C,IACA0D,EAAMA,EAAIf,UACde,EAAM,IAAI/C,GAAcd,GAAI6D,EAAIxf,EAAIgb,GAAKF,MAAO0E,EAAI9C,EAAG8C,EAAI7C,GACpD4C,EAAIjW,IAAIkW,EACnB,CACA,gBAAAC,CAAiBC,GACb,MAAMC,EAAUrD,GAAmB,IAAMoD,EAAI,EAAI,IAAMA,EAAI,EACrDzC,EAAS,GACf,IAAIJ,EAAIhoB,KACJ+qB,EAAO/C,EACX,IAAK,IAAIrJ,EAAS,EAAGA,EAASmM,EAASnM,IAAU,CAC7CoM,EAAO/C,EACPI,EAAOjM,KAAK4O,GACZ,IAAK,IAAIrnB,EAAI,EAAGA,EAAI,IAAMmnB,EAAI,GAAInnB,IAC9BqnB,EAAOA,EAAKtW,IAAIuT,GAChBI,EAAOjM,KAAK4O,GAEhB/C,EAAI+C,EAAKlB,QACb,CACA,OAAOzB,CACX,CACA,IAAA4C,CAAK5qB,EAAG6qB,IACCA,GAAejrB,KAAKioB,OAAOL,GAAcrc,QAC1C0f,EAAc,GAAM1f,MACxB,MAAMsf,EAAKI,GAAeA,EAAYC,cAAiB,EACvD,GAAI,IAAML,EACN,MAAM,IAAItqB,MAAM,iEAEpB,IAAI4qB,EAAcF,GAAeG,GAAiB5mB,IAAIymB,GACjDE,IACDA,EAAcnrB,KAAK4qB,iBAAiBC,GAChCI,GAAqB,IAANJ,IACfM,EAAcvD,GAAcmB,WAAWoC,GACvCC,GAAiBjoB,IAAI8nB,EAAaE,KAG1C,IAAInD,EAAIJ,GAAcM,KAClBmD,EAAIzD,GAAcrc,KACtB,MAAMuf,EAAU,GAAKrD,GAAmB,IAAMoD,EAAI,IAAMA,GAClDS,EAAa,IAAMT,EAAI,GACvBU,EAAOznB,OAAO,GAAK+mB,EAAI,GACvBW,EAAY,GAAKX,EACjBY,EAAU3nB,OAAO+mB,GACvB,IAAK,IAAIlM,EAAS,EAAGA,EAASmM,EAASnM,IAAU,CAC7C,MAAMpY,EAASoY,EAAS2M,EACxB,IAAII,EAAQrrB,OAAOD,EAAImrB,GACvBnrB,IAAMqrB,EACFC,EAAQJ,IACRI,GAASF,EACTprB,GAAKolB,IAET,MAAMmG,EAAUplB,EACVqlB,EAAUrlB,EAASrD,KAAK2oB,IAAIH,GAAS,EACrCI,EAAQnN,EAAS,GAAM,EACvBoN,EAAQL,EAAQ,EACR,IAAVA,EACAL,EAAIA,EAAE5W,IAAIuX,GAAgBF,EAAOX,EAAYQ,KAG7C3D,EAAIA,EAAEvT,IAAIuX,GAAgBD,EAAOZ,EAAYS,IAErD,CACA,MAAO,CAAE5D,IAAGqD,IAChB,CACA,QAAAY,CAAS1B,EAAQU,GACb,IACIiB,EACAC,EAFA/rB,EAAIqqB,GAAgBF,GAGxB,GAAI9C,GAAkB,CAClB,MAAM,MAAET,EAAK,GAAEH,EAAE,MAAEI,EAAK,GAAEF,GAAOZ,GAAKC,YAAYhmB,GAClD,IAAM4nB,EAAG0C,EAAKW,EAAGe,GAAQpsB,KAAKgrB,KAAKnE,EAAIoE,IACjCjD,EAAG2C,EAAKU,EAAGgB,GAAQrsB,KAAKgrB,KAAKjE,EAAIkE,GACvCP,EAAMsB,GAAgBhF,EAAO0D,GAC7BC,EAAMqB,GAAgB/E,EAAO0D,GAC7BA,EAAM,IAAI/C,GAAcd,GAAI6D,EAAIxf,EAAIgb,GAAKF,MAAO0E,EAAI9C,EAAG8C,EAAI7C,GAC3DoE,EAAQxB,EAAIjW,IAAIkW,GAChBwB,EAAOC,EAAI3X,IAAI4X,EACnB,KACK,CACD,MAAM,EAAErE,EAAC,EAAEqD,GAAMrrB,KAAKgrB,KAAK5qB,EAAG6qB,GAC9BiB,EAAQlE,EACRmE,EAAOd,CACX,CACA,OAAOzD,GAAcmB,WAAW,CAACmD,EAAOC,IAAO,EACnD,CACA,QAAArD,CAASwD,GACL,MAAM,EAAEnhB,EAAC,EAAE0c,EAAC,EAAEC,GAAM9nB,KACdusB,EAAMvsB,KAAKioB,OAAOL,GAAcM,MAC1B,MAARoE,IACAA,EAAOC,EAAM5G,GAAM8C,GAAOX,IAC9B,MAAM0E,EAAMF,EACNG,EAAM3F,GAAI0F,EAAMA,GAChBE,EAAM5F,GAAI2F,EAAMD,GAChBG,EAAK7F,GAAI3b,EAAIshB,GACbG,EAAK9F,GAAIe,EAAI6E,GACbG,EAAK/F,GAAIgB,EAAI0E,GACnB,GAAID,EACA,OAAO,GAAMrE,KACjB,GAAI2E,IAAOrH,GACP,MAAM,IAAIjlB,MAAM,oBACpB,OAAO,IAAI,GAAMosB,EAAIC,EACzB,EAIJ,SAASZ,GAAgBc,EAAWC,GAChC,MAAMC,EAAMD,EAAKnD,SACjB,OAAOkD,EAAYE,EAAMD,CAC7B,CALAnF,GAAcrc,KAAO,IAAIqc,GAAchC,GAAMG,GAAIH,GAAMI,GAAIR,IAC3DoC,GAAcM,KAAO,IAAIN,GAAcrC,GAAKC,GAAKD,IAKjD,MAAM6F,GAAmB,IAAI/T,QACtB,MAAM,GACT,WAAAjV,CAAY+I,EAAG0c,GACX7nB,KAAKmL,EAAIA,EACTnL,KAAK6nB,EAAIA,CACb,CACA,cAAAoF,CAAe3B,GACXtrB,KAAKkrB,aAAeI,EACpBF,GAAiB8B,OAAOltB,KAC5B,CACA,QAAAmtB,GACI,OAAOntB,KAAK6nB,EAAIpC,KAAQF,EAC5B,CACA,wBAAO6H,CAAkB1sB,GACrB,MAAM2sB,EAA2B,KAAjB3sB,EAAMI,OAChBqK,EAAImiB,GAAcD,EAAU3sB,EAAQA,EAAM0C,SAAS,IACzD,IAAKmqB,GAAoBpiB,GACrB,MAAM,IAAI5K,MAAM,yBAEpB,IAAIsnB,EA6SZ,SAAiB1c,GACb,MAAM,EAAE2a,GAAMF,GACR4H,EAAM1pB,OAAO,GACb2pB,EAAO3pB,OAAO,IACd4pB,EAAO5pB,OAAO,IACd6pB,EAAO7pB,OAAO,IACd8pB,EAAO9pB,OAAO,IACd+pB,EAAO/pB,OAAO,IACd2iB,EAAMtb,EAAIA,EAAIA,EAAK2a,EACnBgI,EAAMrH,EAAKA,EAAKtb,EAAK2a,EACrBiI,EAAMC,GAAKF,EAAIpI,IAAOoI,EAAMhI,EAC5BmI,EAAMD,GAAKD,EAAIrI,IAAOoI,EAAMhI,EAC5BoI,EAAOF,GAAKC,EAAIxI,IAAOgB,EAAMX,EAC7BqI,EAAOH,GAAKE,EAAKT,GAAQS,EAAOpI,EAChCsI,EAAOJ,GAAKG,EAAKT,GAAQS,EAAOrI,EAChCuI,EAAOL,GAAKI,EAAKR,GAAQQ,EAAOtI,EAChCwI,EAAQN,GAAKK,EAAKR,GAAQQ,EAAOvI,EACjCyI,EAAQP,GAAKM,EAAMV,GAAQQ,EAAOtI,EAClC0I,EAAQR,GAAKO,EAAM7I,IAAOoI,EAAMhI,EAChC2I,EAAMT,GAAKQ,EAAMb,GAAQQ,EAAOrI,EAChC4I,EAAMV,GAAKS,EAAIjB,GAAO/G,EAAMX,EAC5B6I,EAAKX,GAAKU,EAAIjJ,IAEpB,GADYkJ,EAAKA,EAAM7I,IACZ3a,EACP,MAAM,IAAI5K,MAAM,2BACpB,OAAOouB,CACX,CAvUgBC,CADGtH,GAAYnc,IAEvB,MAAM0jB,GAAUhH,EAAIrC,MAASA,GACzB6H,EACIwB,IACAhH,EAAIf,IAAKe,IAG6B,IAAP,EAAXnnB,EAAM,MACPmuB,IACnBhH,EAAIf,IAAKe,IAEjB,MAAMqE,EAAQ,IAAI,GAAM/gB,EAAG0c,GAE3B,OADAqE,EAAM4C,iBACC5C,CACX,CACA,0BAAO6C,CAAoBruB,GACvB,MAAMyK,EAAImiB,GAAc5sB,EAAM0C,SAAS,EAAG8jB,GAAW,IAC/CW,EAAIyF,GAAc5sB,EAAM0C,SAAS8jB,GAAW,EAAc,EAAXA,GAAe,IAC9DgF,EAAQ,IAAI,GAAM/gB,EAAG0c,GAE3B,OADAqE,EAAM4C,iBACC5C,CACX,CACA,cAAO8C,CAAQlmB,GACX,MAAMpI,EAAQuuB,GAAYnmB,GACpB/F,EAAMrC,EAAMI,OACZouB,EAASxuB,EAAM,GACrB,GAAIqC,IAAQmkB,GACR,OAAOlnB,KAAKotB,kBAAkB1sB,GAClC,GAAIqC,IAAQqkB,KAA6B,IAAX8H,GAA8B,IAAXA,GAC7C,OAAOlvB,KAAKotB,kBAAkB1sB,GAElC,GAAIqC,IAAQskB,IAA8B,IAAX6H,EAC3B,OAAOlvB,KAAK+uB,oBAAoBruB,GACpC,MAAM,IAAIH,MAAM,sDAAsD6mB,0BAAqCC,8BAA2CtkB,IAC1J,CACA,qBAAOosB,CAAeC,GAClB,OAAO,GAAM7jB,KAAK0gB,SAASoD,GAAoBD,GACnD,CACA,oBAAOE,CAAcC,EAASC,EAAWC,GACrC,MAAM,EAAG,EAAEC,GAsdnB,SAA4BF,GACxB,GAAIA,aAAqBG,GAErB,OADAH,EAAUV,iBACHU,EAEX,IACI,OAAOG,GAAUC,QAAQJ,EAC7B,CACA,MAAOK,GACH,OAAOF,GAAUG,YAAYN,EACjC,CACJ,CAjeyBO,CAAmBP,GACpC,IAAK,CAAC,EAAG,EAAG,EAAG,GAAGzuB,SAAS0uB,GACvB,MAAM,IAAIlvB,MAAM,wCACpB,MAAM2D,EAAI8rB,GAAaf,GAAYM,KAC7B,EAAEnvB,GAAMwlB,GACRqK,EAAoB,IAAbR,GAA+B,IAAbA,EAAiBrR,EAAIhe,EAAIge,EAClD8R,EAAOzH,GAAOwH,EAAM7vB,GACpB+vB,EAAKrJ,IAAK5iB,EAAIgsB,EAAM9vB,GACpBgwB,EAAKtJ,GAAI4I,EAAIQ,EAAM9vB,GACnBqO,EAAoB,EAAXghB,EAAe,KAAO,KAC/BY,EAAI,GAAMrB,QAAQvgB,EAAS6hB,GAAYL,IACvCM,EAAI,GAAMhlB,KAAKilB,qBAAqBH,EAAGF,EAAIC,GACjD,IAAKG,EACD,MAAM,IAAIhwB,MAAM,+CAEpB,OADAgwB,EAAEzB,iBACKyB,CACX,CACA,UAAAE,CAAWC,GAAe,GACtB,OAAO,GAAW1wB,KAAK2wB,MAAMD,GACjC,CACA,KAAAC,CAAMD,GAAe,GACjB,MAAMvlB,EAAImlB,GAAYtwB,KAAKmL,GAC3B,OAAIulB,EAEO,GADQ1wB,KAAKmtB,WAAa,KAAO,OACrBhiB,IAGZ,KAAKA,IAAImlB,GAAYtwB,KAAK6nB,IAEzC,CACA,MAAA+I,GACI,OAAO5wB,KAAK2wB,OAAM,GAAMhsB,MAAM,EAClC,CACA,MAAAksB,GACI,OAAO7wB,KAAKywB,YAAW,GAAM9rB,MAAM,EACvC,CACA,cAAAmqB,GACI,MAAMhkB,EAAM,kCACN,EAAEK,EAAC,EAAE0c,GAAM7nB,KACjB,IAAKutB,GAAoBpiB,KAAOoiB,GAAoB1F,GAChD,MAAM,IAAItnB,MAAMuK,GACpB,MAAMgmB,EAAOhK,GAAIe,EAAIA,GAErB,GAAIf,GAAIgK,EADMxJ,GAAYnc,MACAoa,GACtB,MAAM,IAAIhlB,MAAMuK,EACxB,CACA,MAAAmd,CAAOzL,GACH,OAAOxc,KAAKmL,IAAMqR,EAAMrR,GAAKnL,KAAK6nB,IAAMrL,EAAMqL,CAClD,CACA,MAAA+B,GACI,OAAO,IAAI,GAAM5pB,KAAKmL,EAAG2b,IAAK9mB,KAAK6nB,GACvC,CACA,MAAAgC,GACI,OAAOjC,GAAcG,WAAW/nB,MAAM6pB,SAASf,UACnD,CACA,GAAArU,CAAI+H,GACA,OAAOoL,GAAcG,WAAW/nB,MAAMyU,IAAImT,GAAcG,WAAWvL,IAAQsM,UAC/E,CACA,QAAAuB,CAAS7N,GACL,OAAOxc,KAAKyU,IAAI+H,EAAMoN,SAC1B,CACA,QAAAqC,CAAS1B,GACL,OAAO3C,GAAcG,WAAW/nB,MAAMisB,SAAS1B,EAAQvqB,MAAM8oB,UACjE,CACA,oBAAA0H,CAAqBD,EAAG/qB,EAAG/E,GACvB,MAAMqlB,EAAI8B,GAAcG,WAAW/nB,MAC7B+wB,EAAKvrB,IAAM+f,IAAO/f,IAAMggB,IAAOxlB,OAAS,GAAMuL,KAAOua,EAAEwE,eAAe9kB,GAAKsgB,EAAEmG,SAASzmB,GACtFwrB,EAAKpJ,GAAcG,WAAWwI,GAAGjG,eAAe7pB,GAChDwwB,EAAMF,EAAGtc,IAAIuc,GACnB,OAAOC,EAAIhJ,OAAOL,GAAcM,WAAQjjB,EAAYgsB,EAAInI,UAC5D,EAIJ,SAASoI,GAASxB,GACd,OAAOrvB,OAAO8I,SAASumB,EAAE,GAAI,KAAO,EAAI,KAAOA,EAAIA,CACvD,CACA,SAASyB,GAAYtuB,GACjB,GAAIA,EAAK/B,OAAS,GAAiB,IAAZ+B,EAAK,GACxB,MAAM,IAAItC,MAAM,kCAAkC,GAAWsC,MAEjE,MAAME,EAAMF,EAAK,GACX6B,EAAM7B,EAAKO,SAAS,EAAGL,EAAM,GACnC,IAAKA,GAAO2B,EAAI5D,SAAWiC,EACvB,MAAM,IAAIxC,MAAM,2CAEpB,GAAe,IAAXmE,EAAI,IAAeA,EAAI,IAAM,IAC7B,MAAM,IAAInE,MAAM,8CAEpB,MAAO,CAAEsC,KAAMyqB,GAAc5oB,GAAMosB,KAAMjuB,EAAKO,SAASL,EAAM,GACjE,CAlBA,GAAMwI,KAAO,IAAI,GAAMqa,GAAMG,GAAIH,GAAMI,IACvC,GAAMkC,KAAO,IAAI,GAAM3C,GAAKA,IAgCrB,MAAMoK,GACT,WAAAvtB,CAAYgc,EAAGsR,GACX1vB,KAAKoe,EAAIA,EACTpe,KAAK0vB,EAAIA,EACT1vB,KAAK8uB,gBACT,CACA,kBAAOgB,CAAYhnB,GACf,MAAMhB,EAAMgB,aAAelI,WACrB6f,EAAO,wBACb,GAAmB,iBAAR3X,IAAqBhB,EAC5B,MAAM,IAAIjH,UAAU,GAAG4f,oCAC3B,MAAM/X,EAAMZ,EAAM,GAAWgB,GAAOA,EACpC,GAAmB,MAAfJ,EAAI5H,OACJ,MAAM,IAAIP,MAAM,GAAGkgB,2BACvB,OAAO,IAAIkP,GAAUyB,GAAY1oB,EAAI/D,MAAM,EAAG,KAAMysB,GAAY1oB,EAAI/D,MAAM,GAAI,MAClF,CACA,cAAOirB,CAAQ9mB,GACX,MAAMhB,EAAMgB,aAAelI,WAC3B,GAAmB,iBAARkI,IAAqBhB,EAC5B,MAAM,IAAIjH,UAAU,oDACxB,MAAM,EAAEud,EAAC,EAAEsR,GAlCnB,SAA2B7sB,GACvB,GAAIA,EAAK/B,OAAS,GAAgB,IAAX+B,EAAK,GACxB,MAAM,IAAItC,MAAM,0BAA0B,GAAWsC,MAEzD,GAAIA,EAAK,KAAOA,EAAK/B,OAAS,EAC1B,MAAM,IAAIP,MAAM,uCAEpB,MAAQsC,KAAMub,EAAG0S,KAAMO,GAAWF,GAAYtuB,EAAKO,SAAS,KACpDP,KAAM6sB,EAAGoB,KAAMQ,GAAeH,GAAYE,GAClD,GAAIC,EAAWxwB,OACX,MAAM,IAAIP,MAAM,gDAAgD,GAAW+wB,MAE/E,MAAO,CAAElT,IAAGsR,IAChB,CAqByB6B,CAAkBzpB,EAAMgB,EAAM,GAAWA,IAC1D,OAAO,IAAI6mB,GAAUvR,EAAGsR,EAC5B,CACA,cAAOV,CAAQlmB,GACX,OAAO9I,KAAK4vB,QAAQ9mB,EACxB,CACA,cAAAgmB,GACI,MAAM,EAAE1Q,EAAC,EAAEsR,GAAM1vB,KACjB,IAAKwxB,GAAmBpT,GACpB,MAAM,IAAI7d,MAAM,0CACpB,IAAKixB,GAAmB9B,GACpB,MAAM,IAAInvB,MAAM,yCACxB,CACA,QAAAkxB,GACI,MAAMC,EAAO9L,GAAMxlB,GAAKolB,GACxB,OAAOxlB,KAAK0vB,EAAIgC,CACpB,CACA,UAAAC,GACI,OAAO3xB,KAAKyxB,WAAa,IAAI9B,GAAU3vB,KAAKoe,EAAG0I,IAAK9mB,KAAK0vB,EAAG9J,GAAMxlB,IAAMJ,IAC5E,CACA,aAAA4xB,GACI,OAAO,GAAW5xB,KAAK6xB,WAC3B,CACA,QAAAA,GACI,MAAMC,EAAOZ,GAASa,GAAoB/xB,KAAK0vB,IACzCsC,EAAOd,GAASa,GAAoB/xB,KAAKoe,IACzC6T,EAAQH,EAAKhxB,OAAS,EACtBoxB,EAAQF,EAAKlxB,OAAS,EACtBqxB,EAAOJ,GAAoBE,GAC3BG,EAAOL,GAAoBG,GAEjC,MAAO,KADQH,GAAoBG,EAAQD,EAAQ,OAC5BG,IAAOJ,MAASG,IAAOL,GAClD,CACA,UAAArB,GACI,OAAOzwB,KAAK4xB,eAChB,CACA,KAAAjB,GACI,OAAO3wB,KAAK6xB,UAChB,CACA,iBAAAQ,GACI,OAAO,GAAWryB,KAAKsyB,eAC3B,CACA,YAAAA,GACI,OAAOhC,GAAYtwB,KAAKoe,GAAKkS,GAAYtwB,KAAK0vB,EAClD,EAEJ,SAAS,MAAe7lB,GACpB,IAAKA,EAAOC,OAAOrJ,GAAMA,aAAaG,aAClC,MAAM,IAAIL,MAAM,4BACpB,GAAsB,IAAlBsJ,EAAO/I,OACP,OAAO+I,EAAO,GAClB,MAAM/I,EAAS+I,EAAOE,QAAO,CAACvE,EAAGsC,IAAQtC,EAAIsC,EAAIhH,QAAQ,GACnDkJ,EAAS,IAAIpJ,WAAWE,GAC9B,IAAK,IAAI4C,EAAI,EAAGuG,EAAM,EAAGvG,EAAImG,EAAO/I,OAAQ4C,IAAK,CAC7C,MAAMoE,EAAM+B,EAAOnG,GACnBsG,EAAO7G,IAAI2E,EAAKmC,GAChBA,GAAOnC,EAAIhH,MACf,CACA,OAAOkJ,CACX,CACA,MAAM,GAAQ3B,MAAMC,KAAK,CAAExH,OAAQ,MAAO,CAACyH,EAAG7E,IAAMA,EAAE8E,SAAS,IAAIC,SAAS,EAAG,OAC/E,SAAS,GAAWI,GAChB,KAAMA,aAAkBjI,YACpB,MAAM,IAAIL,MAAM,uBACpB,IAAIuI,EAAM,GACV,IAAK,IAAIpF,EAAI,EAAGA,EAAImF,EAAO/H,OAAQ4C,IAC/BoF,GAAO,GAAMD,EAAOnF,IAExB,OAAOoF,CACX,CACA,MAAMypB,GAAYzuB,OAAO,uEACzB,SAASwsB,GAAY3H,GACjB,GAAmB,iBAARA,EACP,MAAM,IAAIpoB,MAAM,mBACpB,KAAMglB,IAAOoD,GAAOA,EAAM4J,IACtB,MAAM,IAAIhyB,MAAM,kCACpB,OAAOooB,EAAIngB,SAAS,IAAIC,SAAS,GAAI,IACzC,CACA,SAAS+pB,GAAS7J,GACd,MAAMloB,EAAI,GAAW6vB,GAAY3H,IACjC,GAAiB,KAAbloB,EAAEK,OACF,MAAM,IAAIP,MAAM,4BACpB,OAAOE,CACX,CACA,SAASsxB,GAAoBpJ,GACzB,MAAM7f,EAAM6f,EAAIngB,SAAS,IACzB,OAAoB,EAAbM,EAAIhI,OAAa,IAAIgI,IAAQA,CACxC,CACA,SAASsoB,GAAYtoB,GACjB,GAAmB,iBAARA,EACP,MAAM,IAAIjI,UAAU,4CAA8CiI,GAEtE,OAAOhF,OAAO,KAAKgF,IACvB,CACA,SAAS,GAAWA,GAChB,GAAmB,iBAARA,EACP,MAAM,IAAIjI,UAAU,2CAA6CiI,GAErE,GAAIA,EAAIhI,OAAS,EACb,MAAM,IAAIP,MAAM,4CAA8CuI,EAAIhI,QACtE,MAAMiI,EAAQ,IAAInI,WAAWkI,EAAIhI,OAAS,GAC1C,IAAK,IAAI4C,EAAI,EAAGA,EAAIqF,EAAMjI,OAAQ4C,IAAK,CACnC,MAAMsF,EAAQ,EAAJtF,EACJuF,EAAUH,EAAInE,MAAMqE,EAAGA,EAAI,GAC3BE,EAAO7I,OAAO8I,SAASF,EAAS,IACtC,GAAI5I,OAAO+I,MAAMF,IAASA,EAAO,EAC7B,MAAM,IAAI3I,MAAM,yBACpBwI,EAAMrF,GAAKwF,CACf,CACA,OAAOH,CACX,CACA,SAASukB,GAAc5sB,GACnB,OAAO0wB,GAAY,GAAW1wB,GAClC,CACA,SAASuuB,GAAYnmB,GACjB,OAAOA,aAAelI,WAAaA,WAAW0H,KAAKQ,GAAO,GAAWA,EACzE,CACA,SAAS2hB,GAAgB9B,GACrB,GAAmB,iBAARA,GAAoBtoB,OAAOC,cAAcqoB,IAAQA,EAAM,EAC9D,OAAO7kB,OAAO6kB,GAClB,GAAmB,iBAARA,GAAoB6I,GAAmB7I,GAC9C,OAAOA,EACX,MAAM,IAAI9nB,UAAU,sDACxB,CACA,SAASimB,GAAIthB,EAAG/E,EAAImlB,GAAME,GACtB,MAAM9b,EAASxE,EAAI/E,EACnB,OAAOuJ,GAAUub,GAAMvb,EAASvJ,EAAIuJ,CACxC,CACA,SAASgkB,GAAK7iB,EAAGsnB,GACb,MAAM,EAAE3M,GAAMF,GACd,IAAIlhB,EAAMyG,EACV,KAAOsnB,KAAUlN,IACb7gB,GAAOA,EACPA,GAAOohB,EAEX,OAAOphB,CACX,CA4BA,SAAS+jB,GAAOtoB,EAAQuyB,EAAS9M,GAAME,GACnC,GAAI3lB,IAAWolB,IAAOmN,GAAUnN,GAC5B,MAAM,IAAIhlB,MAAM,6CAA6CJ,SAAcuyB,KAE/E,IAAIltB,EAAIshB,GAAI3mB,EAAQuyB,GAChBjyB,EAAIiyB,EACJvnB,EAAIoa,GAAKsC,EAAIrC,GAAK5F,EAAI4F,GAAKjd,EAAIgd,GACnC,KAAO/f,IAAM+f,IAAK,CACd,MAAMoN,EAAIlyB,EAAI+E,EACR4Y,EAAI3d,EAAI+E,EACRotB,EAAIznB,EAAIyU,EAAI+S,EACZvyB,EAAIynB,EAAItf,EAAIoqB,EAClBlyB,EAAI+E,EAAGA,EAAI4Y,EAAGjT,EAAIyU,EAAGiI,EAAItf,EAAGqX,EAAIgT,EAAGrqB,EAAInI,CAC3C,CAEA,GADYK,IACA+kB,GACR,MAAM,IAAIjlB,MAAM,0BACpB,OAAOumB,GAAI3b,EAAGunB,EAClB,CAuBA,SAAS1C,GAAahvB,EAAM6xB,GAAe,GACvC,MAAM3uB,EANV,SAAoBxD,GAChB,MAAMoyB,EAAuB,EAAfpyB,EAAMI,OAAwB,EAAXqmB,GAC3BwB,EAAM2E,GAAc5sB,GAC1B,OAAOoyB,EAAQ,EAAInK,GAAO7kB,OAAOgvB,GAASnK,CAC9C,CAEcoK,CAAW/xB,GACrB,GAAI6xB,EACA,OAAO3uB,EACX,MAAM,EAAE9D,GAAMwlB,GACd,OAAO1hB,GAAK9D,EAAI8D,EAAI9D,EAAI8D,CAC5B,CACA,IAAI8uB,GACAC,GACJ,MAAMC,GACF,WAAA9wB,CAAY+wB,EAASC,GAGjB,GAFApzB,KAAKmzB,QAAUA,EACfnzB,KAAKozB,SAAWA,EACO,iBAAZD,GAAwBA,EAAU,EACzC,MAAM,IAAI5yB,MAAM,4BACpB,GAAwB,iBAAb6yB,GAAyBA,EAAW,EAC3C,MAAM,IAAI7yB,MAAM,6BACpBP,KAAKuI,EAAI,IAAI3H,WAAWuyB,GAAS1vB,KAAK,GACtCzD,KAAKqmB,EAAI,IAAIzlB,WAAWuyB,GAAS1vB,KAAK,GACtCzD,KAAKqzB,QAAU,CACnB,CACA,IAAA/N,IAAQnK,GACJ,OAAO,GAAMmY,WAAWtzB,KAAKqmB,KAAMlL,EACvC,CACA,QAAAoY,IAAYpY,GACR,OAAO8X,GAAgBjzB,KAAKqmB,KAAMlL,EACtC,CACA,SAAAqY,GACI,GAA+B,mBAApBP,GACP,MAAM,IAAIvL,GAAS,iCAC3B,CACA,IAAA+L,GACI,GAAIzzB,KAAKqzB,SAAW,IAChB,MAAM,IAAI9yB,MAAM,qDACpBP,KAAKqzB,SAAW,CACpB,CACA,YAAMK,CAAOC,EAAO,IAAI/yB,YACpBZ,KAAKqmB,QAAUrmB,KAAKslB,KAAKtlB,KAAKuI,EAAG3H,WAAW0H,KAAK,CAAC,IAAQqrB,GAC1D3zB,KAAKuI,QAAUvI,KAAKslB,KAAKtlB,KAAKuI,GACV,IAAhBorB,EAAK7yB,SAETd,KAAKqmB,QAAUrmB,KAAKslB,KAAKtlB,KAAKuI,EAAG3H,WAAW0H,KAAK,CAAC,IAAQqrB,GAC1D3zB,KAAKuI,QAAUvI,KAAKslB,KAAKtlB,KAAKuI,GAClC,CACA,UAAAqrB,CAAWD,EAAO,IAAI/yB,YAClBZ,KAAKwzB,YACLxzB,KAAKqmB,EAAIrmB,KAAKuzB,SAASvzB,KAAKuI,EAAG3H,WAAW0H,KAAK,CAAC,IAAQqrB,GACxD3zB,KAAKuI,EAAIvI,KAAKuzB,SAASvzB,KAAKuI,GACR,IAAhBorB,EAAK7yB,SAETd,KAAKqmB,EAAIrmB,KAAKuzB,SAASvzB,KAAKuI,EAAG3H,WAAW0H,KAAK,CAAC,IAAQqrB,GACxD3zB,KAAKuI,EAAIvI,KAAKuzB,SAASvzB,KAAKuI,GAChC,CACA,cAAMsrB,GACF7zB,KAAKyzB,OACL,IAAI1wB,EAAM,EACV,MAAMrB,EAAM,GACZ,KAAOqB,EAAM/C,KAAKozB,UAAU,CACxBpzB,KAAKuI,QAAUvI,KAAKslB,KAAKtlB,KAAKuI,GAC9B,MAAMurB,EAAK9zB,KAAKuI,EAAE5D,QAClBjD,EAAIya,KAAK2X,GACT/wB,GAAO/C,KAAKuI,EAAEzH,MAClB,CACA,OAAO,MAAeY,EAC1B,CACA,YAAAqyB,GACI/zB,KAAKwzB,YACLxzB,KAAKyzB,OACL,IAAI1wB,EAAM,EACV,MAAMrB,EAAM,GACZ,KAAOqB,EAAM/C,KAAKozB,UAAU,CACxBpzB,KAAKuI,EAAIvI,KAAKuzB,SAASvzB,KAAKuI,GAC5B,MAAMurB,EAAK9zB,KAAKuI,EAAE5D,QAClBjD,EAAIya,KAAK2X,GACT/wB,GAAO/C,KAAKuI,EAAEzH,MAClB,CACA,OAAO,MAAeY,EAC1B,EAEJ,SAAS8vB,GAAmB7I,GACxB,OAAOpD,GAAMoD,GAAOA,EAAM/C,GAAMxlB,CACpC,CACA,SAASmtB,GAAoB5E,GACzB,OAAOpD,GAAMoD,GAAOA,EAAM/C,GAAME,CACpC,CACA,SAASkO,GAASC,EAAQrB,EAAG7U,EAAGmW,GAAO,GACnC,MAAM,EAAE9zB,GAAMwlB,GACRS,EAAI2J,GAAaiE,GAAQ,GAC/B,IAAKzC,GAAmBnL,GACpB,OACJ,MAAM8N,EAAO1L,GAAOpC,EAAGjmB,GACjBuyB,EAAI,GAAMpnB,KAAK0gB,SAAS5F,GACxBjI,EAAI0I,GAAI6L,EAAExnB,EAAG/K,GACnB,GAAIge,IAAMmH,GACN,OACJ,MAAMmK,EAAI5I,GAAIqN,EAAOrN,GAAI8L,EAAI7U,EAAIK,EAAGhe,GAAIA,GACxC,GAAIsvB,IAAMnK,GACN,OACJ,IAAI6O,EAAM,IAAIzE,GAAUvR,EAAGsR,GACvBD,GAAYkD,EAAExnB,IAAMipB,EAAIhW,EAAI,EAAI,GAAK/d,OAAOsyB,EAAE9K,EAAIrC,IAKtD,OAJI0O,GAAQE,EAAI3C,aACZ2C,EAAMA,EAAIzC,aACVlC,GAAY,GAET,CAAE2E,MAAK3E,WAClB,CACA,SAASJ,GAAoBpa,GACzB,IAAI0T,EACJ,GAAmB,iBAAR1T,EACP0T,EAAM1T,OAEL,GAAmB,iBAARA,GAAoB5U,OAAOC,cAAc2U,IAAQA,EAAM,EACnE0T,EAAM7kB,OAAOmR,QAEZ,GAAmB,iBAARA,EAAkB,CAC9B,GAAIA,EAAInU,SAAW,EAAIqmB,GACnB,MAAM,IAAI5mB,MAAM,oCACpBooB,EAAMyI,GAAYnc,EACtB,KACK,MAAIA,aAAerU,YAMpB,MAAM,IAAIC,UAAU,8BALpB,GAAIoU,EAAInU,SAAWqmB,GACf,MAAM,IAAI5mB,MAAM,oCACpBooB,EAAM2E,GAAcrY,EAIxB,CACA,IAAKuc,GAAmB7I,GACpB,MAAM,IAAIpoB,MAAM,qCACpB,OAAOooB,CACX,CAiDA,SAAS0L,GAAS3zB,GAEd,OAAO4sB,GADO5sB,EAAMI,OAASomB,GAAWxmB,EAAMiE,MAAM,EAAGuiB,IAAYxmB,EAEvE,CACA,SAAS4zB,GAAY5zB,GACjB,MAAM6zB,EAAKF,GAAS3zB,GACd8zB,EAAK1N,GAAIyN,EAAI3O,GAAMxlB,GACzB,OAAOq0B,GAAWD,EAAKjP,GAAMgP,EAAKC,EACtC,CACA,SAASC,GAAW9L,GAChB,OAAO6J,GAAS7J,EACpB,CAwNA,GAAMpd,KAAK0hB,eAAe,GAC1B,MAAM,GAAS,CACXjoB,KAAM,GACNE,IAAqB,iBAATC,MAAqB,WAAYA,KAAOA,KAAKJ,YAASE,GAOhEyvB,GAAuB,CAAC,EACjB,GAAQ,CACjBhtB,WAAU,GACVD,WAAU,GACVJ,YAAW,GACXyf,OACA2B,UACA,iBAAAkM,CAAkBvF,GACd,IAEI,OADAC,GAAoBD,IACb,CACX,CACA,MAAOS,GACH,OAAO,CACX,CACJ,EACA+E,iBAAkBpC,GAClBqC,qBAAsBxF,GACtByF,iBAAmB9zB,IACfA,EAAOiuB,GAAYjuB,GACnB,MAAM+zB,EAAS5N,GAAW,EAC1B,GAAInmB,EAAKF,OAASi0B,GAAU/zB,EAAKF,OAAS,KACtC,MAAM,IAAIP,MAAM,uDAGpB,OAAOiyB,GADK1L,GAAIwG,GAActsB,GAAO4kB,GAAMxlB,EAAIolB,IAAOA,GAClC,EAExBte,YAAa,CAAC6D,EAAc,MACxB,GAAI,GAAO7F,IACP,OAAO,GAAOA,IAAI8F,gBAAgB,IAAIpK,WAAWmK,IAEhD,GAAI,GAAO/F,KAAM,CAClB,MAAM,YAAEkC,GAAgB,GAAOlC,KAC/B,OAAOpE,WAAW0H,KAAKpB,EAAY6D,GACvC,CAEI,MAAM,IAAIxK,MAAM,oDACpB,EAEJy0B,iBAAkB,IAAM,GAAMF,iBAAiB,GAAM5tB,YAAYigB,GAAW,IAC5E,UAAA8N,CAAW3J,EAAa,EAAGY,EAAQ,GAAM3gB,MACrC,MAAM2pB,EAAShJ,IAAU,GAAM3gB,KAAO2gB,EAAQ,IAAI,GAAMA,EAAM/gB,EAAG+gB,EAAMrE,GAGvE,OAFAqN,EAAOjI,eAAe3B,GACtB4J,EAAOjJ,SAASvG,IACTwP,CACX,EACA7vB,OAAQgE,SAAU8rB,KACd,GAAI,GAAOjwB,IAAK,CACZ,MAAMzC,QAAe,GAAOyC,IAAIkwB,OAAO3wB,OAAO,UAAW,MAAe0wB,IACxE,OAAO,IAAIv0B,WAAW6B,EAC1B,CACK,GAAI,GAAOuC,KAAM,CAClB,MAAM,WAAEqwB,GAAe,GAAOrwB,KACxBhE,EAAOq0B,EAAW,UAExB,OADAF,EAASjmB,SAAS0jB,GAAM5xB,EAAK4B,OAAOgwB,KAC7BhyB,WAAW0H,KAAKtH,EAAKyD,SAChC,CAEI,MAAM,IAAIlE,MAAM,+CACpB,EAEJ+yB,WAAYjqB,MAAO4L,KAAQkgB,KACvB,GAAI,GAAOjwB,IAAK,CACZ,MAAMowB,QAAa,GAAOpwB,IAAIkwB,OAAOG,UAAU,MAAOtgB,EAAK,CAAEwL,KAAM,OAAQzf,KAAM,CAAEyf,KAAM,aAAe,EAAO,CAAC,SAC1G9V,EAAU,MAAewqB,GACzB1yB,QAAe,GAAOyC,IAAIkwB,OAAOI,KAAK,OAAQF,EAAM3qB,GAC1D,OAAO,IAAI/J,WAAW6B,EAC1B,CACK,GAAI,GAAOuC,KAAM,CAClB,MAAM,WAAEywB,GAAe,GAAOzwB,KACxBhE,EAAOy0B,EAAW,SAAUxgB,GAElC,OADAkgB,EAASjmB,SAAS0jB,GAAM5xB,EAAK4B,OAAOgwB,KAC7BhyB,WAAW0H,KAAKtH,EAAKyD,SAChC,CAEI,MAAM,IAAIlE,MAAM,oDACpB,EAEJm1B,gBAAYzwB,EACZ0wB,oBAAgB1wB,EAChB2wB,WAAYvsB,MAAOiQ,KAAQ6b,KACvB,IAAIU,EAAOnB,GAAqBpb,GAChC,QAAarU,IAAT4wB,EAAoB,CACpB,MAAMC,QAAa,GAAMzwB,OAAOzE,WAAW0H,KAAKgR,GAAM7T,GAAMA,EAAE6F,WAAW,MACzEuqB,EAAO,GAAYC,EAAMA,GACzBpB,GAAqBpb,GAAOuc,CAChC,CACA,OAAO,GAAMxwB,OAAOwwB,KAASV,EAAS,EAE1CY,eAAgB,CAACzc,KAAQ6b,KACrB,GAA2B,mBAAhBnC,GACP,MAAM,IAAItL,GAAS,+CACvB,IAAImO,EAAOnB,GAAqBpb,GAChC,QAAarU,IAAT4wB,EAAoB,CACpB,MAAMC,EAAO9C,GAAYpyB,WAAW0H,KAAKgR,GAAM7T,GAAMA,EAAE6F,WAAW,MAClEuqB,EAAO,GAAYC,EAAMA,GACzBpB,GAAqBpb,GAAOuc,CAChC,CACA,OAAO7C,GAAY6C,KAASV,EAAS,EAEzCa,eAAgBpO,IAEpBhmB,OAAOq0B,iBAAiB,GAAO,CAC3BP,WAAY,CACRQ,cAAc,EACd1xB,IAAG,IACQwuB,GAEX,GAAA7vB,CAAIgzB,GACKnD,KACDA,GAAcmD,EACtB,GAEJR,eAAgB,CACZO,cAAc,EACd1xB,IAAG,IACQyuB,GAEX,GAAA9vB,CAAIgzB,GACKlD,KACDA,GAAkBkD,EAC1B,KChsCR,MAAMC,GAAmB,GCAlB,SAASC,GAAkBjH,GAC9B,MAAMkH,EAAyC,iBAAflH,EAA0B,EAAWA,GAAcA,EACnF,GAA+B,IAA3BkH,EAAiBx1B,QAA2C,IAA3Bw1B,EAAiBx1B,OAClD,MAAM,IAAIP,MAAM,kGAAkG+1B,EAAiBx1B,UAEvI,GAA+B,IAA3Bw1B,EAAiBx1B,QAAyC,IAAzBw1B,EAAiB,IAClD,MAAM,IAAI/1B,MAAM,uGAEpB,OAAO+1B,CACX,CCNA,MAAMC,GAAM,IAAI31B,WAAW,CAAC,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,IACzE41B,GAAK51B,WAAW0H,KAAK,CAAExH,OAAQ,KAAM,CAAC6e,EAAGjc,IAAMA,IAC/C+yB,GAAKD,GAAGliB,KAAK5Q,IAAO,EAAIA,EAAI,GAAK,KACvC,IAAIgzB,GAAO,CAACF,IACRG,GAAO,CAACF,IACZ,IAAK,IAAI/yB,EAAI,EAAGA,EAAI,EAAGA,IACnB,IAAK,IAAIsF,IAAK,CAAC0tB,GAAMC,IACjB3tB,EAAEmT,KAAKnT,EAAEtF,GAAG4Q,KAAK+R,GAAMkQ,GAAIlQ,MACnC,MAAMuQ,GAAS,CACX,CAAC,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,GACtD,CAAC,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,GACtD,CAAC,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,GACtD,CAAC,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,GACtD,CAAC,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,IACxDtiB,KAAK5Q,GAAM,IAAI9C,WAAW8C,KACtBmzB,GAAUH,GAAKpiB,KAAI,CAACwiB,EAAKpzB,IAAMozB,EAAIxiB,KAAKtL,GAAM4tB,GAAOlzB,GAAGsF,OACxD+tB,GAAUJ,GAAKriB,KAAI,CAACwiB,EAAKpzB,IAAMozB,EAAIxiB,KAAKtL,GAAM4tB,GAAOlzB,GAAGsF,OACxDguB,GAAK,IAAIrxB,YAAY,CAAC,EAAY,WAAY,WAAY,WAAY,aACtEsxB,GAAK,IAAItxB,YAAY,CAAC,WAAY,WAAY,WAAY,WAAY,IAEtEuxB,GAAO,CAAChvB,EAAMC,IAAWD,GAAQC,EAAUD,IAAU,GAAKC,EAEhE,SAASkjB,GAAE8L,EAAOhsB,EAAG0c,EAAGC,GACpB,OAAc,IAAVqP,EACOhsB,EAAI0c,EAAIC,EACA,IAAVqP,EACGhsB,EAAI0c,GAAO1c,EAAI2c,EACR,IAAVqP,GACGhsB,GAAK0c,GAAKC,EACH,IAAVqP,EACGhsB,EAAI2c,EAAMD,GAAKC,EAEhB3c,GAAK0c,GAAKC,EACzB,CAEA,MAAMsP,GAAM,IAAIzxB,YAAY,IACrB,MAAM0xB,WAAkBr1B,GAC3B,WAAAI,GACIG,MAAM,GAAI,GAAI,GAAG,GACjBvC,KAAKs3B,GAAK,WACVt3B,KAAKu3B,IAAK,UACVv3B,KAAKw3B,IAAK,WACVx3B,KAAKy3B,GAAK,UACVz3B,KAAK03B,IAAK,UACd,CACA,GAAAlzB,GACI,MAAM,GAAE8yB,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,GAAO13B,KAC/B,MAAO,CAACs3B,EAAIC,EAAIC,EAAIC,EAAIC,EAC5B,CACA,GAAAv0B,CAAIm0B,EAAIC,EAAIC,EAAIC,EAAIC,GAChB13B,KAAKs3B,GAAU,EAALA,EACVt3B,KAAKu3B,GAAU,EAALA,EACVv3B,KAAKw3B,GAAU,EAALA,EACVx3B,KAAKy3B,GAAU,EAALA,EACVz3B,KAAK03B,GAAU,EAALA,CACd,CACA,OAAAr0B,CAAQX,EAAM6D,GACV,IAAK,IAAI7C,EAAI,EAAGA,EAAI,GAAIA,IAAK6C,GAAU,EACnC6wB,GAAI1zB,GAAKhB,EAAK8D,UAAUD,GAAQ,GAEpC,IAAIoxB,EAAe,EAAV33B,KAAKs3B,GAAQM,EAAKD,EAAIE,EAAe,EAAV73B,KAAKu3B,GAAQO,EAAKD,EAAIE,EAAe,EAAV/3B,KAAKw3B,GAAQQ,EAAKD,EAAIE,EAAe,EAAVj4B,KAAKy3B,GAAQS,EAAKD,EAAIE,EAAe,EAAVn4B,KAAK03B,GAAQU,EAAKD,EAGvI,IAAK,IAAIhB,EAAQ,EAAGA,EAAQ,EAAGA,IAAS,CACpC,MAAMkB,EAAS,EAAIlB,EACbmB,EAAMtB,GAAGG,GAAQoB,EAAMtB,GAAGE,GAC1BqB,EAAK9B,GAAKS,GAAQsB,EAAK9B,GAAKQ,GAC5BrD,EAAK+C,GAAQM,GAAQuB,EAAK3B,GAAQI,GACxC,IAAK,IAAIzzB,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,MAAMi1B,EAAMzB,GAAKS,EAAKtM,GAAE8L,EAAOU,EAAIE,EAAIE,GAAMb,GAAIoB,EAAG90B,IAAM40B,EAAKxE,EAAGpwB,IAAMy0B,EAAM,EAC9ER,EAAKQ,EAAIA,EAAKF,EAAIA,EAAoB,EAAff,GAAKa,EAAI,IAASA,EAAKF,EAAIA,EAAKc,CAC3D,CAEA,IAAK,IAAIj1B,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,MAAMk1B,EAAM1B,GAAKU,EAAKvM,GAAEgN,EAAQP,EAAIE,EAAIE,GAAMd,GAAIqB,EAAG/0B,IAAM60B,EAAKG,EAAGh1B,IAAM00B,EAAM,EAC/ER,EAAKQ,EAAIA,EAAKF,EAAIA,EAAoB,EAAfhB,GAAKc,EAAI,IAASA,EAAKF,EAAIA,EAAKc,CAC3D,CACJ,CAEA54B,KAAKmD,IAAKnD,KAAKu3B,GAAKQ,EAAKG,EAAM,EAAIl4B,KAAKw3B,GAAKS,EAAKG,EAAM,EAAIp4B,KAAKy3B,GAAKU,EAAKP,EAAM,EAAI53B,KAAK03B,GAAKC,EAAKG,EAAM,EAAI93B,KAAKs3B,GAAKO,EAAKG,EAAM,EACvI,CACA,UAAAz0B,GACI6zB,GAAI3zB,KAAK,EACb,CACA,OAAAmB,GACI5E,KAAKuB,WAAY,EACjBvB,KAAKyC,OAAOgB,KAAK,GACjBzD,KAAKmD,IAAI,EAAG,EAAG,EAAG,EAAG,EACzB,EAMG,MAAM01B,GAAY5xB,IAAgB,IAAM,IAAIowB,KClG7CyB,GAAah1B,OAAO,GAAK,GAAK,GAC9BD,GAAOC,OAAO,IAEb,SAASi1B,GAAQ34B,EAAG44B,GAAK,GAC5B,OAAIA,EACO,CAAE90B,EAAG7D,OAAOD,EAAI04B,IAAa30B,EAAG9D,OAAQD,GAAKyD,GAAQi1B,KACzD,CAAE50B,EAAsC,EAAnC7D,OAAQD,GAAKyD,GAAQi1B,IAAiB30B,EAA4B,EAAzB9D,OAAOD,EAAI04B,IACpE,CAqCA,MAeA,GAnDO,SAAeG,EAAKD,GAAK,GAC5B,IAAIE,EAAK,IAAIvzB,YAAYszB,EAAIn4B,QACzBq4B,EAAK,IAAIxzB,YAAYszB,EAAIn4B,QAC7B,IAAK,IAAI4C,EAAI,EAAGA,EAAIu1B,EAAIn4B,OAAQ4C,IAAK,CACjC,MAAM,EAAEQ,EAAC,EAAEC,GAAM40B,GAAQE,EAAIv1B,GAAIs1B,IAChCE,EAAGx1B,GAAIy1B,EAAGz1B,IAAM,CAACQ,EAAGC,EACzB,CACA,MAAO,CAAC+0B,EAAIC,EAChB,EA2CA,GAxCc,CAACj1B,EAAGC,EAAGurB,IAAMxrB,IAAMwrB,EAwCjC,GAvCc,CAACxrB,EAAGC,EAAGurB,IAAOxrB,GAAM,GAAKwrB,EAAOvrB,IAAMurB,EAuCpD,GArCe,CAACxrB,EAAGC,EAAGurB,IAAOxrB,IAAMwrB,EAAMvrB,GAAM,GAAKurB,EAqCpD,GApCe,CAACxrB,EAAGC,EAAGurB,IAAOxrB,GAAM,GAAKwrB,EAAOvrB,IAAMurB,EAoCrD,GAlCe,CAACxrB,EAAGC,EAAGurB,IAAOxrB,GAAM,GAAKwrB,EAAOvrB,IAAOurB,EAAI,GAkC1D,GAjCe,CAACxrB,EAAGC,EAAGurB,IAAOxrB,IAAOwrB,EAAI,GAAQvrB,GAAM,GAAKurB,EAiC3D,GApBO,SAAawJ,EAAIC,EAAIC,EAAIC,GAC5B,MAAMl1B,GAAKg1B,IAAO,IAAME,IAAO,GAC/B,MAAO,CAAEn1B,EAAIg1B,EAAKE,GAAOj1B,EAAI,GAAK,GAAM,GAAM,EAAGA,EAAO,EAAJA,EACxD,EAiBA,GAfc,CAACg1B,EAAIE,EAAIC,KAAQH,IAAO,IAAME,IAAO,IAAMC,IAAO,GAehE,GAdc,CAACC,EAAKL,EAAIE,EAAII,IAAQN,EAAKE,EAAKI,GAAOD,EAAM,GAAK,GAAM,GAAM,EAc5E,GAbc,CAACJ,EAAIE,EAAIC,EAAIG,KAAQN,IAAO,IAAME,IAAO,IAAMC,IAAO,IAAMG,IAAO,GAajF,GAZc,CAACF,EAAKL,EAAIE,EAAII,EAAIE,IAAQR,EAAKE,EAAKI,EAAKE,GAAOH,EAAM,GAAK,GAAM,GAAM,EAYrF,GAVc,CAACA,EAAKL,EAAIE,EAAII,EAAIE,EAAIC,IAAQT,EAAKE,EAAKI,EAAKE,EAAKC,GAAOJ,EAAM,GAAK,GAAM,GAAM,EAU9F,GAXc,CAACJ,EAAIE,EAAIC,EAAIG,EAAIG,KAAQT,IAAO,IAAME,IAAO,IAAMC,IAAO,IAAMG,IAAO,IAAMG,IAAO,IC3C3FC,GAAWC,IAAa,GAAU,CACrC,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,sBACpExlB,KAAIlU,GAAK0D,OAAO1D,MAEZ25B,GAAa,IAAIp0B,YAAY,IAC7Bq0B,GAAa,IAAIr0B,YAAY,IAC5B,MAAMs0B,WAAej4B,GACxB,WAAAI,GACIG,MAAM,IAAK,GAAI,IAAI,GAKnBvC,KAAKk5B,GAAK,WACVl5B,KAAKm5B,IAAK,UACVn5B,KAAKo5B,IAAK,WACVp5B,KAAKq5B,IAAK,WACVr5B,KAAKw5B,GAAK,WACVx5B,KAAKs5B,IAAK,SACVt5B,KAAK05B,IAAK,WACV15B,KAAKy5B,GAAK,WACVz5B,KAAK25B,GAAK,WACV35B,KAAK45B,IAAK,WACV55B,KAAKk6B,IAAK,WACVl6B,KAAKm6B,GAAK,UACVn6B,KAAKo6B,GAAK,UACVp6B,KAAKq6B,IAAK,SACVr6B,KAAKs6B,GAAK,WACVt6B,KAAKu6B,GAAK,SACd,CAEA,GAAA/1B,GACI,MAAM,GAAE00B,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEG,EAAE,GAAEF,EAAE,GAAEI,EAAE,GAAED,EAAE,GAAEE,EAAE,GAAEC,EAAE,GAAEM,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,GAAOv6B,KAC3E,MAAO,CAACk5B,EAAIC,EAAIC,EAAIC,EAAIG,EAAIF,EAAII,EAAID,EAAIE,EAAIC,EAAIM,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EACxE,CAEA,GAAAp3B,CAAI+1B,EAAIC,EAAIC,EAAIC,EAAIG,EAAIF,EAAII,EAAID,EAAIE,EAAIC,EAAIM,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAC5Dv6B,KAAKk5B,GAAU,EAALA,EACVl5B,KAAKm5B,GAAU,EAALA,EACVn5B,KAAKo5B,GAAU,EAALA,EACVp5B,KAAKq5B,GAAU,EAALA,EACVr5B,KAAKw5B,GAAU,EAALA,EACVx5B,KAAKs5B,GAAU,EAALA,EACVt5B,KAAK05B,GAAU,EAALA,EACV15B,KAAKy5B,GAAU,EAALA,EACVz5B,KAAK25B,GAAU,EAALA,EACV35B,KAAK45B,GAAU,EAALA,EACV55B,KAAKk6B,GAAU,EAALA,EACVl6B,KAAKm6B,GAAU,EAALA,EACVn6B,KAAKo6B,GAAU,EAALA,EACVp6B,KAAKq6B,GAAU,EAALA,EACVr6B,KAAKs6B,GAAU,EAALA,EACVt6B,KAAKu6B,GAAU,EAALA,CACd,CACA,OAAAl3B,CAAQX,EAAM6D,GAEV,IAAK,IAAI7C,EAAI,EAAGA,EAAI,GAAIA,IAAK6C,GAAU,EACnCwzB,GAAWr2B,GAAKhB,EAAK8D,UAAUD,GAC/ByzB,GAAWt2B,GAAKhB,EAAK8D,UAAWD,GAAU,GAE9C,IAAK,IAAI7C,EAAI,GAAIA,EAAI,GAAIA,IAAK,CAE1B,MAAM82B,EAA4B,EAArBT,GAAWr2B,EAAI,IACtB+2B,EAA4B,EAArBT,GAAWt2B,EAAI,IACtBg3B,EAAM,GAAWF,EAAMC,EAAM,GAAK,GAAWD,EAAMC,EAAM,GAAK,GAAUD,EAAMC,EAAM,GACpFE,EAAM,GAAWH,EAAMC,EAAM,GAAK,GAAWD,EAAMC,EAAM,GAAK,GAAUD,EAAMC,EAAM,GAEpFG,EAA0B,EAApBb,GAAWr2B,EAAI,GACrBm3B,EAA0B,EAApBb,GAAWt2B,EAAI,GACrBo3B,EAAM,GAAWF,EAAKC,EAAK,IAAM,GAAWD,EAAKC,EAAK,IAAM,GAAUD,EAAKC,EAAK,GAChFE,EAAM,GAAWH,EAAKC,EAAK,IAAM,GAAWD,EAAKC,EAAK,IAAM,GAAUD,EAAKC,EAAK,GAEhFG,EAAO,GAAUL,EAAKI,EAAKf,GAAWt2B,EAAI,GAAIs2B,GAAWt2B,EAAI,KAC7Du3B,EAAO,GAAUD,EAAMN,EAAKI,EAAKf,GAAWr2B,EAAI,GAAIq2B,GAAWr2B,EAAI,KACzEq2B,GAAWr2B,GAAY,EAAPu3B,EAChBjB,GAAWt2B,GAAY,EAAPs3B,CACpB,CACA,IAAI,GAAE9B,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEG,EAAE,GAAEF,EAAE,GAAEI,EAAE,GAAED,EAAE,GAAEE,EAAE,GAAEC,EAAE,GAAEM,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,EAAE,GAAEC,GAAOv6B,KAEzE,IAAK,IAAI0D,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAEzB,MAAMw3B,EAAU,GAAWvB,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAC/EuB,EAAU,GAAWxB,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAE/EwB,EAAQzB,EAAKO,GAAQP,EAAKS,EAI1BiB,EAAO,GAAUd,EAAIY,EAHbvB,EAAKO,GAAQP,EAAKS,EAGUP,GAAUp2B,GAAIs2B,GAAWt2B,IAC7D43B,EAAM,GAAUD,EAAMf,EAAIY,EAASE,EAAMvB,GAAUn2B,GAAIq2B,GAAWr2B,IAClE63B,EAAa,EAAPF,EAENG,EAAU,GAAWtC,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAC/EsC,EAAU,GAAWvC,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAAM,GAAWD,EAAIC,EAAI,IAC/EuC,EAAQxC,EAAKE,EAAOF,EAAKM,EAAOJ,EAAKI,EACrCmC,EAAQxC,EAAKE,EAAOF,EAAKG,EAAOD,EAAKC,EAC3CgB,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALP,EACLQ,EAAU,EAALP,IACF11B,EAAGy1B,EAAIx1B,EAAGy1B,GAAO,GAAa,EAALF,EAAa,EAALD,EAAc,EAAN6B,EAAe,EAANC,IACrD7B,EAAU,EAALF,EACLC,EAAU,EAALH,EACLE,EAAU,EAALJ,EACLE,EAAU,EAALD,EACLD,EAAU,EAALF,EACLG,EAAU,EAALF,EACL,MAAMyC,EAAM,GAAUL,EAAKE,EAASE,GACpCzC,EAAK,GAAU0C,EAAKN,EAAKE,EAASE,GAClCvC,EAAW,EAANyC,CACT,GAEG13B,EAAGg1B,EAAI/0B,EAAGg1B,GAAO,GAAkB,EAAVn5B,KAAKk5B,GAAkB,EAAVl5B,KAAKm5B,GAAa,EAALD,EAAa,EAALC,MAC3Dj1B,EAAGk1B,EAAIj1B,EAAGk1B,GAAO,GAAkB,EAAVr5B,KAAKo5B,GAAkB,EAAVp5B,KAAKq5B,GAAa,EAALD,EAAa,EAALC,MAC3Dn1B,EAAGs1B,EAAIr1B,EAAGm1B,GAAO,GAAkB,EAAVt5B,KAAKw5B,GAAkB,EAAVx5B,KAAKs5B,GAAa,EAALE,EAAa,EAALF,MAC3Dp1B,EAAGw1B,EAAIv1B,EAAGs1B,GAAO,GAAkB,EAAVz5B,KAAK05B,GAAkB,EAAV15B,KAAKy5B,GAAa,EAALC,EAAa,EAALD,MAC3Dv1B,EAAGy1B,EAAIx1B,EAAGy1B,GAAO,GAAkB,EAAV55B,KAAK25B,GAAkB,EAAV35B,KAAK45B,GAAa,EAALD,EAAa,EAALC,MAC3D11B,EAAGg2B,EAAI/1B,EAAGg2B,GAAO,GAAkB,EAAVn6B,KAAKk6B,GAAkB,EAAVl6B,KAAKm6B,GAAa,EAALD,EAAa,EAALC,MAC3Dj2B,EAAGk2B,EAAIj2B,EAAGk2B,GAAO,GAAkB,EAAVr6B,KAAKo6B,GAAkB,EAAVp6B,KAAKq6B,GAAa,EAALD,EAAa,EAALC,MAC3Dn2B,EAAGo2B,EAAIn2B,EAAGo2B,GAAO,GAAkB,EAAVv6B,KAAKs6B,GAAkB,EAAVt6B,KAAKu6B,GAAa,EAALD,EAAa,EAALC,IAC9Dv6B,KAAKmD,IAAI+1B,EAAIC,EAAIC,EAAIC,EAAIG,EAAIF,EAAII,EAAID,EAAIE,EAAIC,EAAIM,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EACzE,CACA,UAAAh3B,GACIw2B,GAAWt2B,KAAK,GAChBu2B,GAAWv2B,KAAK,EACpB,CACA,OAAAmB,GACI5E,KAAKyC,OAAOgB,KAAK,GACjBzD,KAAKmD,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC1D,EAEJ,MAAM04B,WAAmB5B,GACrB,WAAA73B,GACIG,QAEAvC,KAAKk5B,IAAK,WACVl5B,KAAKm5B,GAAK,UACVn5B,KAAKo5B,GAAK,WACVp5B,KAAKq5B,IAAK,WACVr5B,KAAKw5B,GAAK,UACVx5B,KAAKs5B,GAAK,UACVt5B,KAAK05B,GAAK,WACV15B,KAAKy5B,GAAK,WACVz5B,KAAK25B,GAAK,UACV35B,KAAK45B,GAAK,WACV55B,KAAKk6B,GAAK,WACVl6B,KAAKm6B,GAAK,SACVn6B,KAAKo6B,GAAK,WACVp6B,KAAKq6B,GAAK,WACVr6B,KAAKs6B,GAAK,UACVt6B,KAAKu6B,IAAK,WACVv6B,KAAKkB,UAAY,EACrB,EAEJ,MAAM46B,WAAmB7B,GACrB,WAAA73B,GACIG,QAEAvC,KAAKk5B,GAAK,UACVl5B,KAAKm5B,IAAK,SACVn5B,KAAKo5B,IAAK,WACVp5B,KAAKq5B,IAAK,UACVr5B,KAAKw5B,GAAK,UACVx5B,KAAKs5B,GAAK,WACVt5B,KAAK05B,IAAK,WACV15B,KAAKy5B,GAAK,WACVz5B,KAAK25B,IAAK,WACV35B,KAAK45B,IAAK,WACV55B,KAAKk6B,IAAK,WACVl6B,KAAKm6B,GAAK,WACVn6B,KAAKo6B,GAAK,UACVp6B,KAAKq6B,GAAK,UACVr6B,KAAKs6B,GAAK,UACVt6B,KAAKu6B,IAAK,WACVv6B,KAAKkB,UAAY,EACrB,EAEJ,MAAM66B,WAAe9B,GACjB,WAAA73B,GACIG,QAEAvC,KAAKk5B,IAAK,UACVl5B,KAAKm5B,IAAK,WACVn5B,KAAKo5B,GAAK,WACVp5B,KAAKq5B,GAAK,UACVr5B,KAAKw5B,IAAK,WACVx5B,KAAKs5B,GAAK,UACVt5B,KAAK05B,GAAK,UACV15B,KAAKy5B,IAAK,UACVz5B,KAAK25B,GAAK,WACV35B,KAAK45B,IAAK,QACV55B,KAAKk6B,IAAK,WACVl6B,KAAKm6B,GAAK,WACVn6B,KAAKo6B,IAAK,UACVp6B,KAAKq6B,GAAK,WACVr6B,KAAKs6B,GAAK,WACVt6B,KAAKu6B,IAAK,WACVv6B,KAAKkB,UAAY,EACrB,EAEkB+F,IAAgB,IAAM,IAAIgzB,KACtBhzB,IAAgB,IAAM,IAAI40B,KAD7C,MAEMG,GAAa/0B,IAAgB,IAAM,IAAI60B,KAC9B70B,IAAgB,IAAM,IAAI80B,8BC/NhD,MAAME,GAAqB,IAAI/kB,IACxB,SAASglB,GAAOC,EAAcr6B,GACjC,MAAMs6B,EAAUH,GAAmBz3B,IAAI23B,GACvC,QAAgBl3B,IAAZm3B,EACA,OAAOA,EAAQt6B,GAEnB,MAAMu6B,EAXV,SAA2BF,GACvB,MAAMG,EAAa16B,OAAOuZ,OAAOghB,GAAcI,QAAOh0B,GAAkB,iBAANA,IAC5Di0B,EAAe,IAAIplB,IAAIklB,GAC7B,OAAQx6B,GAAU06B,EAAavgB,IAAIna,EACvC,CAOuB26B,CAAkBN,GAErC,OADAF,GAAmB94B,IAAIg5B,EAAcE,GAC9BH,GAAOC,EAAcr6B,EAChC,CACO,MAAM,GACT,WAAAM,CAAY1B,GACRV,KAAK08B,SAAW,EAChB18B,KAAK6L,OAA0B,iBAAVnL,EAAqB,EAAWA,GAASA,CAClE,CACA,SAAAi8B,CAAU77B,GACN,MAAM4B,EAAO1C,KAAK6L,OAAOzI,SAASpD,KAAK08B,SAAU18B,KAAK08B,SAAW57B,GAEjE,OADAd,KAAK08B,UAAY57B,EACV4B,CACX,CACA,YAAAk6B,GACI,OfaqB/wB,EebD7L,KAAK28B,UAAU,IAAI,GfclB,GAAK,GACL,MAArB9wB,EAAOtF,GACc,IAArBsF,EAAOtF,GACPsF,EAAOtF,GAJR,IAAsBsF,CeZzB,CACA,SAAAgxB,GACI,OAAiB78B,KAAK28B,UAAU,GAAI,EACxC,CACA,YAAAG,GACI,QfjBqBjxB,EeiBD7L,KAAK28B,UAAU,IfhBd,EegBkB,IfhBZ,EAAK9wB,EAAOtF,MAAiB,EADzD,IAAsBsF,CekBzB,CACA,aAAAkxB,CAAcj8B,GACV,MACMgI,EAAM,EADE9I,KAAK28B,UAAU77B,GAAQ6D,QAAQq4B,WAE7C,OAAOl5B,OAAO,KAAKgF,IACvB,CACA,aAAAm0B,CAAcn8B,GACV,MACMgI,EAAM,EADE9I,KAAK28B,UAAU77B,IAE7B,OAAOgD,OAAO,KAAKgF,IACvB,CACA,cAAIo0B,GACA,OAAOl9B,KAAK08B,QAChB,CACA,cAAIQ,CAAW/G,GACXn2B,KAAK08B,SAAWvG,CACpB,CACA,iBAAIgH,GACA,OAAOn9B,KAAK6L,MAChB,CACA,aAAAuxB,CAAcjB,EAAckB,GACxB,MAAM1U,EAAM3oB,KAAK68B,YACjB,GAAIX,GAAOC,EAAcxT,GACrB,OAAOA,EAEX,MAAM0U,EAA0B1U,EACpC,EC5DG,IAAI,GAkBA2U,GAjBAC,GAmCJ,SAASC,GAAkB5hB,GAC9B,OAAO0hB,GAAgB1hB,EAC3B,EArCW2hB,GAgBR,KAAgB,GAAc,CAAC,IAfb,IAAI,MACrBA,GAAkB,KAAI,OACtBA,GAAoB,OAAI,SACxBA,GAAsB,SAAI,OAC1BA,GAAuB,UAAI,QAC3BA,GAA+B,kBAAI,UACnCA,GAA+B,kBAAI,WACnCA,GAAwB,WAAI,KAC5BA,GAAyB,YAAI,MAC7BA,GAA0B,aAAI,OAC9BA,GAA0B,aAAI,OAC9BA,GAAkB,KAAI,OACtBA,GAAmB,MAAI,QACvBA,GAAyB,YAAI,QAC7BA,GAAwB,WAAI,OAGhC,SAAWD,GACPA,EAAgBA,EAAqB,IAAI,GAAK,MAC9CA,EAAgBA,EAAsB,KAAI,GAAK,OAC/CA,EAAgBA,EAAwB,OAAI,GAAK,SACjDA,EAAgBA,EAAsB,KAAI,GAAK,OAC/CA,EAAgBA,EAAuB,MAAI,GAAK,QAChDA,EAAgBA,EAAyB,QAAI,GAAK,UAClDA,EAAgBA,EAA0B,SAAI,GAAK,WACnDA,EAAgBA,EAAoB,GAAI,GAAK,KAC7CA,EAAgBA,EAAqB,IAAI,GAAK,MAC9CA,EAAgBA,EAAsB,KAAI,GAAK,OAC/CA,EAAgBA,EAAsB,KAAI,IAAM,OAChDA,EAAgBA,EAAsB,KAAI,IAAM,OAChDA,EAAgBA,EAAuB,MAAI,IAAM,QACjDA,EAAgBA,EAAuB,MAAI,IAAM,QACjDA,EAAgBA,EAAsB,KAAI,IAAM,MACnD,CAhBD,CAgBGA,KAAoBA,GAAkB,CAAC,ICjC1C,MAAMG,GAAW35B,OAAO,sCAClB45B,GAAW55B,OAAO,GAClB65B,GAAW75B,OAAO,sCAClB85B,GAAW95B,OAAO,4CACX,GAAShC,IACG,iBAAVA,GAAsBA,EAAM2N,cAAcouB,WAAW,QAC5D/7B,EAAQ0d,EAAkB,EAAW1d,KAErC,EAAWA,EAAOlB,cAClBkB,EAAQ0d,EAAkB1d,IAC9B,MAAMg8B,EAAS,EAAYh8B,GAC3B,GAAIg8B,EAASH,GACT,MAAM,IAAIve,WAAW,4DAA4Due,MAEhF,GAAIG,EAASF,GACd,MAAM,IAAIxe,WAAW,yDAAyDwe,MAElF,MAAO,CAAEhiB,KAAM,GAAYmiB,IAAKj8B,MAAOg8B,EAAQ,EAEtC,GAAUh8B,IACnB,MAAMg8B,EAAS,EAAYh8B,GAC3B,GAAIg8B,EAASJ,GACT,MAAM,IAAIte,WAAW,iEAEpB,GAAI0e,EAASL,GACd,MAAM,IAAIre,WAAW,0DAA0Dqe,MAEnF,MAAO,CAAE7hB,KAAM,GAAYoiB,KAAMl8B,MAAOg8B,EAAQ,EC3BvC,GAAYr7B,IACrB,GAAIA,EAAOsF,WAAa,QACpB,MAAM,IAAIxH,MAAM,4DAEpB,MAAO,CAAEqb,KAAM,GAAYvF,OAAQvU,MAAO,EAAWW,GAAS,EAErD,GAAsBiG,GAAQ,GAAS,EAAYA,ICPnD,GAAS,KAAM,CAAGkT,KAAM,GAAYqiB,WACpC,GAAU,KAAM,CAAGriB,KAAM,GAAYsiB,YCF3C,IAAI,GACAC,GCkBJ,SAAS,GAAahjB,EAAQijB,GACjC,MAAO,CACHxiB,KAAM,GAAeyiB,mBACrBD,kBAAmBA,GAAqB,EACxCjjB,SAER,CACO,SAAS,GAAuBqU,GAEnC,GADe,EAAWA,GAAWznB,YACvB,EACV,MAAMxH,MAAM,qBAEhB,MAAO,CACHqb,KAAM,GAAe0iB,iBACrBz7B,KAAM2sB,EAEd,CA2GO,SAAS,GAAe+O,EAASH,EAAmBI,GACvD,MAAMC,EAAeL,GAAqB,EACpCM,EAAYF,GAAkBjb,EACpC,GAAI,GAAsBgb,EAASG,GAC/B,MAAM,IAAIn+B,MAAM,uCAAuCm+B,KAE3D,MAAO,CACH9iB,KAAM,GAAe+iB,qBACrBJ,UACAH,kBAAmBK,EACnBD,eAAgBE,EAExB,CASO,SAAS,GAAcE,GAC1B,MAAMC,GAAc,QAAiBD,GACrC,MAAO,CACHhjB,KAAM,GAAekjB,QACrB/wB,QAAS8wB,EAAY,GACrBE,QAASF,EAAY,GAE7B,CAmBO,SAAS,GAA2BG,EAAgBC,GACvD,MAAO,CACHD,iBACApjB,KAAM,GAAesjB,qBACrBD,WAER,CC5LO,SAASE,GAAsBpxB,EAASqxB,EAAUC,EAASC,GAC9D,GAA0B,IAAtBA,EAAWx+B,OACX,MAAMP,MAAM,iCAEhB,KAAI6+B,IAAa,EAAgBG,OAASH,IAAa,EAAgBI,QACzC,IAAtBF,EAAWx+B,QAA4B,IAAZu+B,GAC3B,MAAM9+B,MAAM,+CAGpB,IAAI6+B,IAAa,EAAgBI,QAC7BJ,IAAa,EAAgBK,OAC7BL,IAAa,EAAgBM,sBACxBJ,EAAWhrB,KAAI0T,GAAKA,EAAEnlB,OAAMiH,MAAM,IACnC,MAAMvJ,MAAM,6CAGpB,OAAQ6+B,GACJ,KAAK,EAAgBG,MACjB,OAAOI,GAAuB5xB,EAAS6xB,GAAUN,EAAW,GAAGz8B,OACnE,KAAK,EAAgB28B,OACjB,OAAOG,GAAuB5xB,EAAS8xB,GAAWP,EAAW,GAAGz8B,OACpE,KAAK,EAAgBi9B,KACrB,KAAK,EAAgBC,kBACjB,OAAOJ,GAAuB5xB,EAASiyB,GAASX,EAASC,EAAWhrB,IAAI2rB,MAC5E,KAAK,EAAgBR,MACrB,KAAK,EAAgBC,mBACjB,OAAOC,GAAuB5xB,EAASmyB,GAAUb,EAASC,EAAWhrB,IAAI2rB,MAErF,CACO,SAASN,GAAuB5xB,EAAS/M,GAC5C,MAAO,CAAE4a,KAAM,GAAekjB,QAAS/wB,UAASgxB,QAAS/9B,EAC7D,CACO,SAAS,GAAgBm/B,GAC5B,OAAO,QAAWA,EAAQpyB,QAASoyB,EAAQpB,QAC/C,CAgBO,SAASqB,GAAiB1iB,GAC7B,MAAO2iB,EAAcC,EAAmBC,GAAkB7iB,EAAG8iB,MAAM,SDiGhE,IAAqBC,EAAeC,EAAcC,EC/FrD,OD+FwBF,EChGEJ,EDgGaK,EChGCJ,EDgGaK,EChGMJ,EDiGpD,CACH3kB,KAAM,GAAeglB,MACrBT,QAAS,GAAcM,GACvBC,aAAc,GAAeA,GAC7BC,UAAW,GAAeA,GCnGlC,CACO,SAASE,GAAqBC,GACjC,GAAIA,EAAgB//B,SAAS,KAAM,CAC/B,MAAOo/B,EAASO,GAAgBI,EAAgBN,MAAM,KACtD,OD0GD,SAAiCC,EAAeC,GACnD,MAAMK,EAAO,GAAcN,GACrBhgB,EAAO,GAAeigB,GAC5B,MAAO,CACH9kB,KAAM,GAAeolB,UACrBvyB,OAAQ,GAAyBwyB,SACjCd,QAASY,EACTL,aAAcjgB,EAEtB,CCnHeygB,CAAwBf,EAASO,EAC5C,CAEI,ODiHD,SAAiCD,GACpC,MAAMM,EAAO,GAAcN,GAC3B,MAAO,CACH7kB,KAAM,GAAeolB,UACrBvyB,OAAQ,GAAyB0yB,SACjChB,QAASY,EAEjB,CCxHeK,CAAwBN,EAEvC,CC1DO,SAAS,GAAoBL,GAChC,MAAMM,EAAO,GAAcN,GAC3B,MAAO,CAAE7kB,KAAM,GAAYylB,kBAAmBv/B,MAAO,GAAgBi/B,GACzE,CCdO,SAAS,KACZ,MAAO,CAAEnlB,KAAM,GAAY0lB,aAC/B,CACO,SAAS,GAAOx/B,GACnB,MAAO,CAAE8Z,KAAM,GAAY2lB,aAAcz/B,QAC7C,CCJO,SAAS0/B,GAAQ3+B,GACpB,IAAK,MAAMoS,KAAOpS,EACd,KCyEU,2DACDkZ,KAFa0E,EDxEHxL,IC0EIwL,EAAK3f,OAAS,KDzEjC,MAAM,IAAIP,MAAM,IAAI0U,kCCuEzB,IAAuBwL,EDpE1B,MAAO,CAAE7E,KAAM,GAAY6lB,MAAO3/B,MAAOe,EAC7C,ELRWs7B,GAaR,KAAmB,GAAiB,CAAC,IAZrBA,GAAwB,QAAI,GAAK,UAChDA,GAAeA,GAA0B,UAAI,GAAK,YAClDA,GAAeA,GAAqC,qBAAI,GAAK,uBAC7DA,GAAeA,GAA2B,WAAI,GAAK,aACnDA,GAAeA,GAAsB,MAAI,GAAK,QAC9CA,GAAeA,GAA8B,cAAI,GAAK,gBACtDA,GAAeA,GAA0B,UAAI,GAAK,YAClDA,GAAeA,GAAmC,mBAAI,GAAK,qBAC3DA,GAAeA,GAAwB,QAAI,GAAK,UAChDA,GAAeA,GAAiC,iBAAI,GAAK,mBACzDA,GAAeA,GAAwC,wBAAI,IAAM,0BACjEA,GAAeA,GAAqC,qBAAI,IAAM,uBOZ3D,MAAM,GAAiBt7B,IACnB,CAAE+Y,KAAM,GAAY8lB,YAAa5/B,MAAOe,IAEtC,GAAgBA,IAClB,CAAE+Y,KAAM,GAAY+lB,WAAY7/B,MAAOe,ICA3C,SAAS,GAAc++B,GAC1B,IAAIC,EACJ,GAAsC,iBAA3BD,EAAqC,CAC5C,MAAME,EAAoE,OAArDF,EAAuBj9B,MAAM,EAAG,GAAG8K,cACxDoyB,EAAc,IAAI,GAAY,EAAWC,EAAeF,EAAuBj9B,MAAM,GAAKi9B,GAC9F,MAEIC,EADKD,aAAkChhC,WACzB,IAAI,GAAYghC,GAGhBA,EAKlB,OAHaC,EAAYzE,cAAcE,IAAiBl9B,IACpD,MAAM,IAAI,GAAqB,kCAAkCA,IAAI,KAGrE,KAAKk9B,GAAgByE,IACjB,OAAO,GAAMviB,EAAkBqiB,EAAYlF,UAAU,MACzD,KAAKW,GAAgB0E,KACjB,OAAO,GAAOH,EAAYlF,UAAU,KACxC,KAAKW,GAAgB76B,OACjB,MAAMw/B,EAAeJ,EAAYjF,eACjC,OAAO,GAASiF,EAAYlF,UAAUsF,IAC1C,KAAK3E,GAAgB4E,KACjB,OAAO,KACX,KAAK5E,GAAgB6E,MACjB,OAAO,KACX,KAAK7E,GAAgB6C,QAEjB,OLlBmCA,EKiBlBiC,GAAmBP,GLhBrC,CAAEjmB,KAAM,GAAYylB,kBAAmBv/B,MAAO,GAAgBq+B,IKkBjE,KAAK7C,GAAgB+E,SAGjB,OLdL,SAAwClC,EAASO,GACpD,GAAI,EAAYA,EAAanC,SAASx2B,YAAc,IAChD,MAAM,IAAIxH,MAAM,6CAEpB,MAAO,CACHqb,KAAM,GAAY0mB,kBAClBxgC,MAAO,GAAG,GAAgBq+B,MAAYO,EAAanC,UAE3D,CKMmBgE,CAFUH,GAAmBP,GACfW,GAAoBX,IAE7C,KAAKvE,GAAgBmF,GACjB,OCpCiB3gC,EDoCG,GAAc+/B,GCnCnC,CAAEjmB,KAAM,GAAY8mB,WAAY5gC,SDoCnC,KAAKw7B,GAAgBqF,IACjB,OCzCL,SAAyB7gC,GAC5B,MAAO,CAAE8Z,KAAM,GAAYgnB,YAAa9gC,QAC5C,CDuCmB+gC,CAAgB,GAAchB,IACzC,KAAKvE,GAAgBwF,KACjB,OAAO,KACX,KAAKxF,GAAgBhd,KACjB,OAAO,GAAO,GAAcuhB,IAChC,KAAKvE,GAAgByF,KACjB,MAAMC,EAAanB,EAAYjF,eACzBqG,EAAe,GACrB,IAAK,IAAIv/B,EAAI,EAAGA,EAAIs/B,EAAYt/B,IAC5Bu/B,EAAa9mB,KAAK,GAAc0lB,IAEpC,OEpDW1mB,EFoDG8nB,EEnDf,CAAErnB,KAAM,GAAYsnB,KAAMphC,MAAOqZ,GFoDpC,KAAKmiB,GAAgB6F,MACjB,MAAMC,EAAcvB,EAAYjF,eAC1ByG,EAAgB,CAAC,EACvB,IAAK,IAAI3/B,EAAI,EAAGA,EAAI0/B,EAAa1/B,IAAK,CAClC,MAAM4/B,EAAcd,GAAoBX,GAAatD,QACrD,QAAoBt5B,IAAhBq+B,EACA,MAAM,IAAI,GAAqB,0BAEnCD,EAAcC,GAAe,GAAczB,EAC/C,CACA,OAAOL,GAAQ6B,GACnB,KAAK/F,GAAgBiG,MACjB,MAAMC,EAAc3B,EAAYjF,eAC1B6G,EAAW1jB,EAAa8hB,EAAYlF,UAAU6G,IACpD,OAAO,GAAcC,GACzB,KAAKnG,GAAgBoG,KACjB,MAAMC,EAAa9B,EAAYjF,eACzBgH,EAAU,EAAY/B,EAAYlF,UAAUgH,IAClD,OAAO,GAAaC,GACxB,QACI,MAAM,IAAI,GAAqB,2FEzEpC,IAAgBzoB,EDGMrZ,ENYkBq+B,CK4D/C,CGhEO,SAAS0D,GAAyBC,GACrC,OAAQA,EAAKloB,MACT,KAAK,GAAekjB,QAChB,OAAOiF,GAAsBD,GACjC,KAAK,GAAe9C,UAChB,OAAOgD,GAAwBF,GACnC,KAAK,GAAenF,qBAChB,OAAOsF,GAAuBH,GAClC,KAAK,GAAeI,WAChB,OA2HL,SAAkCC,GACrC,MAAMC,EAAa,GACbC,EAAe,EAAYF,EAAW5F,SACtC+F,EAAgBC,GAAoB,EAAWF,GAAuC,EAAxB,GAEpE,OADAD,EAAWjoB,KAAK,EAAWmoB,IACpB,EAAYF,EACvB,CAjImBI,CAAyBV,GACpC,KAAK,GAAelD,MAChB,OAAO6D,GAAoBX,GAC/B,KAAK,GAAeY,cAChB,OA2ML,SAAyCC,GAC5C,MAAMP,EAAa,GAWnB,GAVAA,EAAWjoB,KAAKwoB,EAAcC,eAC9BR,EAAWjoB,KAAK6nB,GAAwBW,EAAcE,YAClDF,EAAcC,gBAAkB,EAAkBE,UAClDH,EAAcC,gBAAkB,EAAkBG,aAClDX,EAAWjoB,KAAKsoB,GAAoBE,EAAcK,QAElDL,EAAcC,gBAAkB,EAAkBG,aAClDX,EAAWjoB,KAAK8oB,GAAiBN,EAAchE,YAEnDyD,EAAWjoB,KAAKwoB,EAAcO,eAC1BP,EAAcC,gBAAkB,EAAkBO,KAClDR,EAAcC,gBAAkB,EAAkBE,SAAU,CAC5D,GAAIH,EAAcS,OAASthC,OAAO,sBAC9B,MAAM,IAAIghB,GAAmB,4DACjCsf,EAAWjoB,KAAK8C,EAAW0lB,EAAcS,OAAQ,GACrD,CACA,OAAO,EAAYhB,EACvB,CA9NmBiB,CAAgCvB,GAC3C,KAAK,GAAewB,UAChB,OAAOrF,GAAwB6D,GACnC,KAAK,GAAezF,mBAChB,OAAOkH,GAAqBzB,GAChC,KAAK,GAAe0B,QAChB,OAAOC,GAAsB3B,GACjC,KAAK,GAAe5E,qBAChB,OA4aL,SAA4CwG,GAC/C,MAAMtB,EAAa,GACnB,OAAQsB,EAAMzG,SAASrjB,MACnB,KAAK,GAAe0pB,UAChBlB,EAAWjoB,KAAKupB,EAAM1G,iBAAmB,EAAe2G,WAClD,GAAcC,oBACd,GAAcC,uBACpBzB,EAAWjoB,KAAK,GCrZM2pB,EDqZuBJ,EAAMzG,SAASp8B,KCpZ7D,GAAMmsB,QAAQ,GAAe8W,IAAYnV,OAAM,MDqZ9C,MACJ,KAAK,GAAe2N,iBAChB8F,EAAWjoB,KAAKupB,EAAM1G,iBAAmB,EAAe2G,WAClD,GAAcI,oBACd,GAAcC,uBACpB5B,EAAWjoB,KAAK8pB,GAA+BP,EAAMzG,WC3Z1D,IAA2B6G,ED8Z9B,OAAO,EAAY1B,EACvB,CA7bmB8B,CAAmCpC,GAC9C,KAAK,GAAexF,iBAChB,OAAO2H,GAA+BnC,GAElD,CAiCO,SAASC,GAAsB5D,GAClC,MAAMiE,EAAa,GAGnB,OAFAA,EAAWjoB,KAAK,EAAWmD,EAAS6gB,EAAQpyB,QAAS,KACrDq2B,EAAWjoB,KAAK,EAAWgkB,EAAQpB,UAC5B,EAAYqF,EACvB,CACO,SAAShC,GAAmB+D,GAC/B,MAAMtE,EAAc,EAAWsE,EAAY,IACrCA,EACA,IAAI,GAAYA,GAChBp4B,EAAU,EAAS,EAAW8zB,EAAYlF,UAAU,KACpD95B,EAAO,EAAWg/B,EAAYlF,UAAU,KAC9C,MAAO,CAAE/gB,KAAM,GAAekjB,QAAS/wB,UAASgxB,QAASl8B,EAC7D,CAIO,SAASmhC,GAAwBa,GACpC,MAAMT,EAAa,GASnB,OARAA,EAAWjoB,KAAK0oB,EAAUp2B,QACtBo2B,EAAUp2B,SAAW,GAAyB0yB,UAC9C0D,EAAUp2B,SAAW,GAAyBwyB,UAC9CmD,EAAWjoB,KAAK4nB,GAAsBc,EAAU1E,UAEhD0E,EAAUp2B,SAAW,GAAyBwyB,UAC9CmD,EAAWjoB,KAAK8nB,GAAuBY,EAAUnE,eAE9C,EAAY0D,EACvB,CA0BO,SAASH,GAAuBmC,GACnC,MAAMhC,EAAa,GACbC,EAAe,EAAY+B,EAAI7H,SAC/Bz9B,EAASujC,EAAat8B,WAG5B,OAFAq8B,EAAWjoB,KAAK,EAAWmD,EAASxe,EAAQslC,EAAIhI,qBAChDgG,EAAWjoB,KAAKkoB,GACT,EAAYD,EACvB,CACO,SAAS5B,GAAoB2D,EAAYn3B,EAAa0vB,GACzD1vB,EAAcA,GAA4B,EAC1C,MAAM6yB,EAAc,EAAWsE,EAAY,IACrCA,EACA,IAAI,GAAYA,GAChBrlC,EAAS,EAAS,EAAW+gC,EAAYlF,UAAU3tB,KAEzD,OAAO,GADS,EAAY6yB,EAAYlF,UAAU77B,IACnBkO,EAAa0vB,GAAa,IAC7D,CAsBO,SAAS+F,GAAoB4B,GAChC,MAAMjC,EAAa,GAInB,OAHAA,EAAWjoB,KAAK4nB,GAAsBsC,EAAKlG,UAC3CiE,EAAWjoB,KAAK8nB,GAAuBoC,EAAK3F,eAC5C0D,EAAWjoB,KAAK8nB,GAAuBoC,EAAK1F,YACrC,EAAYyD,EACvB,CACO,SAASkC,GAAiBH,GAC7B,MAAMtE,EAAc,EAAWsE,EAAY,IACrCA,EACA,IAAI,GAAYA,GACtB,MAAO,CACHvqB,KAAM,GAAeglB,MACrBT,QAASiC,GAAmBP,GAC5BnB,aAAc8B,GAAoBX,GAClClB,UAAW6B,GAAoBX,GAEvC,CAIO,SAAS0D,GAAqBgB,GACjC,MAAMxD,EAAOwD,EAAOprB,OACdipB,EAAa,GACnBA,EAAWjoB,KAAK,EAAWmD,EAASyjB,EAAKjiC,OAAQylC,EAAOnI,qBACxD,IAAK,MAAMj6B,KAAK4+B,EACZqB,EAAWjoB,KAAK0nB,GAAyB1/B,IAE7C,OAAO,EAAYigC,EACvB,CAyDO,SAAS,GAA6B+B,GACzC,MAAMtE,EAAc,EAAWsE,EAAY,IACrCA,EACA,IAAI,GAAYA,GAChBK,EAAoB3E,EAAYzE,cAAc,GAAmBh9B,IACnE,MAAM,IAAI,GAAqB,kBAAkBA,yBAAyB,IAExEykC,EA5JH,SAA8BsB,GACjC,MAAMtE,EAAc,EAAWsE,EAAY,IACrCA,EACA,IAAI,GAAYA,GAChB13B,EAASozB,EAAYzE,cAAc,IAA0Bh9B,IAC/D,MAAM,IAAI,GAAqB,sCAAsCA,IAAI,IAE7E,GAAIqO,IAAW,GAAyBg4B,OACpC,MAAO,CAAE7qB,KAAM,GAAeolB,UAAWvyB,UAE7C,MAAM0xB,EAAUiC,GAAmBP,GACnC,GAAIpzB,IAAW,GAAyB0yB,SACpC,MAAO,CAAEvlB,KAAM,GAAeolB,UAAWvyB,SAAQ0xB,WAErD,MAAMO,EAAe8B,GAAoBX,GACzC,MAAO,CACHjmB,KAAM,GAAeolB,UACrBvyB,SACA0xB,UACAO,eAER,CAuIsBgG,CAAqB7E,GACvC,IAAIqD,EACAF,EACAI,EACJ,OAAQoB,GACJ,KAAK,EAAkBrB,IAKnB,OAJAD,EAAgBrD,EAAYzE,cAAcvZ,IAAuBzjB,IAC7D,MAAM,IAAI,GAAqB,kBAAkBA,6BAA6B,IAElFglC,EAASthC,OAAO,KAAK,EAAW+9B,EAAYlF,UAAU,OAC/C,CACH/gB,KAAM,GAAe8oB,cACrBE,cAAe,EAAkBO,IACjCN,YACAK,gBACAE,UAER,KAAK,EAAkBN,SAMnB,OALAE,EAAQsB,GAAiBzE,GACzBqD,EAAgBrD,EAAYzE,cAAcvZ,IAAuBzjB,IAC7D,MAAM,IAAI,GAAqB,kBAAkBA,6BAA6B,IAElFglC,EAASthC,OAAO,KAAK,EAAW+9B,EAAYlF,UAAU,OAC/C,CACH/gB,KAAM,GAAe8oB,cACrBE,cAAe,EAAkBE,SACjCD,YACAK,gBACAE,SACAJ,MAAOA,GAEf,KAAK,EAAkBD,YACnBC,EAAQsB,GAAiBzE,GACzB,MAAMlB,EAAY,GAAckB,GAIhC,OAHAqD,EAAgBrD,EAAYzE,cAActZ,IAA0B1jB,IAChE,MAAM,IAAI,GAAqB,kBAAkBA,6BAA6B,IAE3E,CACHwb,KAAM,GAAe8oB,cACrBE,cAAe,EAAkBG,YACjCF,YACAK,gBACAF,QACArE,aAGhB,CAIO,SAAS8E,GAAsBkB,GAClC,MAAMvC,EAAa,GAEnB,OADAA,EAAWjoB,KAAKwqB,EAAQC,aAChBD,EAAQC,aACZ,KAAK,EAAYC,cACbzC,EAAWjoB,KAAK8oB,GAAiB0B,EAAQG,YACzC1C,EAAWjoB,KAAK8C,EAAW0nB,EAAQvB,OAAQ,IAC3ChB,EAAWjoB,KAAK0nB,GAAyB8C,EAAQI,OACjD,MACJ,KAAK,EAAYC,aACb5C,EAAWjoB,KAAK0nB,GAAyB8C,EAAQM,kBACjD7C,EAAWjoB,KAAK0nB,GAAyB8C,EAAQjG,eACjD0D,EAAWjoB,KAAK0nB,GAAyB8C,EAAQO,eACjD,MAAMC,EAAU,IAAIvmC,WAAW,GAC/ByiB,EAAc8jB,EAASR,EAAQS,aAAatmC,OAAQ,GACpDsjC,EAAWjoB,KAAKgrB,GAChBR,EAAQS,aAAal4B,SAAQmG,IACzB+uB,EAAWjoB,KAAK8oB,GAAiB5vB,GAAK,IAE1C,MACJ,KAAK,EAAYgyB,cACbjD,EAAWjoB,KAAK0nB,GAAyB8C,EAAQjG,eACjD0D,EAAWjoB,KAAK0nB,GAAyB8C,EAAQW,WACjD,MACJ,KAAK,EAAYC,uBACbnD,EAAWjoB,KAAKwqB,EAAQa,gBACxBpD,EAAWjoB,KAAK0nB,GAAyB8C,EAAQjG,eACjD0D,EAAWjoB,KAAK0nB,GAAyB8C,EAAQW,WACjD,MACJ,KAAK,EAAYG,iBACb,MACJ,KAAK,EAAYC,SACbtD,EAAWjoB,KAAKwqB,EAAQgB,eACxB,MACJ,KAAK,EAAYC,uBACbxD,EAAWjoB,KAAKwqB,EAAQgB,eACxBvD,EAAWjoB,KAAK8oB,GAAiB0B,EAAQG,YACzC,MACJ,KAAK,EAAYe,iBACbzD,EAAWjoB,KAAKwqB,EAAQgB,eACxBvD,EAAWjoB,KAAK8oB,GAAiB0B,EAAQG,UAAY,GAAOH,EAAQG,WAAa,OACjF1C,EAAWjoB,KAAKwqB,EAAQmB,UACxB,MACJ,KAAK,EAAYC,aACb3D,EAAWjoB,KAAK,EAAWwqB,EAAQqB,aACnC5D,EAAWjoB,KAAK,EAAWwqB,EAAQsB,qBACnC7D,EAAWjoB,KAAK,EAAWwqB,EAAQuB,eACnC9D,EAAWjoB,KAAK,EAAWwqB,EAAQwB,oBACnC/D,EAAWjoB,KAAKkH,EAAc,IAAIziB,WAAW,GAAI+lC,EAAQyB,uBACzDhE,EAAWjoB,K/BvUhB,SAAoBmH,EAAaxhB,EAAOyE,EAAS,GAEpD,OADA+c,EAAY/c,GAAUzE,EACfwhB,CACX,C+BoU4B+kB,CAAW,IAAIznC,WAAW,GAAI+lC,EAAQ2B,QACtDlE,EAAWjoB,KAAK,EAAWwqB,EAAQ4B,gBAG3C,OAAO,EAAYnE,EACvB,CAgGO,SAAS6B,GAA+BuC,GAC3C,OAAO,EAAWA,EAAiB3lC,KACvC,CAyBO,SAASo9B,GAAwBhrB,GACpC,OAAOA,EAAIpS,KAAK8B,OACpB,CE9dA,SAAS8jC,GAAgBC,EAAQhoC,GAC7B,OAAO,EAAY,CAAC88B,GAAkBkL,GAAShoC,GACnD,CA4DA,SAASioC,GAAkBC,EAAIC,GAC3B,MAAMzE,EAAa,GACb17B,EAAkB,SAAZmgC,EAAsBhpB,EAAa+oB,EAAG9mC,OAAS,EAAY8mC,EAAG9mC,OACpEiB,EAAM,IAAInC,WAAW,GAI3B,OAHAyiB,EAActgB,EAAK2F,EAAI5H,OAAQ,GAC/BsjC,EAAWjoB,KAAKpZ,GAChBqhC,EAAWjoB,KAAKzT,GACT+/B,GAAgBG,EAAGhtB,KAAM,EAAYwoB,GAChD,CAUO,SAASa,GAAiBnjC,GAC7B,OAAQA,EAAM8Z,MACV,KAAK,GAAYqiB,SACjB,KAAK,GAAYC,UACb,OAjFZ,SAAyBp8B,GACrB,OAAO,IAAIlB,WAAW,CAAC48B,GAAkB17B,EAAM8Z,OACnD,CA+EmBktB,CAAgBhnC,GAC3B,KAAK,GAAYw/B,aACjB,KAAK,GAAYC,aACb,OAjFiBqH,EAiFU9mC,GAhF5B8Z,OAAS,GAAY0lB,aACjB,IAAI1gC,WAAW,CAAC48B,GAAkBoL,EAAGhtB,QAGrC6sB,GAAgBG,EAAGhtB,KAAMqpB,GAAiB2D,EAAG9mC,QA6EpD,KAAK,GAAYuU,OACb,OA3EZ,SAA2BuyB,GACvB,MAAM9nC,EAAS,IAAIF,WAAW,GAE9B,OADAyiB,EAAcviB,EAAQoC,KAAK6lC,KAAKH,EAAG9mC,MAAMhB,OAAS,GAAI,GAC/C2nC,GAAgBG,EAAGhtB,KAAMvU,EAAYvG,EAAQ,EAAW8nC,EAAG9mC,QACtE,CAuEmBknC,CAAkBlnC,GAC7B,KAAK,GAAYk8B,KACb,OApEZ,SAAyB4K,GACrB,MAAMloC,EAAQwe,EAAcpb,OAAO8kC,EAAG9mC,OAAQ2hB,GAC9C,OAAOglB,GAAgBG,EAAGhtB,KAAMlb,EACpC,CAiEmBuoC,CAAgBnnC,GAC3B,KAAK,GAAYi8B,IACb,OA1EZ,SAAwB6K,GACpB,MAAMloC,EAAQwe,EtCoMX,SAAgBpd,EAAO2d,GAC1B,GAAI3d,IAAUgC,OAAO,IAAO2b,EAAQ3b,OAAO,MACtCA,OAAO,IAAO2b,EAAQ3b,OAAO,IAAOA,OAAO,GAAKhC,EACjD,KAAM,yCAAyC2d,IAEnD,OAAI3d,GAASgC,OAAO,GACTA,OAAOhC,GAEXA,GAASgC,OAAO,IAAM2b,EACjC,CsC7MgCypB,CAAOplC,OAAO8kC,EAAG9mC,OAAQgC,OAAO0f,IAAoBC,GAChF,OAAOglB,GAAgBG,EAAGhtB,KAAMlb,EACpC,CAuEmByoC,CAAernC,GAC1B,KAAK,GAAYu/B,kBACb,OApEZ,SAAsCuH,GAClC,OAAOH,GAAgBG,EAAGhtB,KAAMmoB,GAAsB,GAAc6E,EAAG9mC,QAC3E,CAkEmBsnC,CAA6BtnC,GACxC,KAAK,GAAYwgC,kBACb,OAnEZ,SAAsCsG,GAClC,MAAOzI,EAAS1f,GPgEb,SAAyB4oB,GAC5B,MAAOlJ,EAAS1f,GAAQ4oB,EAAW7I,MAAM,KACzC,IAAKL,IAAY1f,EACb,MAAM,IAAIlgB,MAAM,gCAAgC8oC,KACpD,MAAO,CAAClJ,EAAS1f,EACrB,COrE4B6oB,CAAgBV,EAAG9mC,OAC3C,OAAO2mC,GAAgBG,EAAGhtB,KAAMvU,EAAY08B,GAAsB,GAAc5D,IAAW8D,GAAuB,GAAexjB,KACrI,CAgEmB8oB,CAA6BznC,GACxC,KAAK,GAAY4gC,WACjB,KAAK,GAAYE,YACb,OAlEZ,SAA6BgG,GACzB,OAAOH,GAAgBG,EAAGhtB,KAAMqpB,GAAiB2D,EAAG9mC,OACxD,CAgEmB0nC,CAAoB1nC,GAC/B,KAAK,GAAYohC,KACb,OAjEZ,SAAyB0F,GACrB,MAAMxE,EAAa,GACbtjC,EAAS,IAAIF,WAAW,GAC9ByiB,EAAcviB,EAAQ8nC,EAAG9mC,MAAMhB,OAAQ,GACvCsjC,EAAWjoB,KAAKrb,GAChB,IAAK,MAAMgB,KAAS8mC,EAAG9mC,MAAO,CAC1B,MAAM2nC,EAAkBxE,GAAiBnjC,GACzCsiC,EAAWjoB,KAAKstB,EACpB,CACA,OAAOhB,GAAgBG,EAAGhtB,KAAM,EAAYwoB,GAChD,CAuDmBsF,CAAgB5nC,GAC3B,KAAK,GAAY2/B,MACb,OAxDZ,SAA0BmH,GACtB,MAAMxE,EAAa,GACbtjC,EAAS,IAAIF,WAAW,GAC9ByiB,EAAcviB,EAAQc,OAAOkU,KAAK8yB,EAAG9mC,OAAOhB,OAAQ,GACpDsjC,EAAWjoB,KAAKrb,GAChB,MAAM6oC,EAAqB/nC,OAAOkU,KAAK8yB,EAAG9mC,OAAO8nC,MAAK,CAACpkC,EAAG/E,IAAM+E,EAAEqkC,cAAcppC,KAChF,IAAK,MAAMwU,KAAO00B,EAAoB,CAClC,MAAMG,EAAiB,GAAe70B,GACtCmvB,EAAWjoB,KAAK8nB,GAAuB6F,IACvC,MAAML,EAAkBxE,GAAiB2D,EAAG9mC,MAAMmT,IAClDmvB,EAAWjoB,KAAKstB,EACpB,CACA,OAAOhB,GAAgBG,EAAGhtB,KAAM,EAAYwoB,GAChD,CA2CmB2F,CAAiBjoC,GAC5B,KAAK,GAAY4/B,YACb,OAnCZ,SAAgCkH,GAC5B,OAAOD,GAAkBC,EAAI,QACjC,CAiCmBoB,CAAuBloC,GAClC,KAAK,GAAY6/B,WACb,OAlCZ,SAA+BiH,GAC3B,OAAOD,GAAkBC,EAAI,OACjC,CAgCmBqB,CAAsBnoC,GACjC,QACI,MAAM,IAAIgjB,GAAmB,+CAxGzC,IAA6B8jB,CA0G7B,CP7GO,MACMsB,GAAcC,GAAcA,EAAUrpC,OAAS,EAAI,IAAIqpC,IAAcA,EAErE5F,GAAsB,CAAC4F,EAAWrpC,IAAWqpC,EAAUC,OAAOtpC,EAAQ,KACtE,GAAwB,CAACkM,EAAQwxB,MAAmBxxB,GAAS,EAAYA,GAAQlM,OAAS09B,EAChG,SAAS6L,GAAUhgC,GACtB,OAAO,KAAgBA,EAC3B,CAMO,MAAM00B,GAAW5lB,GACb0f,GAAUxzB,GAAO8T,IAEfmxB,GAAgBznC,GAClB,EAAWm5B,GAAWn5B,IAGpB+8B,GAAazmB,GACf,EAAW4lB,GAAQ5lB,IAEjB0mB,GAAc1mB,IACvB,MAAMoxB,EAAUxL,GAAQ5lB,GAClBqxB,EAAenjC,EAAY,IAAIzG,WAAW,CAAC,IAAK,IAAIA,WAAW,CAAC2pC,EAAQzpC,SAAUypC,GAExF,OAAO,EADkBxL,GAAQyL,GACE,EAE1BxK,GAAW,CAACX,EAASoL,KAC9B,GAAIpL,EAAU,IAAMoL,EAAQ3pC,OAAS,GACjC,MAAMP,MAAM,+DAEhB,MAAM6jC,EAAa,GACnBA,EAAWjoB,KAAK,GAAKkjB,GACrBoL,EAAQv7B,SAAQw7B,IACZtG,EAAWjoB,KAAKuuB,EAAO5pC,QACvBsjC,EAAWjoB,KAAKuuB,EAAO,IAE3BtG,EAAWjoB,KAAK,GAAKsuB,EAAQ3pC,QAC7BsjC,EAAWjoB,KAAK,KAChB,MAAMquB,EAAe,EAAYpG,GAEjC,OAAO,EADkBrF,GAAQyL,GACE,EAE1BtK,GAAY,CAACb,EAASoL,KAC/B,GAAIpL,EAAU,IAAMoL,EAAQ3pC,OAAS,GACjC,MAAMP,MAAM,gEAEhB,MAAMoqC,EAAc,GACpBA,EAAYxuB,KAAK,GAAKkjB,GACtBoL,EAAQv7B,SAAQw7B,IACZC,EAAYxuB,KAAKuuB,EAAO5pC,QACxB6pC,EAAYxuB,KAAKuuB,EAAO,IAE5BC,EAAYxuB,KAAK,GAAKsuB,EAAQ3pC,QAC9B6pC,EAAYxuB,KAAK,KACjB,MAAMyuB,EAAS,EAAYD,GACrBlmC,EAASY,GAAOulC,GAChBxG,EAAa,GACnBA,EAAWjoB,KAAK,GAChBioB,EAAWjoB,KAAK1X,EAAO3D,QACvBsjC,EAAWjoB,KAAK1X,GAChB,MAAM+lC,EAAe,EAAYpG,GAEjC,OAAO,EADkBrF,GAAQyL,GACE,EAahC,MAAMK,GAAyBnpB,IAClC,GAAIA,EAASopB,KACT,OAJG,GAIYppB,EAAS1X,QAC5B,MAAM,IAAIzJ,MAAMmhB,EAAS4mB,MAAM,EM3E5B,SAASyC,GAAyB3b,EAAYjM,EAAU,WAG3D,OAFAA,EAAU,EAAYA,GAInB,SAAiC2iB,EAAW3iB,EAAU,WACzDA,EAAU,EAAYA,GACtB2iB,EAAiC,iBAAdA,EAAyB,EAAWA,GAAaA,EACpE,MAAMkF,EErBH,SAAkC5L,EAAUjc,GAE/C,OADAA,EAAU,EAAYA,GAAW,GACzBic,GACJ,KAAK,EAAgBG,MACjB,OAAQpc,EAAQjB,oBACZ,KAAK,EAAmBF,QACpB,OAAOF,EAAeU,iBAC1B,KAAK,EAAmBM,QACpB,OAAOhB,EAAeiB,iBAC1B,QACI,MAAM,IAAIxiB,MAAM,iCAAiC4iB,EAAQjB,mCAAmCkd,KAExG,KAAK,EAAgBU,KACrB,KAAK,EAAgBC,kBACrB,KAAK,EAAgBP,OACrB,KAAK,EAAgBC,MACrB,KAAK,EAAgBC,mBACjB,OAAQvc,EAAQjB,oBACZ,KAAK,EAAmBF,QACpB,OAAOF,EAAeY,gBAC1B,KAAK,EAAmBI,QACpB,OAAOhB,EAAekB,gBAC1B,QACI,MAAM,IAAIziB,MAAM,iCAAiC4iB,EAAQjB,mCAAmCkd,KAExG,QACI,MAAM,IAAI7+B,MAAM,uBAAuB6+B,KAEnD,CFPoB6L,CAAyB,EAAgB1L,MAAOpc,GAGhE,OADmB,GADNwc,GAAuBqL,EAASpL,GAAUkG,IAG3D,CATWoF,CADW,GAAmB9b,GACKjM,EAC9C,CASO,SAAS,GAAsB2iB,GAElC,OADAA,EAAiC,iBAAdA,EAAyB,EAAWA,GAAaA,EAC7D,CACHlqB,KAAM,GAAe0pB,UACrBziC,KAAMijC,EAEd,CAWO,SAAS,GAAgBA,GAC5B,MAA4B,iBAAdA,EAAyBA,EAAY,EAAWA,EAClE,CArCA,GAAMnQ,eAAiB,CAAC1gB,KAAQk2B,KAC5B,MAAMjnC,EAAIohB,GAAKrkB,OAAOoE,GAAQ4P,GAE9B,OADAk2B,EAAKj8B,SAAQpE,GAAO5G,EAAEtB,OAAOkI,KACtB5G,EAAEO,QAAQ,EAmCd,MAAM,GAAiB,GAEvB,SAAS2mC,GAAuBhc,GAEnC,OADqC,iBAAfA,EAA0BA,EAAWtuB,OAAS,EAAIsuB,EAAWrnB,cACjE2Y,CACtB,CAEO,SAAS,GAAsBolB,GAClC,OAAQ,GAAeA,GAAWjI,WAAW,KACjD,CACO,SAAS,GAAmBzO,GAE/B,MAAMsB,EAAe0a,GADrBhc,EAAaiH,GAAkBjH,IAE/B,OAAO,EvBmwBJ,SAAsBA,EAAYsB,GAAe,GACpD,OAAO,GAAMvB,eAAeC,GAAYqB,WAAWC,EACvD,CuBrwBsB,CAAkBtB,EAAWzqB,MAAM,EAAG,IAAK+rB,GACjE,CAOO,MAAM2a,GACN,WACH,OAkBAjc,EAAa,GADkBA,EAjBL,GAAM4F,qBAmBdl0B,QAAyC,EAA/B4f,EACtB0O,EACA,GAAGA,MAJN,IAA4BA,CAhBnC,EACO,SAASkc,GAAYlc,EAAYmc,GACpCnc,EAAaiH,GAAkBjH,GAC/B,MAAOoc,EAAcC,GvB6zBzB,SAAkBlc,EAASmc,EAASthC,EAAO,CAAC,GACxC,MAAM,KAAEupB,EAAI,EAAEf,EAAC,EAAE7U,GAlCrB,SAAqBwR,EAASH,EAAYuc,GACtC,GAAe,MAAXpc,EACA,MAAM,IAAIhvB,MAAM,2CAA2CgvB,MAC/D,MAAMgI,EAAKtI,GAAYM,GACjBxR,EAAIsR,GAAoBD,GACxBwc,EAAW,CAACnX,GAAW1W,GAAIuW,GAAYiD,IAC7C,GAAoB,MAAhBoU,EAAsB,EACD,IAAjBA,IACAA,EAAe,GAAMzkC,YAAYggB,KACrC,MAAMnS,EAAIka,GAAY0c,GACtB,GAAI52B,EAAEjU,SAAWomB,GACb,MAAM,IAAI3mB,MAAM,kBAAkB2mB,0BACtC0kB,EAASzvB,KAAKpH,EAClB,CAGA,MAAO,CAAE4e,KAFI,MAAeiY,GAEbhZ,EADLyB,GAASkD,GACDxZ,IACtB,CAiB2B8tB,CAAYtc,EAASmc,EAASthC,EAAKuhC,cACpDG,EAAO,IAAI5Y,GA71BL,GA61BuB/L,IAEnC,IAAIiN,EACJ,IAFA0X,EAAKlY,WAAWD,KAEPS,EAAMJ,GAAS8X,EAAK/X,eAAgBnB,EAAG7U,EAAG3T,EAAK2hC,aACpDD,EAAKlY,aACT,OAtBJ,SAAqBoY,EAAQ5hC,GACzB,MAAM,IAAEgqB,EAAG,SAAE3E,GAAauc,GACpB,IAAEC,EAAG,UAAEC,GAActqC,OAAO4I,OAAO,CAAEuhC,WAAW,EAAME,KAAK,GAAQ7hC,GACnE+hC,EAASF,EAAM7X,EAAIxC,gBAAkBwC,EAAI/B,oBAC/C,OAAO6Z,EAAY,CAACC,EAAQ1c,GAAY0c,CAC5C,CAiBWC,CAAYhY,EAAKhqB,EAC5B,CuBr0BuCiiC,CAASd,EAAanc,EAAWzqB,MAAM,EAAG,IAAK,CAC9EonC,WAAW,EACXG,WAAW,IAEf,GAAkB,MAAdT,EACA,MAAM,IAAIlrC,MAAM,oCAGpB,OADsB+e,EAASmsB,EAAY,GACpB9b,GAAUX,QAAQwc,GAAclZ,cAC3D,CAcO,SAAS,MAAsBpR,GAClC,MAAuB,iBAAZA,EAAK,GAIpB,SAA6BnT,EAAS+3B,GAElC,OADAA,EAAiC,iBAAdA,EAAyB,EAAWA,GAAaA,GAC7D,QAAW/3B,EAAS,EAAWgxB,GAAQ+G,IAClD,CANewG,IAAuBprB,GAO/B,SAAqC4kB,EAAW3iB,GAGnD,OAFAA,EAAUA,EAAU,EAAYA,GAAW,EAC3C2iB,EAAiC,iBAAdA,EAAyB,EAAWA,GAAaA,GAC7D,QAAW3iB,EAAQb,eAAeC,UAAW,EAAWwc,GAAQ+G,IAC3E,CAVWyG,IAA+BrrB,EAC1C,CGhGO,SAASsrB,KACZ,MAAO,CACH5wB,KAAM,GAAe0iB,iBACrBz7B,KAAM,EAAW,IAAIjC,WAAW,IAExC,CAOO,SAAS,GAAiCw+B,EAAUsL,EAAQ+B,EAAOC,GACtE,MAAMC,EAASxN,GAAsB,EAAGC,EAAU,EAAG,CAAC,GAAsBsL,KAAU3L,QAChF6N,EAAc,GAAsBlC,GACpC,EAAe/E,WACf,EAAekH,aACrB,MAAO,CACHzN,WACAuN,SACAF,MAAO,EAAYA,GACnBC,IAAK,EAAYA,GACjBE,cACApd,UAAWgd,KAEnB,CAaO,SAAS,GAAY1f,GACxB,MAAO,cAAeA,CAC1B,CACO,SAASggB,GAAqB1N,GACjC,OAAOA,IAAa,EAAgBU,MAAQV,IAAa,EAAgBK,KAC7E,CAKA,SAASsN,GAAejgB,GACpB,MAAMkgB,EAAS3C,GAAUvd,GASzB,OARAkgB,EAAOP,MAAQ,EACfO,EAAON,IAAM,EACT,GAAYM,GACZA,EAAOxd,UAAYgd,KAGnBQ,EAAOC,OAAS,GAEb,IACAD,EACHP,MAAO3oC,OAAO,GACd4oC,IAAK5oC,OAAO,GAEpB,CA4FO,SAASopC,GAAgCpgB,GAC5C,OAAI,GAAYA,GAzFb,SAAkDA,GASrD,OAAO,EARY,CACfA,EAAUsS,SACV,EAAWtS,EAAU6f,QACrB1tB,EAAW6N,EAAU2f,MAAO,GAC5BxtB,EAAW6N,EAAU4f,IAAK,GAC1B5f,EAAU8f,YACV3G,GAA+BnZ,EAAU0C,YAGjD,CAgFe2d,CAAyCrgB,GA5EjD,SAAiDA,GACpD,MAAMsX,EAAa,CACftX,EAAUsS,SACV,EAAWtS,EAAU6f,QACrB1tB,EAAW6N,EAAU2f,MAAO,GAC5BxtB,EAAW6N,EAAU4f,IAAK,IAExBO,EAAS,GAAangB,EAAUmgB,QACtC7I,EAAWjoB,KAAKopB,GAAqB0H,IACrC,MAAM5N,EAAU,IAAIz+B,WAAW,GAG/B,OnChFG,SAAuB0iB,EAAaxhB,EAAOyE,EAAS,GACvD+c,EAAY/c,EAAS,GAAKzE,IAAU,EACpCwhB,EAAY/c,EAAS,GAAKzE,IAAU,CAExC,CmC0EIsrC,CAAc/N,EAASvS,EAAUugB,mBAAoB,GACrDjJ,EAAWjoB,KAAKkjB,GACT,EAAY+E,EACvB,CAgEWkJ,CAAwCxgB,EACnD,CAYO,SAASygB,GAAeC,EAAYC,EAAUf,EAAKD,GACtD,MACMiB,EAAUF,EACZ,EAAW,IAAI5sC,WAAW,CAAC6sC,KAC3B,EAAWxuB,EAAWytB,EAAK,IAC3B,EAAWztB,EAAWwtB,EAAO,IACjC,GALmB,KAKf,EAAWiB,GAAS3lC,WACpB,MAAMxH,MAAM,iCAEhB,OAAO+pC,GAAa,EAAWoD,GACnC,CACA,SAASC,GAAgBH,EAAY9C,EAAQlb,GACzC,MAAMoe,EAAa,GAAS,EACtB5O,EAAiB,GAAsB0L,EAAO7nC,MAC9C,EAAe8iC,WACf,EAAekH,aAEfgB,EAAe,EADLL,EAAatD,GAAWlL,EAAex2B,SAAS,KAAOgnB,GAEvE,GAAIqe,EAAa9lC,WAAa6lC,EAC1B,MAAMrtC,MAAM,iCAEhB,OAAO+pC,GAAauD,EACxB,CAWO,SAASC,GAAiBC,EAAgBN,EAAUf,EAAKD,EAAOzN,EAAgBxP,GACnF,MAAMwe,EAAaT,GAAeQ,EAAgBN,EAAUf,EAAKD,GAC3D3G,EAAY,GHjLf,SAAmCyF,EAAa/C,EAAkBxJ,EAAiB,EAAe2G,YACrG,MAAMsI,EtBlCH,SAAsCze,GACzC,GAAIA,EAAU1uB,OAA4B,EAAnBs1B,GAAuB,EAAI,EAC9C,MAAM,IAAI71B,MAAM,qBAEpB,MAAM2tC,EAAgB1e,EAAU7qB,MAAM,EAAG,GACnCyZ,EAAIoR,EAAU7qB,MAAM,EAAG,EAAuB,EAAnByxB,IAC3B1G,EAAIF,EAAU7qB,MAAM,EAAuB,EAAnByxB,IAC9B,MAAO,CACHqV,WAAY,EAASyC,GACrB9vB,IACAsR,IAER,CsBsB4Bye,CAA6B3F,GAC/ChZ,EAAY,IAAIG,GAAUtQ,EAAY4uB,EAAgB7vB,GAAIiB,EAAY4uB,EAAgBve,IACtFxD,EAAQ,GAAMoD,cAAcic,EAAa/b,EAAWye,EAAgBxC,YACpE2C,EAAapP,IAAmB,EAAe2G,WACrD,OAAOzZ,EAAMyE,MAAMyd,EACvB,CG2K4CC,CAA0BL,EAAYxe,EAAWwP,IAEzF,MAAO,CACH0L,OAAQ5E,EACRwI,YAHgBX,GAAgBK,EAAYlI,EAAWtW,GAK/D,CA6DO,SAAS,GAAmB+e,GAC/B,MAAO,CACHd,SAAU,EAAStM,SACnBoN,oBAER,CACO,SAAS,GAAoBA,EAAmBC,GACnD,MAAO,CACHf,SAAU,EAASgB,UACnBF,oBACAC,yBAA0BA,GAEpB,GAAiC,EAAgBjP,MAAO,IAAIzyB,OAAO,IAAK,EAAG,GAEzF,CACO,SAAS4hC,GAAuBC,GACnC,GAAIA,EAAKJ,kBACL,OAAQI,EAAKlB,UACT,KAAK,EAAStM,SACV,OAAO,GAAmB4L,GAAe4B,EAAKJ,oBAClD,KAAK,EAASE,UACV,OAAO,GAAoB1B,GAAe4B,EAAKJ,mBAjF/D,WACI,MAAMA,EAAoB,GAAiC,EAAgBhP,MAAO,GAAI,EAAG,GAIzF,OAHAgP,EAAkB5B,QdrNR,GAAe7N,QACZhd,EAAeU,iBACf,IAAI1V,OAAO,KcoNxByhC,EAAkB3B,YAAc,EAAejH,WAC/C4I,EAAkB/e,UAAYgd,KACvB+B,CACX,CA2EmFK,IACvE,QACI,MAAM,IAAI5pB,GAAa,6CAGnC,MAAM,IAAIzkB,MAAM,0CACpB,CChTO,SAASsuC,GAAW1Y,EAAK0S,EAAW,OACvC,OAAQ1S,EAAIva,MACR,KAAK,GAAYqiB,SACb,MAAO,OACX,KAAK,GAAYC,UACb,MAAO,QACX,KAAK,GAAYH,IACb,OAAO5H,EAAIr0B,MAAM0G,WACrB,KAAK,GAAYw1B,KACb,MAAO,IAAI7H,EAAIr0B,MAAM0G,aACzB,KAAK,GAAY6N,OACb,GAAiB,aAAbwyB,EAAyB,CACzB,MAAMngC,EAAMqX,EAAa,EAAWoW,EAAIr0B,QACxC,GAAI,QAAQia,KAAKrT,GACb,OAAOomC,KAAKC,UAAUrmC,EAE9B,CACA,MAAO,KAAKytB,EAAIr0B,QACpB,KAAK,GAAYw/B,aACb,MAAO,OACX,KAAK,GAAYC,aACb,MAAO,SAASsN,GAAW1Y,EAAIr0B,MAAO+mC,MAC1C,KAAK,GAAYjG,YACb,MAAO,QAAQiM,GAAW1Y,EAAIr0B,MAAO+mC,MACzC,KAAK,GAAYnG,WACb,MAAO,OAAOmM,GAAW1Y,EAAIr0B,MAAO+mC,MACxC,KAAK,GAAYxH,kBACjB,KAAK,GAAYiB,kBACb,OAAOnM,EAAIr0B,MACf,KAAK,GAAYohC,KACb,MAAO,SAAS/M,EAAIr0B,MAAMwS,KAAI/L,GAAKsmC,GAAWtmC,EAAGsgC,KAAWx3B,KAAK,QACrE,KAAK,GAAYowB,MACb,MAAO,UAAU7/B,OAAOkU,KAAKqgB,EAAIr0B,OAC5BwS,KAAIW,GAAO,IAAIA,KAAO45B,GAAW1Y,EAAIr0B,MAAMmT,GAAM4zB,QACjDx3B,KAAK,QACd,KAAK,GAAYqwB,YACb,MAAO,IAAIvL,EAAIr0B,SACnB,KAAK,GAAY6/B,WACb,MAAO,KAAKxL,EAAIr0B,SAE5B,CAkDO,SAASktC,GAAgB7Y,GAC5B,OAAQA,EAAIva,MACR,KAAK,GAAYqiB,SACjB,KAAK,GAAYC,UACb,MAAO,OACX,KAAK,GAAYH,IACb,MAAO,MACX,KAAK,GAAYC,KACb,MAAO,OACX,KAAK,GAAY3nB,OACb,MAAO,SAASnT,KAAK6lC,KAAK5S,EAAIr0B,MAAMhB,OAAS,MACjD,KAAK,GAAYwgC,aACb,MAAO,kBACX,KAAK,GAAYC,aACb,MAAO,aAAayN,GAAgB7Y,EAAIr0B,UAC5C,KAAK,GAAY8gC,YACb,MAAO,yBAAyBoM,GAAgB7Y,EAAIr0B,UACxD,KAAK,GAAY4gC,WACb,MAAO,aAAasM,GAAgB7Y,EAAIr0B,sBAC5C,KAAK,GAAYu/B,kBACjB,KAAK,GAAYiB,kBACb,MAAO,YACX,KAAK,GAAYY,KACb,MAAO,SAAS/M,EAAIr0B,MAAMhB,UAAUq1B,EAAIr0B,MAAMhB,OAASkuC,GAAgB7Y,EAAIr0B,MAAM,IAAM,iBAC3F,KAAK,GAAY2/B,MACb,MAAO,UAAU7/B,OAAOkU,KAAKqgB,EAAIr0B,OAC5BwS,KAAIW,GAAO,IAAIA,KAAO+5B,GAAgB7Y,EAAIr0B,MAAMmT,SAChD5D,KAAK,QACd,KAAK,GAAYqwB,YACb,MAAO,iBAAiB7hB,EAAasW,EAAIr0B,OAAOhB,UACpD,KAAK,GAAY6gC,WACb,MAAO,gBAAgB,EAAYxL,EAAIr0B,OAAOhB,UAE1D,CCzHO,IAAImuC,IACX,SAAWA,GACPA,EAAiBA,EAAwC,sBAAI,GAAK,wBAClEA,EAAiBA,EAAuC,qBAAI,GAAK,uBACjEA,EAAiBA,EAAqC,mBAAI,GAAK,qBAC/DA,EAAiBA,EAA0C,wBAAI,GAAK,0BACpEA,EAAiBA,EAAqC,mBAAI,GAAK,qBAC/DA,EAAiBA,EAAuC,qBAAI,GAAK,uBACjEA,EAAiBA,EAAyC,uBAAI,GAAK,yBACnEA,EAAiBA,EAAyC,uBAAI,GAAK,yBACnEA,EAAiBA,EAAsC,oBAAI,GAAK,sBAChEA,EAAiBA,EAAqC,mBAAI,IAAM,qBAChEA,EAAiBA,EAA4C,0BAAI,IAAM,4BACvEA,EAAiBA,EAA2C,yBAAI,IAAM,2BACtEA,EAAiBA,EAA+C,6BAAI,IAAM,8BAC7E,CAdD,CAcGA,KAAqBA,GAAmB,CAAC,IACrC,MAAMC,GAAyB/Y,GAAuB,iBAARA,EACxCgZ,GAAsBhZ,QAAuBlxB,IAAfkxB,EAAI1zB,OAClC2sC,GAA2BjZ,QAAgClxB,IAAxBkxB,EAAI,gBACvCkZ,GAA0BlZ,QAA+BlxB,IAAvBkxB,EAAI,eACtCmZ,GAAwBnZ,QAAyBlxB,IAAjBkxB,EAAIzU,SACpC6tB,GAAwBpZ,QAAyBlxB,IAAjBkxB,EAAIqZ,SACpCC,GAAqBtZ,QAAsBlxB,IAAdkxB,EAAIgN,MACjCuM,GAAoBvZ,QAAqBlxB,IAAbkxB,EAAI4M,KAwGtC,SAAS4M,GAAcxZ,GAC1B,GAAI+Y,GAAsB/Y,GACtB,MAAY,WAARA,EACO,MAEM,YAARA,EACE,OAEJA,EAEN,GAAIgZ,GAAmBhZ,GACxB,MAAO,SAASA,EAAI1zB,OAAO3B,UAE1B,GAAIsuC,GAAwBjZ,GAC7B,MAAO,iBAAiBA,EAAI,gBAAgBr1B,UAE3C,GAAIuuC,GAAuBlZ,GAC5B,MAAO,gBAAgBA,EAAI,eAAer1B,UAEzC,GAAIwuC,GAAqBnZ,GAC1B,MAAO,aAAawZ,GAAcxZ,EAAIzU,SAAS+gB,OAAOkN,GAAcxZ,EAAIzU,SAASmO,UAEhF,GAAI0f,GAAqBpZ,GAC1B,MAAO,aAAawZ,GAAcxZ,EAAIqZ,aAErC,GAAIC,GAAkBtZ,GACvB,MAAO,UAAUA,EAAIgN,MAAM7uB,KAAI0J,GAAK,IAAIA,EAAEyC,QAAQkvB,GAAc3xB,EAAEpC,WAAUvK,KAAK,QAEhF,GAAIq+B,GAAiBvZ,GACtB,MAAO,SAASA,EAAI4M,KAAKjiC,UAAU6uC,GAAcxZ,EAAI4M,KAAKnnB,SAG1D,MAAM,IAAIrb,MAAM,6CAA6CuuC,KAAKC,UAAU5Y,KAEpF,CAOA,SAASyZ,GAAUhH,EAAIiH,GACnB,MAAMC,EAjJH,SAAsB3Z,GACzB,GAAI+Y,GAAsB/Y,GAAM,CAC5B,GAAY,YAARA,EACA,MAAO,CAAEzY,GAAIuxB,GAAiBc,sBAAuBn0B,KAAMua,GAE1D,GAAY,WAARA,EACL,MAAO,CAAEzY,GAAIuxB,GAAiBe,qBAAsBp0B,KAAMua,GAEzD,GAAY,SAARA,EACL,MAAO,CAAEzY,GAAIuxB,GAAiBgB,mBAAoBr0B,KAAMua,GAEvD,GAAY,cAARA,EACL,MAAO,CAAEzY,GAAIuxB,GAAiBiB,wBAAyBt0B,KAAMua,GAE5D,GAAY,oBAARA,EACL,MAAO,CAAEzY,GAAIuxB,GAAiBkB,6BAA8Bv0B,KAAMua,GAEjE,GAAY,SAARA,EACL,MAAO,CAAEzY,GAAIuxB,GAAiBmB,mBAAoBx0B,KAAMua,GAGxD,MAAM,IAAI51B,MAAM,0CAA0CuuC,KAAKC,UAAU5Y,KAEjF,CACK,GAAIgZ,GAAmBhZ,GACxB,MAAO,CAAEzY,GAAIuxB,GAAiBoB,qBAAsBz0B,KAAMua,GAEzD,GAAImZ,GAAqBnZ,GAC1B,MAAO,CAAEzY,GAAIuxB,GAAiBqB,uBAAwB10B,KAAMua,GAE3D,GAAIoZ,GAAqBpZ,GAC1B,MAAO,CAAEzY,GAAIuxB,GAAiBsB,uBAAwB30B,KAAMua,GAE3D,GAAIsZ,GAAkBtZ,GACvB,MAAO,CAAEzY,GAAIuxB,GAAiBuB,oBAAqB50B,KAAMua,GAExD,GAAIuZ,GAAiBvZ,GACtB,MAAO,CAAEzY,GAAIuxB,GAAiBwB,mBAAoB70B,KAAMua,GAEvD,GAAIiZ,GAAwBjZ,GAC7B,MAAO,CAAEzY,GAAIuxB,GAAiByB,0BAA2B90B,KAAMua,GAE9D,GAAIkZ,GAAuBlZ,GAC5B,MAAO,CAAEzY,GAAIuxB,GAAiB0B,yBAA0B/0B,KAAMua,GAG9D,MAAM,IAAI51B,MAAM,gCAAgCuuC,KAAKC,UAAU5Y,KAEvE,CAiGkBya,CAAaf,GAC3B,OAAQjH,EAAGhtB,MACP,KAAK,GAAYqiB,SACjB,KAAK,GAAYC,UACb,OAAO4R,EAAMpyB,KAAOuxB,GAAiBgB,mBACzC,KAAK,GAAYlS,IACb,OAAO+R,EAAMpyB,KAAOuxB,GAAiBe,qBACzC,KAAK,GAAYhS,KACb,OAAO8R,EAAMpyB,KAAOuxB,GAAiBc,sBACzC,KAAK,GAAY15B,OACb,OAAQy5B,EAAMpyB,KAAOuxB,GAAiBoB,sBAClCP,EAAMl0B,KAAKnZ,OAAO3B,QAAUoC,KAAK6lC,KAAKH,EAAG9mC,MAAMhB,OAAS,GAChE,KAAK,GAAY4gC,YACb,OAAQoO,EAAMpyB,KAAOuxB,GAAiByB,2BAClCZ,EAAMl0B,KAAK,gBAAgB9a,QAAU8nC,EAAG9mC,MAAMhB,OACtD,KAAK,GAAY6gC,WACb,OAAQmO,EAAMpyB,KAAOuxB,GAAiB0B,0BAClCb,EAAMl0B,KAAK,eAAe9a,QAAU8nC,EAAG9mC,MAAMhB,OACrD,KAAK,GAAYwgC,aACb,OAAQwO,EAAMpyB,KAAOuxB,GAAiBmB,oBAClCN,EAAMpyB,KAAOuxB,GAAiBsB,uBACtC,KAAK,GAAYhP,aACb,OAAQuO,EAAMpyB,KAAOuxB,GAAiBsB,wBAClCX,GAAUhH,EAAG9mC,MAAOguC,EAAMl0B,KAAK4zB,UACvC,KAAK,GAAY5M,YACb,OAAQkN,EAAMpyB,KAAOuxB,GAAiBqB,wBAClCV,GAAUhH,EAAG9mC,MAAOguC,EAAMl0B,KAAK8F,SAASmO,OAChD,KAAK,GAAY6S,WACb,OAAQoN,EAAMpyB,KAAOuxB,GAAiBqB,wBAClCV,GAAUhH,EAAG9mC,MAAOguC,EAAMl0B,KAAK8F,SAAS+gB,IAChD,KAAK,GAAYH,kBACb,OAAQwN,EAAMpyB,KAAOuxB,GAAiBiB,yBAClCJ,EAAMpyB,KAAOuxB,GAAiBkB,6BACtC,KAAK,GAAY9O,kBACb,OAAOyO,EAAMpyB,KAAOuxB,GAAiBiB,wBACzC,KAAK,GAAYhN,KACb,OAAQ4M,EAAMpyB,IAAMuxB,GAAiBwB,oBACjCX,EAAMl0B,KAAKmnB,KAAKjiC,QAAU8nC,EAAG9mC,MAAMhB,QACnC8nC,EAAG9mC,MAAMgI,OAAMqsB,GAAOyZ,GAAUzZ,EAAK2Z,EAAMl0B,KAAKmnB,KAAKnnB,QAC7D,KAAK,GAAY6lB,MACb,GAAIqO,EAAMpyB,IAAMuxB,GAAiBuB,oBAAqB,CAClD,MAAMrN,EAAQkH,GAAUzB,EAAG9mC,OAC3B,IAAK,IAAI4B,EAAI,EAAGA,EAAIosC,EAAMl0B,KAAKunB,MAAMriC,OAAQ4C,IAAK,CAC9C,MAAMmtC,EAAgBf,EAAMl0B,KAAKunB,MAAMz/B,GACjCuR,EAAM47B,EAAcpwB,KACpB0V,EAAMgN,EAAMluB,GAClB,IAAIkhB,EAOA,OAAO,EANP,IAAKyZ,GAAUzZ,EAAK0a,EAAcj1B,MAC9B,OAAO,SAEJunB,EAAMluB,EAKrB,CACA,OAAO,CACX,CAEI,OAAO,EAEf,QACI,OAAO,EAEnB,CCnOO,MAAM,GACT,WAAA7S,EAAY,KAAEusC,EAAI,QAAEhI,EAAO,eAAEmK,EAAiB,GAAa,IAAG,kBAAEC,EAAoB,EAAkBC,KAAI,mBAAE9uB,EAAkB,QAAED,EAAO,QAAEkB,EAAU,YAC/IA,EAAU,EAAYA,GACtBnjB,KAAKkiB,mBAAqBA,GAAsBiB,EAAQjB,mBACxDliB,KAAKiiB,QAAUA,GAAWkB,EAAQlB,QAClCjiB,KAAK2uC,KAAOA,EAER3uC,KAAK2mC,QADL,WAAYA,EACG,IACRA,EACHvB,OAAQ,EAAYuB,EAAQvB,SAIjBuB,EAEnB3mC,KAAK+wC,kBAAoBA,EACzB/wC,KAAK8wC,eAAiBA,EACtB9wC,KAAKixC,WAAa,EAAWtsB,GACjC,CACA,SAAAusB,GACI,MAAMC,EAAK9G,GAAUrqC,MAErB,OADAmxC,EAAGxC,KAAOD,GAAuByC,EAAGxC,MAC7BwC,EAAGC,MACd,CACA,WAAAC,GACI,MAAMF,EAAK9G,GAAUrqC,MAErB,OADAmxC,EAAGxC,KAAOD,GAAuByC,EAAGxC,MAC7BwC,EAAGC,MACd,CACA,YAAAE,GACI,OH2QD,SAAsB3C,EAAMZ,GAC/B,OAAQY,EAAKlB,UACT,KAAK,EAAStM,SAEd,KAAK,EAASsN,UACV,OAtFZ,SAAgB3hB,EAAWihB,EAAgBN,GACvC,OAAI,GAAY3gB,GAOpB,SAAyBA,EAAWihB,EAAgBN,GAChD,MAAM,OAAE/C,EAAM,YAAE4D,GAAgBR,GAAiBC,EAAgBN,EAAU3gB,EAAU4f,IAAK5f,EAAU2f,MAAO3f,EAAU8f,YAAa9f,EAAU0C,UAAU3sB,MAChJ0uC,EAAYpS,GAAsB,EAAGrS,EAAUsS,SAAU,EAAG,CAACsL,IAAS3L,QAC5E,GAAIwS,IAAczkB,EAAU6f,OACxB,MAAM,IAAI,GAAkB,qDAAqD4E,QAAgBzkB,EAAU6f,UAC/G,OAAO2B,CACX,CAZekD,CAAgB1kB,EAAWihB,EAAgBN,GAa1D,SAAwB3gB,EAAWihB,EAAgBN,GAC/C,MAAMnO,EAAa,GACnB,IAAIkO,EAAaO,EACb0D,GAAmB,EACnBpS,EAAU,EACd,IAAK,MAAMqG,KAAS5Y,EAAUmgB,OAC1B,OAAQvH,EAAMzG,SAASrjB,MACnB,KAAK,GAAe0pB,UACX,GAAsBI,EAAMzG,SAASp8B,QACtC4uC,GAAmB,GACvBnS,EAAWnjB,KAAKupB,EAAMzG,UACtB,MACJ,KAAK,GAAeX,iBACZoH,EAAM1G,iBAAmB,EAAe6N,eACxC4E,GAAmB,GACvB,MAAM,OAAE/G,EAAM,YAAE4D,GAAgBR,GAAiBN,EAAYC,EAAU3gB,EAAU4f,IAAK5f,EAAU2f,MAAO/G,EAAM1G,eAAgB0G,EAAMzG,SAASp8B,MAM5I,GALIiqC,GAAqBhgB,EAAUsS,YAC/BoO,EAAac,GAEjBhP,EAAWnjB,KAAKuuB,GAChBrL,GAAW,EACK,QAAZA,EACA,MAAM,IAAI,GAAkB,uBAI5C,GAAKyN,GAAqBhgB,EAAUsS,WAAaC,IAAYvS,EAAUugB,sBAzNnCjO,EA0NPtS,EAAUsS,YAzNlB,EAAgBW,mBACjCX,IAAa,EAAgBM,qBAwNmBL,EAAUvS,EAAUugB,mBACpE,MAAM,IAAI,GAAkB,kCA3N7B,IAAiCjO,EA4NpC,GAAIqS,IACC3kB,EAAUsS,WAAa,EAAgBK,OACpC3S,EAAUsS,WAAa,EAAgBM,oBAC3C,MAAM,IAAI,GAAkB,uDAChC,MAAM6R,EAAYpS,GAAsB,EAAGrS,EAAUsS,SAAUtS,EAAUugB,mBAAoB/N,GAAYP,QACzG,GAAIwS,IAAczkB,EAAU6f,OACxB,MAAM,IAAI,GAAkB,qDAAqD4E,QAAgBzkB,EAAU6f,UAC/G,OAAOa,CACX,CA/CekE,CAAe5kB,EAAWihB,EAAgBN,EAEzD,CA+EmB,CAAOkB,EAAKJ,kBAAmBR,EAAgB,EAAS5M,UACnE,QACI,MAAM,IAAInc,GAAa,4BAEnC,CGpRessB,CAAatxC,KAAK2uC,KAAM3uC,KAAKqxC,cACxC,CACA,cAAAM,CAAejE,EAASte,GACpB,QAAoCnqB,IAAhCjF,KAAK2uC,KAAKJ,kBACV,MAAM,IAAIhuC,MAAM,yCAEpB,QAA2B0E,IAAvBjF,KAAK2uC,KAAKlB,SACV,MAAM,IAAIltC,MAAM,gCAEpB,OAAOP,KAAK4xC,cAAc5xC,KAAK2uC,KAAKJ,kBAAmBb,EAAS,EAASvM,SAAU/R,EACvF,CACA,eAAAyiB,CAAgBnE,EAASte,GACrB,GAAIpvB,KAAK2uC,KAAKlB,WAAa,EAASgB,UAChC,OAAOzuC,KAAK4xC,cAAc5xC,KAAK2uC,KAAKH,yBAA0Bd,EAAS,EAASe,UAAWrf,GAG3F,MAAM,IAAI7uB,MAAM,+CAExB,CACA,YAAAuxC,CAAahM,GACT,MAAMhC,EAA4B,iBAAdgC,GAA0B,SAAUA,EAClDA,EACA,GAAsBA,GACtBiM,EAAO/xC,KAAK2uC,KAAKJ,kBACvB,IAAIwD,GAAS,GAAYA,GAKrB,MAAM,IAAIxxC,MAAM,oDALY,CAC5B,MAAM6tC,EAAa,GAAsBtK,EAAKjhC,MAC9CkvC,EAAK9E,OAAO9wB,KAAK,GAA2BiyB,EAAa,EAAezI,WAAa,EAAekH,aAAc/I,GACtH,CAIJ,CACA,aAAA8N,CAAc9kB,EAAW0gB,EAAYC,EAAUre,GAC3C,MAAM,QAAE4iB,EAAO,YAAE1D,GH+HlB,SAAuBd,EAAYC,EAAUf,EAAKD,EAAOrd,GAC5D,MAAM4e,EAAaT,GAAeC,EAAYC,EAAUf,EAAKD,GACvDjd,EAAY8b,GAAYlc,EAAY4e,GAG1C,MAAO,CACHgE,QAASxiB,EACT8e,YAHgBX,GAAgBK,EADlB,GAAsB,GAAmB5e,IACAI,GAK/D,CGxIyCyiB,CAAczE,EAAYC,EAAU3gB,EAAU4f,IAAK5f,EAAU2f,MAAOrd,GACrG,GAAI,GAAYtC,GACZA,EAAU0C,UAAY,GAAuBwiB,OAE5C,CACD,MAAM5D,EAAahD,GAAuBhc,GAC1CtC,EAAUmgB,OAAO9wB,KAAK,GAA2BiyB,EAAa,EAAezI,WAAa,EAAekH,aAAc,GAAuBmF,IAClJ,CACA,OAAO1D,CACX,CACA,IAAA8C,GACI,MAAMjL,EAAanmC,KAAKkyC,iBACxB,OAAO5H,GAAanE,EACxB,CACA,UAAAgM,CAAW3D,GACP,GAAIxuC,KAAK2uC,KAAKlB,UAAY,EAASgB,UAC/B,MAAM,IAAIzpB,GAAa,mDAE3BhlB,KAAK2uC,KH8QN,SAAoBA,EAAMH,GAM7B,MAAO,IACAG,EACHH,yBAPO,IACJA,EACH/B,MAAO,EAAY+B,EAAyB/B,OAC5CC,IAAK,EAAY8B,EAAyB9B,MAMlD,CGxRoByF,CAAWnyC,KAAK2uC,KAAMH,EACtC,CACA,MAAA4D,CAAOhN,GACHplC,KAAK2uC,KH+NN,SAAgBA,EAAMvJ,GACzB,OAAQuJ,EAAKlB,UACT,KAAK,EAAStM,SACV,MAAMoN,EAAoB,IACnBI,EAAKJ,kBACR7B,IAAK,EAAYtH,IAErB,MAAO,IAAKuJ,EAAMJ,qBACtB,KAAK,EAASE,UACV,MAAMD,EAA2B,IAC1BG,EAAKH,yBACR9B,IAAK,EAAYtH,IAErB,MAAO,IAAKuJ,EAAMH,4BAE9B,CG9OoB4D,CAAOpyC,KAAK2uC,KAAMvJ,EAClC,CACA,QAAAiN,CAAS5F,GACLzsC,KAAK2uC,KHoPN,SAAkBA,EAAMlC,GAC3B,MAAM8B,EAAoB,IACnBI,EAAKJ,kBACR9B,MAAO,EAAYA,IAEvB,MAAO,IACAkC,EACHJ,oBAER,CG7PoB8D,CAASryC,KAAK2uC,KAAMlC,EACpC,CACA,eAAA6F,CAAgB7F,GACZ,GAAIzsC,KAAK2uC,KAAKlB,UAAY,EAASgB,UAC/B,MAAM,IAAIzpB,GAAa,mDAE3BhlB,KAAK2uC,KHwPN,SAAyBA,EAAMlC,GAClC,MAAM+B,EAA2B,IAC1BG,EAAKH,yBACR/B,MAAO,EAAYA,IAEvB,MAAO,IACAkC,EACHH,2BAER,CGjQoB8D,CAAgBtyC,KAAK2uC,KAAMlC,EAC3C,CACA,SAAA8F,GACI,OAAO,EAAWvyC,KAAKkyC,iBAC3B,CACA,cAAAA,GACI,QAAgCjtC,IAA5BjF,KAAKkiB,mBACL,MAAM,IAAI4C,GAAmB,qCAEjC,QAAqB7f,IAAjBjF,KAAKiiB,QACL,MAAM,IAAI6C,GAAmB,0BAEjC,QAAkB7f,IAAdjF,KAAK2uC,KACL,MAAM,IAAI7pB,GAAmB,uBAEjC,QAAqB7f,IAAjBjF,KAAK2mC,QACL,MAAM,IAAI7hB,GAAmB,0BAEjC,MAAMsf,EAAa,GACnBA,EAAWjoB,KAAKnc,KAAKkiB,oBACrB,MAAMswB,EAAe,IAAI5xC,WAAW,GAQpC,OAPAyiB,EAAcmvB,EAAcxyC,KAAKiiB,QAAS,GAC1CmiB,EAAWjoB,KAAKq2B,GAChBpO,EAAWjoB,KHyPZ,SAAqCwyB,GACxC,MAAMvK,EAAa,GAEnB,OADAA,EAAWjoB,KAAKwyB,EAAKlB,UACbkB,EAAKlB,UACT,KAAK,EAAStM,SACViD,EAAWjoB,KAAK+wB,GAAgCyB,EAAKJ,oBACrD,MACJ,KAAK,EAASE,UACVrK,EAAWjoB,KAAK+wB,GAAgCyB,EAAKJ,oBACrDnK,EAAWjoB,KAAK+wB,GAAgCyB,EAAKH,2BAG7D,OAAO,EAAYpK,EACvB,CGtQwBqO,CAA4BzyC,KAAK2uC,OACjDvK,EAAWjoB,KAAKnc,KAAKixC,YACrB7M,EAAWjoB,KAAKnc,KAAK+wC,mBACrB3M,EAAWjoB,KAAKopB,GAAqBvlC,KAAK8wC,iBAC1C1M,EAAWjoB,KAAKspB,GAAsBzlC,KAAK2mC,UACpC,EAAYvC,EACvB,EA4BG,SAAS,GAAoBsO,GAChC,OxCzImCxwB,EwCyILwwB,EAAYxwB,mBxCxIlC5N,GAAQA,EAAI4N,IwCwI0C,CAC1D,CAAC,EAAmBF,SAAU,EAC9B,CAAC,EAAmBc,SAAUD,IxC3I/B,IAAgCX,CwC6IvC,CC9JO,MACMywB,GAA6B,oBAC7BC,GAAgC,uBAChCC,GAAe,eACfC,GAAoB,0BACpBC,GAA8B,0BCV3C,IAAIC,GA+EG,SAASC,GAAoBnmB,GAChC,OAAOkmB,GAA0BlmB,EACrC,CCmEOzjB,eAAe6pC,GAAyBC,GAC3C,MAAMC,EAAiB,CACnB1G,IAAK5oC,OAAO,GACZ2oC,MAAO3oC,OAAO,GACdqf,QAAS,EACT4tB,kBAAmB,EAAkBC,KACrCqC,WAAW,GAETC,EAAU1xC,OAAO4I,OAAO4oC,EAAgBD,GAC9CG,EAAQnwB,QAAU,EAAYmwB,EAAQnwB,SACtCmwB,EAAQ3wB,OAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB8oC,EAAQnwB,SAAUmwB,EAAQ3wB,QAC/E2wB,EAAQvC,kBDtEL,SAA+B9yB,GAClC,GAAoB,iBAATA,EACP,OAAOA,EACX,GAAa,UAATA,EACA,OAAO,EAAkBs1B,MAC7B,GAAa,SAATt1B,EACA,OAAO,EAAkB+yB,KAC7B,MAAM,IAAIzwC,MAAM,gCAAgC0d,IACpD,CC8DgC,CAAsBq1B,EAAQvC,mBAC1D,MAAMpK,GpB/GgCM,EoB+GIqM,EAAQrM,gBpB/GKvG,EoB+GY4S,EAAQ5S,apB/GNwG,EoB+GoBoM,EAAQpM,apB/GdE,EoB+G4BkM,EAAQlM,apB9G3F,iBAAjB1G,IACPA,EAAe,GAAeA,IAEN,iBAAjBwG,IACPA,EAAe,GAAeA,IAE3B,CACHtrB,KAAM,GAAe4pB,QACrBoB,YAAa,EAAYI,aACzBC,gBAA4C,iBAApBA,EAA+B,GAAcA,GAAmBA,EACxFvG,eACAwG,eACAE,iBAbD,IAAmCH,EAAiBvG,EAAcwG,EAAcE,EoBgHnF,GAAIkM,GAASE,gBAAiB,CAC1B,IAAIC,EACJ,GAAuC,kBAA5BH,EAAQE,gBAA+B,CAC9C,IAAIF,GAASnwB,QAIT,MAAM,IAAI5iB,MAAM,iEAHhBkzC,QFlCTpqC,gBAA0B49B,gBAAiB9G,EAASO,aAAcjgB,EAAI,QAAE0C,EAAU,UAAWR,OAAQ+wB,IACxG,MAAM/wB,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB,EAAY2Y,IAAWuwB,GACpEpyB,EAAM,GAAGqB,EAAOC,UAAUkwB,MAAqB3S,KAAW1f,IAC1DiB,QAAiBiB,EAAO1B,MAAMK,GACpC,IAAKI,EAAS+gB,GAAI,CACd,MAAM33B,QAAY4W,EAASiyB,OAAOC,OAAM,IAAM,KAC9C,MAAM,IAAIrzC,MAAM,6CAA6CkgB,iBAAoB0f,eAAqBze,EAASmyB,WAAWnyB,EAASoyB,kCAAkCxyB,mCAAqCxW,KAC9M,CACA,OAAOgkC,KAAKiF,YAAYryB,EAASiyB,OACrC,CEyB4BK,CAAS,IAAKV,GAKlC,MAEIG,EAAMH,EAAQE,iBJgEnB,SAA8B7M,EAAS8M,GAC1C,MAAMQ,EAAWR,EAAIS,UAAU3X,QAAO4X,GAAMA,EAAG1zB,OAASkmB,EAAQO,aAAa3I,UAC7E,GAAwB,IAApB0V,EAASnzC,OAAc,CACvB,MACMszC,EADUH,EAAS,GACD/yB,KACxB,GAAIylB,EAAQS,aAAatmC,SAAWszC,EAAQtzC,OACxC,MAAM,IAAIP,MAAM,4BAA4B6zC,EAAQtzC,mCAAmC6lC,EAAQS,aAAatmC,UAEhH,IAAK,IAAI4C,EAAI,EAAGA,EAAIijC,EAAQS,aAAatmC,OAAQ4C,IAAK,CAClD,MAAM2wC,EAAa1N,EAAQS,aAAa1jC,GAClC4wC,EAASF,EAAQ1wC,GACvB,IAAKksC,GAAUyE,EAAYC,EAAO14B,MAAO,CACrC,MAAM24B,EAAS7wC,EAAI,EACnB,MAAM,IAAInD,MAAM,sBAAsBomC,EAAQO,aAAa3I,8BAA8BgW,mBAAwB5E,GAAc2E,EAAO14B,cAAcozB,GAAgBqF,KACxK,CACJ,CACA,OAAO,CACX,CACK,MAAwB,IAApBJ,EAASnzC,OACR,IAAIP,MAAM,gDAAgDomC,EAAQO,aAAa3I,WAG/E,IAAIh+B,MAAM,4DAA4DomC,EAAQO,aAAa3I,UAEzG,CItFQiW,CAAqB7N,EAAS8M,EAClC,CACA,IAAIlF,EAAoB,KACxB,GAAI,cAAe+E,EACf/E,EAAoB,GAAiC,EAAgBhP,MAAO+T,EAAQxN,UAAWwN,EAAQ7G,MAAO6G,EAAQ5G,SAErH,CACD,MAAMtN,EAAWkU,EAAQmB,yBACnB,EAAgB1U,kBAChB,EAAgBD,KAChBR,EAAagU,EAAQnT,QA8GnC,SAAkCb,EAAYD,EAASD,EAAUp+B,GAE7D,GADqBm+B,GAAsB,EAAGC,EAAUC,EAASC,EAAWhrB,IAAI,KAAwByqB,UACnF/9B,EACjB,OAAOs+B,EACX,MAAMoV,EAAmBpV,EAAW36B,QAAQilC,OAE5C,GADmBzK,GAAsB,EAAGC,EAAUC,EAASqV,EAAiBpgC,IAAI,KAAwByqB,UACzF/9B,EACf,OAAO0zC,EACX,MAAM,IAAIn0C,MAAM,+DACpB,CAtHco0C,CAAyBrB,EAAQhU,WAAWhrB,IAAI,IAAiBg/B,EAAQsB,cAAexV,EAAU,GAAckU,EAAQnT,SAASpB,SACjIuU,EAAQhU,WAAWhrB,IAAI,IAC7Bi6B,EN7JD,SAAyCnP,EAAUC,EAASoL,EAASgC,EAAOC,GAG/E,MAAO,CACHtN,WACAuN,OAHWxN,GAAsB,EAAGC,EAAUC,EADzBoL,EAAQn2B,IAAI,KACwCyqB,QAIzE0N,MAAO,EAAYA,GACnBC,IAAK,EAAYA,GACjBO,OAAQ,GACRI,mBAAoBhO,EAE5B,CMkJ4B,CAAgCD,EAAUkU,EAAQsB,cAAetV,EAAYgU,EAAQ7G,MAAO6G,EAAQ5G,IAC5H,CACA,MAAMmI,EAAgBvB,EAAQD,UACxB,GAAoB9E,GACpB,GAAmBA,GAQnBuG,EAAmB,IAPDxB,EAAQxC,gBAAkB,IAAIx8B,KAAIygC,GACpC,iBAAPA,EACA,GAA6BA,GACjB,iBAAZA,EAAGn5B,KDzLf,SAA6Bo5B,GAChC,OAAQA,EAAcp5B,MAClB,IAAK,oBACD,MAAO,CACHA,KAAM,GAAe8oB,cACrBE,cAAe,EAAkBO,IACjCN,UAAqC,WAA1BmQ,EAAc7U,QACnB,CAAEvkB,KAAM,GAAeolB,UAAWvyB,OAAQ,GAAyBg4B,QACnE5F,GAAqBmU,EAAc7U,SACzC+E,cAAe+N,GAAoB+B,EAAcloB,WACjDsY,OAAQthC,OAAOkxC,EAAc5P,SAErC,IAAK,mBACD,MAAO,CACHxpB,KAAM,GAAe8oB,cACrBE,cAAe,EAAkBE,SACjCD,UAAqC,WAA1BmQ,EAAc7U,QACnB,CAAEvkB,KAAM,GAAeolB,UAAWvyB,OAAQ,GAAyBg4B,QACnE5F,GAAqBmU,EAAc7U,SACzC+E,cAAe+N,GAAoB+B,EAAcloB,WACjDsY,OAAQthC,OAAOkxC,EAAc5P,QAC7BJ,MAAO5E,GAAiB4U,EAAchQ,QAE9C,IAAK,oBACD,MAAO,CACHppB,KAAM,GAAe8oB,cACrBE,cAAe,EAAkBG,YACjCF,UAAqC,WAA1BmQ,EAAc7U,QACnB,CAAEvkB,KAAM,GAAeolB,UAAWvyB,OAAQ,GAAyBg4B,QACnE5F,GAAqBmU,EAAc7U,SACzC+E,cAAe+N,GAAoB+B,EAAcloB,WACjDkY,MAAO5E,GAAiB4U,EAAchQ,OACtCrE,UAAWqU,EAAcC,SAEjC,QACI,MAAM,IAAI10C,MAAM,+BAE5B,CCqJmB,CAAoBw0C,GACxBA,KAGLrC,EAAc,IAAI,GAAsB,CAC1CxwB,mBAAoBoxB,EAAQnwB,QAAQjB,mBACpCD,QAASqxB,EAAQnwB,QAAQlB,QACzB0sB,KAAMkG,EACNlO,UACAmK,eAAgBgE,EAChB/D,kBAAmBuC,EAAQvC,oBAE/B,QAAsB9rC,IAAlBkuC,EAAUzG,KAAuC,OAAlByG,EAAUzG,IAAc,CACvD,MAAMA,QFhGPrjC,gBAAkCqpC,YAAawC,EAAO/xB,QAASgyB,EAAUxyB,OAAQ+wB,IACpF,MAAMvwB,EAAUgyB,GAAY,GAAoBD,GAC1CvyB,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB,EAAY2Y,IAAWuwB,GAC1E,IACI,MAAM0B,ED+CP,SAAuC1C,GAC1C,MAAMtT,EAAWsT,EAAY/D,KAAKJ,kBAAkBnP,SAEpD,GAD0B,CAAC,EAAgBU,KAAM,EAAgBL,OAC3C1+B,SAASq+B,GAAW,CACtC,MAAMiW,EAA4B3C,EAAY/D,KACzCJ,kBACC+G,EAAqBD,EAA0BpI,OAAO1Q,QAAOmJ,GAASA,EAAMzG,SAASrjB,OAAS,GAAe0iB,mBAAkBx9B,OAC/Hy0C,GAAwBF,EAA0BhI,mBAAqBiI,IACxE,EAAqC,GAC1C,OAAO5C,EAAYR,iBAAiBnqC,WAAawtC,CACrD,CAEI,OAAO7C,EAAYR,iBAAiBnqC,UAE5C,CC7DgCytC,CAA8BN,GACtD,aAlCD7rC,gBAA2C,QAAEs9B,EAAO,gBAAEyO,EAAe,QAAEjyB,EAAU,UAAWR,OAAQ+wB,IACvG,MAAM+B,EAAO,CACTC,oBAAqB/O,EACrBgP,cAAeP,GAEb9B,EAAU,CACZsC,OAAQ,OACR/0B,QAAS,CAAE,eAAgB,oBAC3Bg1B,KAAM/G,KAAKC,UAAU0G,IAEnB9yB,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB,EAAY2Y,IAAWuwB,GACpEpyB,EAAM,GAAGqB,EAAOC,UAAUgwB,KAC1BlxB,QAAiBiB,EAAO1B,MAAMK,EAAKgyB,GACzC,IAAK5xB,EAAS+gB,GAAI,CACd,MAAMoT,QAAan0B,EAASiyB,OAAOC,OAAM,IAAM,KAC/C,GAAIiC,EAAK90C,SAAS,uBAAwB,CACtC,IAAI00C,EAAO,CAAC,EACZ,IACIA,EAAO3G,KAAKiF,MAAM8B,EACtB,CACA,MAAOlT,GACP,CACA,MAAM,IAAI5d,GAAyB0wB,GAAMK,aAAanrC,SAAW,GACrE,CACA,MAAM,IAAIpK,MAAM,8CAA8CmhB,EAASmyB,WAAWnyB,EAASoyB,kCAAkCxyB,mCAAqCu0B,KACtK,CAEA,aADmBn0B,EAAS+zB,QAChBM,WAChB,CAMsBC,CAA4B,CACtCrP,QAAS,EAAWlB,GAAsByP,EAAMvO,UAChDyO,kBACAjyB,UACAR,YACA,GAAG+pB,GACX,CACA,MAAO7c,GACH,KAAMA,aAAiB9K,IACnB,MAAM8K,EACV,aA9DDxmB,gBAA0CqpC,YAAawC,EAAO/xB,QAASgyB,EAAUxyB,OAAQ+wB,IAC5F,MAAMvwB,EAA2B,iBAAV+xB,EAAqB,UAAYC,GAAY,GAAoBD,GAClFvyB,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB,EAAY2Y,IAAWuwB,GACpEpyB,EAAM,GAAGqB,EAAOC,UAAU+vB,KAC1BjxB,QAAiBiB,EAAO1B,MAAMK,EAAK,CACrCT,QAAS,CAAEo1B,OAAQ,sBAEvB,IAAKv0B,EAAS+gB,GAAI,CACd,MAAM33B,QAAY4W,EAASiyB,OAAOC,OAAM,IAAM,KAC9C,MAAM,IAAIrzC,MAAM,2CAA2CmhB,EAASmyB,WAAWnyB,EAASoyB,kCAAkCxyB,mCAAqCxW,KACnK,CACA,MAAMorC,QAAsBx0B,EAASiyB,OAC/BwC,EAA2B,iBAAVjB,EACjBpxC,OAAOoxC,GACPpxC,OAAOZ,KAAK6lC,KAAKmM,EAAMhD,iBAAiBnqC,aAE9C,OADgBjE,OAAOoyC,GACNC,CACrB,CA6CqBC,CAAyB,CAAE1D,YAAawC,EAAO/xB,WAChE,CACJ,CE+E0B,CAAiB,CAAEuvB,iBAAgBY,IACrDZ,EAAYN,OAAO1F,EACvB,CACA,QAAwBznC,IAApBkuC,EAAU1G,OAA2C,OAApB0G,EAAU1G,MAAgB,CAC3D,MAAMnqB,EAAiBgxB,EAAQnwB,QAAQb,eAAeC,UAChD4d,GAAU,QAAW7d,EAAgBowB,EAAY/D,KAAKJ,kBAAkB5B,QACxE0J,QFrKPhtC,eAA0Be,GAC7B,IACI,aATRf,gBAA4B,QAAE82B,EAAO,QAAEhd,EAAU,UAAWR,OAAQ+wB,IAChE,MAAM/wB,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB,EAAY2Y,IAAWuwB,GACpEpyB,EAAM,GAAGqB,EAAOC,+BAA+Bud,WAC/Cze,QAAiBiB,EAAO1B,MAAMK,GAC9BtX,QAAe0X,EAAS+zB,OAC9B,OAAO3xC,OAAOkG,EAAOssC,oBACzB,CAGqBC,CAAansC,EAC9B,CACA,MAAO2K,GAAK,CACZ,MAAMoO,EAAU,EAAY/Y,EAAK+Y,SAAW,WACtCR,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB2Y,GAAU/Y,EAAKuY,QAC5DrB,EAAM,GAAGqB,EAAOC,UAAUiwB,MAAgBzoC,EAAK+1B,kBAC/Cze,QAAiBiB,EAAO1B,MAAMK,GACpC,IAAKI,EAAS+gB,GAAI,CACd,MAAM33B,QAAY4W,EAASiyB,OAAOC,OAAM,IAAM,KAC9C,MAAM,IAAIrzC,MAAM,kCAAkCmhB,EAASmyB,WAAWnyB,EAASoyB,kCAAkCxyB,mCAAqCxW,KAC1J,CACA,MAAM2qC,QAAc/zB,EAAS+zB,OAC7B,OAAO3xC,OAAO2xC,EAAKhJ,MACvB,CEsJ8B,CAAW,CAAEtM,aAAYmT,IAC/CZ,EAAYL,SAASgE,EACzB,CACA,OAAO3D,CACX,CCzNO,SAAS8D,GAAUC,GAKxB,MAAMC,EAAYD,EAAKjW,MAAM,KAC7B,OAAIkW,EAAU51C,OAAS,EACd,CACL61C,UAAWD,EAAU,GACrBj2B,KAAMi2B,EAAU,GAChBE,UAAWF,EAAU,IAGlB,CACLj2B,KAAMi2B,EAAU,GAChBE,UAAWF,EAAU,GAEzB,EFlBA,SAAW1D,GACPA,EAA0BA,EAA8B,GAAI,GAAK,KACjEA,EAA0BA,EAA8B,GAAI,GAAK,KACjEA,EAA0BA,EAA8B,GAAI,GAAK,KACjEA,EAA0BA,EAA+B,IAAI,GAAK,MAClEA,EAA0BA,EAA+B,IAAI,GAAK,MAClEA,EAA0BA,EAAgC,KAAI,IAAM,OACpEA,EAA0BA,EAA0B,YAAc,IAAM,UAC3E,CARD,CAQGA,KAA8BA,GAA4B,CAAC,IEavD,MAAM6D,GAAmBC,GAAqB/X,GAAQ,EAAY+X,mbCKlE,MAAMC,GAAoB,MAiCjC1tC,eAAe2tC,GACb1D,GAaA,OAAOJ,GAXwC,CAC7CjM,gBAAiBqM,EAAQnwB,QAAQd,YACjCqe,aAAcqW,GACd7P,aAAcoM,EAAQpM,aACtBE,aAAckM,EAAQlM,aACtBtB,UAAWwN,EAAQxN,UACnB0N,iBAAiB,EACjBrwB,QAASmwB,EAAQnwB,QACjB2tB,eAAgBwC,EAAQxC,gBAI5B,CASAznC,eAAe4tC,GACb3D,GAEA,OJsDKjqC,gBAAyC,aAAEq3B,EAAY,gBAAEuG,EAAe,aAAEC,EAAY,aAAEE,EAAY,cAAE8P,EAAa,QAAE/zB,EAAU,UAAWR,OAAQ+wB,IACrJ,MAAM+B,EAAO,CACT0B,OAAQD,EACRE,UAAWhQ,EAAa9yB,KAAIe,GbhEzB,KOEA,EAAW4vB,GM8D6B5vB,SAEzCi+B,EAAU,CACZsC,OAAQ,OACR/0B,QAAS,CACL,eAAgB,oBAEpBg1B,KAAM/G,KAAKC,UAAU0G,IAEnBh1B,EAAO42B,mBAAmBnQ,GAC1BvkB,EAAS/gB,OAAO4I,OAAO,CAAC,EAAG,EAAkB,EAAY2Y,IAAWuwB,GACpEpyB,EAAM,GAAGqB,EAAOC,UAAUmwB,MAA+B9L,KAAmBvG,KAAgBjgB,IAC5FiB,QAAiBiB,EAAO1B,MAAMK,EAAKgyB,GACzC,IAAK5xB,EAAS+gB,GAAI,CACd,MAAM33B,QAAY4W,EAASiyB,OAAOC,OAAM,IAAM,KAC9C,MAAM,IAAIrzC,MAAM,8CAA8CmhB,EAASmyB,WAAWnyB,EAASoyB,kCAAkCxyB,mCAAqCxW,KACtK,CACA,aAAa4W,EAAS+zB,OAAOv3B,KAAK2sB,GACtC,CI3ESyM,CAA0B,SAC5BhE,GAD4B,CAE/BrM,gBAAiBqM,EAAQnwB,QAAQd,YACjCqe,aAAcqW,KAElB,CAqBO1tC,eAAekuC,IAAgB,mBACpCC,EAAkB,QAClBr0B,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,kDASlB,OAAO02C,GAAwB,CAC7B/P,aAbsB,yBActBgQ,cAJoBnM,GADGM,MAMvBjE,aAAc,CAAC,GAAmBwP,GAAY,GAAmBn2B,IACjE0C,YACCjF,MAAMu5B,GACHA,EAAW77B,OAAS,GAAY8mB,YAC3B+U,EAAW31C,MAAM8Z,OAAS,GAAYqiB,UAKnD,CAqBO50B,eAAequC,IAAkB,UACtCd,EAAS,QACTzzB,IAUA,OAAO8zB,GAAwB,CAC7B/P,aATsB,sBAUtBgQ,cAJoBnM,GADGM,MAMvBjE,aAAc,CAAC,GAAmBwP,IAClCzzB,YACCjF,MAAMu5B,IACP,GAAIA,EAAW77B,OAAS,GAAY8mB,WAAY,CAC9C,GAAI+U,EAAW31C,MAAM8Z,OAAS,GAAYmiB,KAAO0Z,EAAW31C,MAAM8Z,OAAS,GAAYoiB,KACrF,OAAOl6B,OAAO2zC,EAAW31C,MAAMA,OAE/B,MAAM,IAAIvB,MAAM,oCAEpB,CAAO,MAAIk3C,EAAW77B,OAAS,GAAYgnB,YACnC,IAAIriC,MAAMsuC,GAAW4I,EAAW31C,QAEhC,IAAIvB,MAAM,kCAAkCyuC,GAAgByI,KACpE,GAEJ,CAqBOpuC,eAAesuC,IAAa,mBACjCH,EAAkB,QAClBr0B,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,mCASlB,OAAO02C,GAAwB,CAC7B/P,aAbsB,iBActBgQ,cAJoBnM,GADGM,MAMvBjE,aAAc,CAAC,GAAmBwP,GAAY,GAAmBn2B,IACjE0C,YACCjF,MAAMu5B,IACP,GAAIA,EAAW77B,OAAS,GAAY8mB,WAAY,CAC9C,GAAI+U,EAAW31C,MAAM8Z,OAAS,GAAYmiB,KAAO0Z,EAAW31C,MAAM8Z,OAAS,GAAYoiB,KACrF,OAAOl6B,OAAO2zC,EAAW31C,MAAMA,OAE/B,MAAM,IAAIvB,MAAM,oCAEpB,CAEE,MAAM,IAAIA,MAAMsuC,GADM4I,EACmB31C,OAC3C,GAEJ,CA6BOuH,eAAeuuC,IAAyB,UAC7ChB,EAAS,KACTiB,EAAI,UACJC,EAAS,UACThS,EAAS,QACT3iB,IAEA,MACM40B,EAAuB,EAAY,GAAGnB,IAAYiB,KAClDG,EAAwBjZ,GAAQgZ,GAEhCE,EAAyC,CAC7Cr8B,KAAM,oBACNukB,QAAS,GAAmBhd,EAAQb,eAAeC,UAAWujB,GAC9DhZ,UAAW,KACXsY,OAAQ,EAAY0S,IAGtB,OAAOd,GAAoB,CACzB9P,aAZsB,qBAatBE,aAAc,CAAC,GAAS4Q,GAAwB,GAAOF,IACvDhS,YACA3iB,UACA2tB,eAAgB,CAACmH,IAErB,CAgCO5uC,eAAe6uC,IAAuB,UAC3CtB,EAAS,KACTiB,EAAI,cACJM,EAAa,SACbC,EAAQ,uBACRC,EAAsB,UACtBvS,EAAS,QACT3iB,IAIA,OAAO6zB,GAAoB,CACzB9P,aAHsB,mBAItBE,aAAc,CACZ,GAAmBwP,GACnB,GAAmBiB,GACnB,GAAOM,EAAcptB,MACrB,GAAOotB,EAAcG,aACrB,GAAOH,EAAc5xB,IACrB,GAAO4xB,EAAc1xB,IACrB,GAAO0xB,EAAcrqB,IACrB,GAAOqqB,EAAcI,IACrB,GAAOJ,EAAcK,IACrB,GAAOL,EAAcpqB,IACrB,GAAOoqB,EAAcM,IACrB,GAAON,EAAcO,IACrB,GAAOP,EAAclqB,IACrB,GAAOkqB,EAAcQ,KACrB,GAAOR,EAAcjqB,KACrB,GAAOiqB,EAAcS,KACrB,GAAOT,EAAcU,KACrB,GAAOV,EAAcW,KACrB,GAAOX,EAAcY,KACrB,GAAOZ,EAAca,KACrB,GAAOb,EAAcc,kBACrB,GAAOd,EAAce,iBACrB,GAAOd,GACP,GAAoBC,IAEtBvS,YACA3iB,WAEJ,CA+BO9Z,eAAe8vC,IAAkB,UACtCvC,EAAS,KACTn2B,EAAI,YACJ24B,EAAW,SACXtC,EAAQ,UACRhR,EAAS,QACT3iB,IAEA,MACMk2B,EAAexC,GAAgBC,GAErC,OAAOE,GAAoB,CACzB9P,aAJsB,cAKtBE,aAAc,CACZ,GAAmBwP,GACnB,GAAmBn2B,GACnB,GAAoB24B,GACpB,GAASC,IAEXvT,YACA3iB,WAEJ,CA0BO9Z,eAAeiwC,IAAsB,UAC1C1C,EAAS,UACT9Q,EAAS,QACT3iB,IAIA,OAAO6zB,GAAoB,CACzB9P,aAHsB,kBAItBE,aAAc,CAAC,GAAmBwP,IAClC9Q,YACA3iB,WAEJ,CA6BO9Z,eAAekwC,IAAoB,mBACxC/B,EAAkB,KAClBK,EAAI,UACJC,EAAS,UACThS,EAAS,QACT3iB,IAEA,MACM,UAAEwzB,GAAcH,GAAUgB,GAChC,GAAIb,EACF,MAAM,IAAIp2C,MAAM,oDAElB,MAAMi5C,EAAmB,EAAY,GAAGhC,IAAqBK,KACvD4B,EAAmB1a,GAAQya,GAE3BvB,EAAyC,CAC7Cr8B,KAAM,oBACNukB,QAAS,GAAmBhd,EAAQb,eAAeC,UAAWujB,GAC9DhZ,UAAW,KACXsY,OAAQ,EAAY0S,IAGtB,OAAOd,GAAoB,CACzB9P,aAhBsB,gBAiBtBE,aAAc,CAAC,GAASqS,GAAmB,GAAO3B,IAClDhS,YACA3iB,UACA2tB,eAAgB,CAACmH,IAErB,CA8BO5uC,eAAeqwC,IAAoB,mBACxClC,EAAkB,KAClBK,EAAI,SACJf,EAAQ,UACRhR,EAAS,QACT3iB,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,oDAGlB,MAAM84C,EAAexC,GAAgBC,GAErC,OAAOE,GAAoB,CACzB9P,aATsB,gBAUtBE,aAAc,CACZ,GAAmBwP,GACnB,GAAmBn2B,GACnB,GAAmBo3B,GACnB,GAASwB,IAEXl2B,UACA2iB,aAEJ,CA4BOz8B,eAAeswC,IAAkB,mBACtCnC,EAAkB,SAClBV,EAAQ,UACRhR,EAAS,QACT3iB,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,gDAElB,MAAM84C,EAAexC,GAAgBC,GAErC,OAAOE,GAAoB,CACzB9P,aARsB,cAStBE,aAAc,CAAC,GAAmBwP,GAAY,GAAmBn2B,GAAO,GAAS44B,IACjFvT,YACA3iB,WAEJ,CAkCO9Z,eAAeuwC,IAAoB,mBACxCpC,EAAkB,gBAClBqC,EAAe,SACf/C,EAAQ,UACRhR,EAAS,QACT3iB,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,oDA8BlB,OAAOy2C,GAAoB,CACzB9P,aAlCsB,gBAmCtBE,aA7BmB,CACnB,GAAmBwP,GACnB,GAAmBn2B,GACnB,GAAoBo5B,GACpB/C,EAAW,GAAO,GAASD,GAAgBC,KAAc,MA0BzDhR,YACA3iB,UACA2tB,eAAgB,CA1BoC,CACpDl1B,KAAM,oBACNukB,QAAS,GAAmBhd,EAAQb,eAAeC,UAAWujB,GAC9DhZ,UAAW,OACXkY,MAAO,GAAG7hB,EAAQd,yBAClB4yB,QAASzT,GAAQ,CACf/gB,KAAM,GAAmBA,GACzBm2B,UAAW,GAAmBA,MAGsB,CACtDh7B,KAAM,oBACNukB,QAAS0Z,EACT/sB,UAAW,WACXkY,MAAO,GAAG7hB,EAAQd,yBAClB4yB,QAASzT,GAAQ,CACf/gB,KAAM,GAAmBA,GACzBm2B,UAAW,GAAmBA,QAWpC,CA0BOvtC,eAAeywC,IAAkB,mBACtCtC,EAAkB,UAClB1R,EAAS,QACT3iB,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,gDAGlB,OAAOy2C,GAAoB,CACzB9P,aAPsB,cAQtBE,aAAc,CAAC,GAAmBwP,GAAY,GAAmBn2B,IACjEqlB,YACA3iB,WAEJ,CA8BO9Z,eAAe0wC,IAAiB,mBACrCvC,EAAkB,UAClBM,EAAS,gBACT+B,EAAe,SACf/C,EAAQ,UACRhR,EAAS,QACT3iB,IAEA,MACM,UAAEwzB,EAAS,UAAEC,EAAS,KAAEn2B,GAAS+1B,GAAUgB,GACjD,GAAIb,EACF,MAAM,IAAIp2C,MAAM,8CAiBlB,OAAOy2C,GAAoB,CACzB9P,aArBsB,eAsBtBE,aAhBmB,CACnB,GAAmBwP,GACnB,GAAmBn2B,GACnB,GAAOq3B,GACP+B,EAAkB,GAAO,GAAoBA,IAAoB,KACjE/C,EAAW,GAAO,GAASD,GAAgBC,KAAc,MAYzDhR,YACA3iB,UACA2tB,eAAgB,CAZ6B,CAC7Cl1B,KAAM,oBACNukB,QAAS,GAAmBhd,EAAQb,eAAeC,UAAWujB,GAC9DhZ,UAAW,KACXsY,OAAQ,EAAY0S,MAUxB","sources":["webpack://StacksBns/webpack/universalModuleDefinition","webpack://StacksBns/webpack/runtime/create fake namespace object","webpack://StacksBns/../../node_modules/@noble/hashes/_assert.js","webpack://StacksBns/../../node_modules/@noble/hashes/_sha2.js","webpack://StacksBns/../../node_modules/@noble/hashes/cryptoBrowser.js","webpack://StacksBns/../../node_modules/@noble/hashes/sha256.js","webpack://StacksBns/../../node_modules/@noble/hashes/utils.js","webpack://StacksBns/../../node_modules/base-x/src/index.js","webpack://StacksBns/../../node_modules/c32check/lib/address.js","webpack://StacksBns/../../node_modules/c32check/lib/base58check.js","webpack://StacksBns/../../node_modules/c32check/lib/checksum.js","webpack://StacksBns/../../node_modules/c32check/lib/encoding.js","webpack://StacksBns/../../node_modules/c32check/lib/index.js","webpack://StacksBns/../../node_modules/lodash.clonedeep/index.js","webpack://StacksBns/webpack/bootstrap","webpack://StacksBns/webpack/runtime/compat get default export","webpack://StacksBns/webpack/runtime/define property getters","webpack://StacksBns/webpack/runtime/global","webpack://StacksBns/webpack/runtime/hasOwnProperty shorthand","webpack://StacksBns/webpack/runtime/make namespace object","webpack://StacksBns/webpack/runtime/node module decorator","webpack://StacksBns/../common/dist/esm/utils.js","webpack://StacksBns/../common/dist/esm/constants.js","webpack://StacksBns/../common/dist/esm/fetch.js","webpack://StacksBns/../network/dist/esm/constants.js","webpack://StacksBns/../network/dist/esm/network.js","webpack://StacksBns/../common/dist/esm/buffer.js","webpack://StacksBns/../transactions/dist/esm/constants.js","webpack://StacksBns/../transactions/dist/esm/errors.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/_assert.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/utils.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/cryptoBrowser.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/hmac.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/_sha2.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/sha256.js","webpack://StacksBns/../../node_modules/@noble/secp256k1/lib/esm/index.js","webpack://StacksBns/../common/dist/esm/signatures.js","webpack://StacksBns/../common/dist/esm/keys.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/ripemd160.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/_u64.js","webpack://StacksBns/../../node_modules/@noble/hashes/esm/sha512.js","webpack://StacksBns/../transactions/dist/esm/BytesReader.js","webpack://StacksBns/../transactions/dist/esm/clarity/constants.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/intCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/bufferCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/booleanCV.js","webpack://StacksBns/../transactions/dist/esm/wire/types.js","webpack://StacksBns/../transactions/dist/esm/wire/create.js","webpack://StacksBns/../transactions/dist/esm/wire/helpers.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/principalCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/optionalCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/tupleCV.js","webpack://StacksBns/../transactions/dist/esm/utils.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/stringCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/deserialize.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/responseCV.js","webpack://StacksBns/../transactions/dist/esm/clarity/values/listCV.js","webpack://StacksBns/../transactions/dist/esm/wire/serialization.js","webpack://StacksBns/../transactions/dist/esm/keys.js","webpack://StacksBns/../transactions/dist/esm/clarity/serialize.js","webpack://StacksBns/../transactions/dist/esm/address.js","webpack://StacksBns/../transactions/dist/esm/authorization.js","webpack://StacksBns/../transactions/dist/esm/clarity/clarityValue.js","webpack://StacksBns/../transactions/dist/esm/contract-abi.js","webpack://StacksBns/../transactions/dist/esm/transaction.js","webpack://StacksBns/../transactions/dist/esm/fetch.js","webpack://StacksBns/../transactions/dist/esm/postcondition.js","webpack://StacksBns/../transactions/dist/esm/builders.js","webpack://StacksBns/./src/utils.ts","webpack://StacksBns/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"StacksBns\"] = factory();\n\telse\n\t\troot[\"StacksBns\"] = factory();\n})(this, () => {\nreturn ","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8\|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes \|\| [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;\nfunction number(n) {\n if (!Number.isSafeInteger(n) \|\| n < 0)\n throw new Error(`Wrong positive integer: ${n}`);\n}\nexports.number = number;\nfunction bool(b) {\n if (typeof b !== 'boolean')\n throw new Error(`Expected boolean, not ${b}`);\n}\nexports.bool = bool;\nfunction bytes(b, ...lengths) {\n if (!(b instanceof Uint8Array))\n throw new TypeError('Expected Uint8Array');\n if (lengths.length > 0 && !lengths.includes(b.length))\n throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexports.bytes = bytes;\nfunction hash(hash) {\n if (typeof hash !== 'function' \|\| typeof hash.create !== 'function')\n throw new Error('Hash should be wrapped by utils.wrapConstructor');\n number(hash.outputLen);\n number(hash.blockLen);\n}\nexports.hash = hash;\nfunction exists(instance, checkFinished = true) {\n if (instance.destroyed)\n throw new Error('Hash instance has been destroyed');\n if (checkFinished && instance.finished)\n throw new Error('Hash#digest() has already been called');\n}\nexports.exists = exists;\nfunction output(out, instance) {\n bytes(out);\n const min = instance.outputLen;\n if (out.length < min) {\n throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n }\n}\nexports.output = output;\nconst assert = {\n number,\n bool,\n bytes,\n hash,\n exists,\n output,\n};\nexports.default = assert;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SHA2 = void 0;\nconst _assert_js_1 = require(\"./_assert.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n if (typeof view.setBigUint64 === 'function')\n return view.setBigUint64(byteOffset, value, isLE);\n const _32n = BigInt(32);\n const _u32_max = BigInt(0xffffffff);\n const wh = Number((value >> _32n) & _u32_max);\n const wl = Number(value & _u32_max);\n const h = isLE ? 4 : 0;\n const l = isLE ? 0 : 4;\n view.setUint32(byteOffset + h, wh, isLE);\n view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nclass SHA2 extends utils_js_1.Hash {\n constructor(blockLen, outputLen, padOffset, isLE) {\n super();\n this.blockLen = blockLen;\n this.outputLen = outputLen;\n this.padOffset = padOffset;\n this.isLE = isLE;\n this.finished = false;\n this.length = 0;\n this.pos = 0;\n this.destroyed = false;\n this.buffer = new Uint8Array(blockLen);\n this.view = (0, utils_js_1.createView)(this.buffer);\n }\n update(data) {\n _assert_js_1.default.exists(this);\n const { view, buffer, blockLen } = this;\n data = (0, utils_js_1.toBytes)(data);\n const len = data.length;\n for (let pos = 0; pos < len;) {\n const take = Math.min(blockLen - this.pos, len - pos);\n // Fast path: we have at least one block in input, cast it to view and process\n if (take === blockLen) {\n const dataView = (0, utils_js_1.createView)(data);\n for (; blockLen <= len - pos; pos += blockLen)\n this.process(dataView, pos);\n continue;\n }\n buffer.set(data.subarray(pos, pos + take), this.pos);\n this.pos += take;\n pos += take;\n if (this.pos === blockLen) {\n this.process(view, 0);\n this.pos = 0;\n }\n }\n this.length += data.length;\n this.roundClean();\n return this;\n }\n digestInto(out) {\n _assert_js_1.default.exists(this);\n _assert_js_1.default.output(out, this);\n this.finished = true;\n // Padding\n // We can avoid allocation of buffer for padding completely if it\n // was previously not allocated here. But it won't change performance.\n const { buffer, view, blockLen, isLE } = this;\n let { pos } = this;\n // append the bit '1' to the message\n buffer[pos++] = 0b10000000;\n this.buffer.subarray(pos).fill(0);\n // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n if (this.padOffset > blockLen - pos) {\n this.process(view, 0);\n pos = 0;\n }\n // Pad until full block byte with zeros\n for (let i = pos; i < blockLen; i++)\n buffer[i] = 0;\n // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n // You need to write around 2 exabytes (u64_max / 8 / (1024*6)) for this to happen.\n // So we just write lowest 64 bits of that value.\n setBigUint64(view, blockLen - 8, BigInt(this.length 8), isLE);\n this.process(view, 0);\n const oview = (0, utils_js_1.createView)(out);\n const len = this.outputLen;\n // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n if (len % 4)\n throw new Error('_sha2: outputLen should be aligned to 32bit');\n const outLen = len / 4;\n const state = this.get();\n if (outLen > state.length)\n throw new Error('_sha2: outputLen bigger than state');\n for (let i = 0; i < outLen; i++)\n oview.setUint32(4 * i, state[i], isLE);\n }\n digest() {\n const { buffer, outputLen } = this;\n this.digestInto(buffer);\n const res = buffer.slice(0, outputLen);\n this.destroy();\n return res;\n }\n _cloneInto(to) {\n to \|\| (to = new this.constructor());\n to.set(...this.get());\n const { blockLen, buffer, length, finished, destroyed, pos } = this;\n to.length = length;\n to.pos = pos;\n to.finished = finished;\n to.destroyed = destroyed;\n if (length % blockLen)\n to.buffer.set(buffer);\n return to;\n }\n}\nexports.SHA2 = SHA2;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.crypto = void 0;\nexports.crypto = {\n node: undefined,\n web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sha224 = exports.sha256 = void 0;\nconst _sha2_js_1 = require(\"./_sha2.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends _sha2_js_1.SHA2 {\n constructor() {\n super(64, 32, 8, false);\n // We cannot use array here since array allows indexing by variable\n // which means optimizer/compiler cannot use registers.\n this.A = IV[0] \| 0;\n this.B = IV[1] \| 0;\n this.C = IV[2] \| 0;\n this.D = IV[3] \| 0;\n this.E = IV[4] \| 0;\n this.F = IV[5] \| 0;\n this.G = IV[6] \| 0;\n this.H = IV[7] \| 0;\n }\n get() {\n const { A, B, C, D, E, F, G, H } = this;\n return [A, B, C, D, E, F, G, H];\n }\n // prettier-ignore\n set(A, B, C, D, E, F, G, H) {\n this.A = A \| 0;\n this.B = B \| 0;\n this.C = C \| 0;\n this.D = D \| 0;\n this.E = E \| 0;\n this.F = F \| 0;\n this.G = G \| 0;\n this.H = H \| 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4)\n SHA256_W[i] = view.getUint32(offset, false);\n for (let i = 16; i < 64; i++) {\n const W15 = SHA256_W[i - 15];\n const W2 = SHA256_W[i - 2];\n const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ (W15 >>> 3);\n const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.rotr)(W2, 19) ^ (W2 >>> 10);\n SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) \| 0;\n }\n // Compression function main loop, 64 rounds\n let { A, B, C, D, E, F, G, H } = this;\n for (let i = 0; i < 64; i++) {\n const sigma1 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);\n const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) \| 0;\n const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);\n const T2 = (sigma0 + Maj(A, B, C)) \| 0;\n H = G;\n G = F;\n F = E;\n E = (D + T1) \| 0;\n D = C;\n C = B;\n B = A;\n A = (T1 + T2) \| 0;\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) \| 0;\n B = (B + this.B) \| 0;\n C = (C + this.C) \| 0;\n D = (D + this.D) \| 0;\n E = (E + this.E) \| 0;\n F = (F + this.F) \| 0;\n G = (G + this.G) \| 0;\n H = (H + this.H) \| 0;\n this.set(A, B, C, D, E, F, G, H);\n }\n roundClean() {\n SHA256_W.fill(0);\n }\n destroy() {\n this.set(0, 0, 0, 0, 0, 0, 0, 0);\n this.buffer.fill(0);\n }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n constructor() {\n super();\n this.A = 0xc1059ed8 \| 0;\n this.B = 0x367cd507 \| 0;\n this.C = 0x3070dd17 \| 0;\n this.D = 0xf70e5939 \| 0;\n this.E = 0xffc00b31 \| 0;\n this.F = 0x68581511 \| 0;\n this.G = 0x64f98fa7 \| 0;\n this.H = 0xbefa4fa4 \| 0;\n this.outputLen = 28;\n }\n}\n/*\n SHA2-256 hash function\n * @param message - data that would be hashed\n /\nexports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256());\nexports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224());\n","\"use strict\";\n/! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) /\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.randomBytes = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;\n// The import here is via the package name. This is to ensure\n// that exports mapping/resolution does fall into place.\nconst crypto_1 = require(\"@noble/hashes/crypto\");\n// Cast array to different type\nconst u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.u8 = u8;\nconst u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\nexports.u32 = u32;\n// Cast array to view\nconst createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.createView = createView;\n// The rotate right (circular right shift) operation for uint32\nconst rotr = (word, shift) => (word << (32 - shift)) \| (word >>> shift);\nexports.rotr = rotr;\nexports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\n// So, just to be sure not to corrupt anything.\nif (!exports.isLE)\n throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/\n @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\n /\nfunction bytesToHex(uint8a) {\n // pre-caching improves the speed 6x\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Uint8Array expected');\n let hex = '';\n for (let i = 0; i < uint8a.length; i++) {\n hex += hexes[uint8a[i]];\n }\n return hex;\n}\nexports.bytesToHex = bytesToHex;\n/\n @example hexToBytes('deadbeef')\n /\nfunction hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n }\n if (hex.length % 2)\n throw new Error('hexToBytes: received invalid unpadded hex');\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\nexports.hexToBytes = hexToBytes;\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\nconst nextTick = async () => { };\nexports.nextTick = nextTick;\n// Returns control to thread each 'tick' ms to avoid blocking\nasync function asyncLoop(iters, tick, cb) {\n let ts = Date.now();\n for (let i = 0; i < iters; i++) {\n cb(i);\n // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n const diff = Date.now() - ts;\n if (diff >= 0 && diff < tick)\n continue;\n await (0, exports.nextTick)();\n ts += diff;\n }\n}\nexports.asyncLoop = asyncLoop;\nfunction utf8ToBytes(str) {\n if (typeof str !== 'string') {\n throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\n }\n return new TextEncoder().encode(str);\n}\nexports.utf8ToBytes = utf8ToBytes;\nfunction toBytes(data) {\n if (typeof data === 'string')\n data = utf8ToBytes(data);\n if (!(data instanceof Uint8Array))\n throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\n return data;\n}\nexports.toBytes = toBytes;\n/*\n Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\n * @example concatBytes(buf1, buf2)\n /\nfunction concatBytes(...arrays) {\n if (!arrays.every((a) => a instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\nexports.concatBytes = concatBytes;\n// For runtime check if class implements interface\nclass Hash {\n // Safe version that clones internal state\n clone() {\n return this._cloneInto();\n }\n}\nexports.Hash = Hash;\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nfunction checkOpts(defaults, opts) {\n if (opts !== undefined && (typeof opts !== 'object' \|\| !isPlainObject(opts)))\n throw new TypeError('Options should be object or undefined');\n const merged = Object.assign(defaults, opts);\n return merged;\n}\nexports.checkOpts = checkOpts;\nfunction wrapConstructor(hashConstructor) {\n const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\n const tmp = hashConstructor();\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = () => hashConstructor();\n return hashC;\n}\nexports.wrapConstructor = wrapConstructor;\nfunction wrapConstructorWithOpts(hashCons) {\n const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n const tmp = hashCons({});\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = (opts) => hashCons(opts);\n return hashC;\n}\nexports.wrapConstructorWithOpts = wrapConstructorWithOpts;\n/\n Secure PRNG\n /\nfunction randomBytes(bytesLength = 32) {\n if (crypto_1.crypto.web) {\n return crypto_1.crypto.web.getRandomValues(new Uint8Array(bytesLength));\n }\n else if (crypto_1.crypto.node) {\n return new Uint8Array(crypto_1.crypto.node.randomBytes(bytesLength).buffer);\n }\n else {\n throw new Error(\"The environment doesn't have randomBytes function\");\n }\n}\nexports.randomBytes = randomBytes;\n","'use strict'\n// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\nfunction base (ALPHABET) {\n if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n var BASE_MAP = new Uint8Array(256)\n for (var j = 0; j < BASE_MAP.length; j++) {\n BASE_MAP[j] = 255\n }\n for (var i = 0; i < ALPHABET.length; i++) {\n var x = ALPHABET.charAt(i)\n var xc = x.charCodeAt(0)\n if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n BASE_MAP[xc] = i\n }\n var BASE = ALPHABET.length\n var LEADER = ALPHABET.charAt(0)\n var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n function encode (source) {\n if (source instanceof Uint8Array) {\n } else if (ArrayBuffer.isView(source)) {\n source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n } else if (Array.isArray(source)) {\n source = Uint8Array.from(source)\n }\n if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }\n if (source.length === 0) { return '' }\n // Skip & count leading zeroes.\n var zeroes = 0\n var length = 0\n var pbegin = 0\n var pend = source.length\n while (pbegin !== pend && source[pbegin] === 0) {\n pbegin++\n zeroes++\n }\n // Allocate enough space in big-endian base58 representation.\n var size = ((pend - pbegin) iFACTOR + 1) >>> 0\n var b58 = new Uint8Array(size)\n // Process the bytes.\n while (pbegin !== pend) {\n var carry = source[pbegin]\n // Apply \"b58 = b58 * 256 + ch\".\n var i = 0\n for (var it1 = size - 1; (carry !== 0 \|\| i < length) && (it1 !== -1); it1--, i++) {\n carry += (256 * b58[it1]) >>> 0\n b58[it1] = (carry % BASE) >>> 0\n carry = (carry / BASE) >>> 0\n }\n if (carry !== 0) { throw new Error('Non-zero carry') }\n length = i\n pbegin++\n }\n // Skip leading zeroes in base58 result.\n var it2 = size - length\n while (it2 !== size && b58[it2] === 0) {\n it2++\n }\n // Translate the result into a string.\n var str = LEADER.repeat(zeroes)\n for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n return str\n }\n function decodeUnsafe (source) {\n if (typeof source !== 'string') { throw new TypeError('Expected String') }\n if (source.length === 0) { return new Uint8Array() }\n var psz = 0\n // Skip and count leading '1's.\n var zeroes = 0\n var length = 0\n while (source[psz] === LEADER) {\n zeroes++\n psz++\n }\n // Allocate enough space in big-endian base256 representation.\n var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n var b256 = new Uint8Array(size)\n // Process the characters.\n while (source[psz]) {\n // Decode character\n var carry = BASE_MAP[source.charCodeAt(psz)]\n // Invalid character\n if (carry === 255) { return }\n var i = 0\n for (var it3 = size - 1; (carry !== 0 \|\| i < length) && (it3 !== -1); it3--, i++) {\n carry += (BASE * b256[it3]) >>> 0\n b256[it3] = (carry % 256) >>> 0\n carry = (carry / 256) >>> 0\n }\n if (carry !== 0) { throw new Error('Non-zero carry') }\n length = i\n psz++\n }\n // Skip leading zeroes in b256.\n var it4 = size - length\n while (it4 !== size && b256[it4] === 0) {\n it4++\n }\n var vch = new Uint8Array(zeroes + (size - it4))\n var j = zeroes\n while (it4 !== size) {\n vch[j++] = b256[it4++]\n }\n return vch\n }\n function decode (string) {\n var buffer = decodeUnsafe(string)\n if (buffer) { return buffer }\n throw new Error('Non-base' + BASE + ' character')\n }\n return {\n encode: encode,\n decodeUnsafe: decodeUnsafe,\n decode: decode\n }\n}\nmodule.exports = base\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32ToB58 = exports.b58ToC32 = exports.c32addressDecode = exports.c32address = exports.versions = void 0;\nconst checksum_1 = require(\"./checksum\");\nconst base58check = require(\"./base58check\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.versions = {\n mainnet: {\n p2pkh: 22,\n p2sh: 20, // 'M'\n },\n testnet: {\n p2pkh: 26,\n p2sh: 21, // 'N'\n },\n};\n// address conversion : bitcoin to stacks\nconst ADDR_BITCOIN_TO_STACKS = {};\nADDR_BITCOIN_TO_STACKS[0] = exports.versions.mainnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[5] = exports.versions.mainnet.p2sh;\nADDR_BITCOIN_TO_STACKS[111] = exports.versions.testnet.p2pkh;\nADDR_BITCOIN_TO_STACKS[196] = exports.versions.testnet.p2sh;\n// address conversion : stacks to bitcoin\nconst ADDR_STACKS_TO_BITCOIN = {};\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2pkh] = 0;\nADDR_STACKS_TO_BITCOIN[exports.versions.mainnet.p2sh] = 5;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2pkh] = 111;\nADDR_STACKS_TO_BITCOIN[exports.versions.testnet.p2sh] = 196;\n/*\n Make a c32check address with the given version and hash160\n * The only difference between a c32check string and c32 address\n * is that the letter 'S' is pre-pended.\n * @param {number} version - the address version number\n * @param {string} hash160hex - the hash160 to encode (must be a hash160)\n * @returns {string} the address\n /\nfunction c32address(version, hash160hex) {\n if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {\n throw new Error('Invalid argument: not a hash160 hex string');\n }\n const c32string = (0, checksum_1.c32checkEncode)(version, hash160hex);\n return `S${c32string}`;\n}\nexports.c32address = c32address;\n/\n Decode a c32 address into its version and hash160\n * @param {string} c32addr - the c32check-encoded address\n * @returns {[number, string]} a tuple with the version and hash160\n /\nfunction c32addressDecode(c32addr) {\n if (c32addr.length <= 5) {\n throw new Error('Invalid c32 address: invalid length');\n }\n if (c32addr[0] != 'S') {\n throw new Error('Invalid c32 address: must start with \"S\"');\n }\n return (0, checksum_1.c32checkDecode)(c32addr.slice(1));\n}\nexports.c32addressDecode = c32addressDecode;\n/\n * Convert a base58check address to a c32check address.\n * Try to convert the version number if one is not given.\n * @param {string} b58check - the base58check encoded address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the c32 address with the given version number (or the\n * semantically-equivalent c32 version number, if not given)\n /\nfunction b58ToC32(b58check, version = -1) {\n const addrInfo = base58check.decode(b58check);\n const hash160String = (0, utils_1.bytesToHex)(addrInfo.data);\n const addrVersion = parseInt((0, utils_1.bytesToHex)(addrInfo.prefix), 16);\n let stacksVersion;\n if (version < 0) {\n stacksVersion = addrVersion;\n if (ADDR_BITCOIN_TO_STACKS[addrVersion] !== undefined) {\n stacksVersion = ADDR_BITCOIN_TO_STACKS[addrVersion];\n }\n }\n else {\n stacksVersion = version;\n }\n return c32address(stacksVersion, hash160String);\n}\nexports.b58ToC32 = b58ToC32;\n/\n * Convert a c32check address to a base58check address.\n * @param {string} c32string - the c32check address\n * @param {number} version - the version number, if not inferred from the address\n * @returns {string} the base58 address with the given version number (or the\n * semantically-equivalent bitcoin version number, if not given)\n /\nfunction c32ToB58(c32string, version = -1) {\n const addrInfo = c32addressDecode(c32string);\n const stacksVersion = addrInfo[0];\n const hash160String = addrInfo[1];\n let bitcoinVersion;\n if (version < 0) {\n bitcoinVersion = stacksVersion;\n if (ADDR_STACKS_TO_BITCOIN[stacksVersion] !== undefined) {\n bitcoinVersion = ADDR_STACKS_TO_BITCOIN[stacksVersion];\n }\n }\n else {\n bitcoinVersion = version;\n }\n let prefix = bitcoinVersion.toString(16);\n if (prefix.length === 1) {\n prefix = `0${prefix}`;\n }\n return base58check.encode(hash160String, prefix);\n}\nexports.c32ToB58 = c32ToB58;\n","/\n * From https://github.com/wzbg/base58check\n * @Author: zyc\n * @Date: 2016-09-11 23:36:05\n /\n'use strict';\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decode = exports.encode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst basex = require(\"base-x\");\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nfunction encode(data, prefix = '00') {\n const dataBytes = typeof data === 'string' ? (0, utils_1.hexToBytes)(data) : data;\n const prefixBytes = typeof prefix === 'string' ? (0, utils_1.hexToBytes)(prefix) : data;\n if (!(dataBytes instanceof Uint8Array) \|\| !(prefixBytes instanceof Uint8Array)) {\n throw new TypeError('Argument must be of type Uint8Array or string');\n }\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n return basex(ALPHABET).encode([...prefixBytes, ...dataBytes, ...checksum.slice(0, 4)]);\n}\nexports.encode = encode;\nfunction decode(string) {\n const bytes = basex(ALPHABET).decode(string);\n const prefixBytes = bytes.slice(0, 1);\n const dataBytes = bytes.slice(1, -4);\n // todo: for better performance replace spread with `concatBytes` method\n const checksum = (0, sha256_1.sha256)((0, sha256_1.sha256)(new Uint8Array([...prefixBytes, ...dataBytes])));\n bytes.slice(-4).forEach((check, index) => {\n if (check !== checksum[index]) {\n throw new Error('Invalid checksum');\n }\n });\n return { prefix: prefixBytes, data: dataBytes };\n}\nexports.decode = decode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32checkDecode = exports.c32checkEncode = void 0;\nconst sha256_1 = require(\"@noble/hashes/sha256\");\nconst utils_1 = require(\"@noble/hashes/utils\");\nconst encoding_1 = require(\"./encoding\");\n/\n Get the c32check checksum of a hex-encoded string\n * @param {string} dataHex - the hex string\n * @returns {string} the c32 checksum, as a bin-encoded string\n /\nfunction c32checksum(dataHex) {\n const dataHash = (0, sha256_1.sha256)((0, sha256_1.sha256)((0, utils_1.hexToBytes)(dataHex)));\n const checksum = (0, utils_1.bytesToHex)(dataHash.slice(0, 4));\n return checksum;\n}\n/\n Encode a hex string as a c32check string. This is a lot like how\n * base58check works in Bitcoin-land, but this algorithm uses the\n * z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * calculate the c32checksum of version + data\n * * c32encode version + data + c32checksum\n * @param {number} version - the version string (between 0 and 31)\n * @param {string} data - the data to encode\n * @returns {string} the c32check representation\n /\nfunction c32checkEncode(version, data) {\n if (version < 0 \|\| version >= 32) {\n throw new Error('Invalid version (must be between 0 and 31)');\n }\n if (!data.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Invalid data (not a hex string)');\n }\n data = data.toLowerCase();\n if (data.length % 2 !== 0) {\n data = `0${data}`;\n }\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n const checksumHex = c32checksum(`${versionHex}${data}`);\n const c32str = (0, encoding_1.c32encode)(`${data}${checksumHex}`);\n return `${encoding_1.c32[version]}${c32str}`;\n}\nexports.c32checkEncode = c32checkEncode;\n/\n Decode a c32check string back into its version and data payload. This is\n * a lot like how base58check works in Bitcoin-land, but this algorithm uses\n * the z-base-32 alphabet instead of the base58 alphabet. The algorithm\n * is as follows:\n * * extract the version, data, and checksum\n * * verify the checksum matches c32checksum(version + data)\n * * return data\n * @param {string} c32data - the c32check-encoded string\n * @returns {array} [version (number), data (string)]. The returned data\n * will be a hex string. Throws an exception if the checksum does not match.\n /\nfunction c32checkDecode(c32data) {\n c32data = (0, encoding_1.c32normalize)(c32data);\n const dataHex = (0, encoding_1.c32decode)(c32data.slice(1));\n const versionChar = c32data[0];\n const version = encoding_1.c32.indexOf(versionChar);\n const checksum = dataHex.slice(-8);\n let versionHex = version.toString(16);\n if (versionHex.length === 1) {\n versionHex = `0${versionHex}`;\n }\n if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {\n throw new Error('Invalid c32check string: checksum mismatch');\n }\n return [version, dataHex.substring(0, dataHex.length - 8)];\n}\nexports.c32checkDecode = c32checkDecode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.c32decode = exports.c32normalize = exports.c32encode = exports.c32 = void 0;\nconst utils_1 = require(\"@noble/hashes/utils\");\nexports.c32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';\nconst hex = '0123456789abcdef';\n/\n Encode a hex string as a c32 string. Note that the hex string is assumed\n * to be big-endian (and the resulting c32 string will be as well).\n * @param {string} inputHex - the input to encode\n * @param {number} minLength - the minimum length of the c32 string\n * @returns {string} the c32check-encoded representation of the data, as a string\n /\nfunction c32encode(inputHex, minLength) {\n // must be hex\n if (!inputHex.match(/^[0-9a-fA-F]$/)) {\n throw new Error('Not a hex-encoded string');\n }\n if (inputHex.length % 2 !== 0) {\n inputHex = `0${inputHex}`;\n }\n inputHex = inputHex.toLowerCase();\n let res = [];\n let carry = 0;\n for (let i = inputHex.length - 1; i >= 0; i--) {\n if (carry < 4) {\n const currentCode = hex.indexOf(inputHex[i]) >> carry;\n let nextCode = 0;\n if (i !== 0) {\n nextCode = hex.indexOf(inputHex[i - 1]);\n }\n // carry = 0, nextBits is 1, carry = 1, nextBits is 2\n const nextBits = 1 + carry;\n const nextLowBits = nextCode % (1 << nextBits) << (5 - nextBits);\n const curC32Digit = exports.c32[currentCode + nextLowBits];\n carry = nextBits;\n res.unshift(curC32Digit);\n }\n else {\n carry = 0;\n }\n }\n let C32leadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n C32leadingZeros++;\n }\n }\n res = res.slice(C32leadingZeros);\n const zeroPrefix = new TextDecoder().decode((0, utils_1.hexToBytes)(inputHex)).match(/^\\u0000/);\n const numLeadingZeroBytesInHex = zeroPrefix ? zeroPrefix[0].length : 0;\n for (let i = 0; i < numLeadingZeroBytesInHex; i++) {\n res.unshift(exports.c32[0]);\n }\n if (minLength) {\n const count = minLength - res.length;\n for (let i = 0; i < count; i++) {\n res.unshift(exports.c32[0]);\n }\n }\n return res.join('');\n}\nexports.c32encode = c32encode;\n/\n * Normalize a c32 string\n * @param {string} c32input - the c32-encoded input string\n * @returns {string} the canonical representation of the c32 input string\n /\nfunction c32normalize(c32input) {\n // must be upper-case\n // replace all O's with 0's\n // replace all I's and L's with 1's\n return c32input.toUpperCase().replace(/O/g, '0').replace(/L\|I/g, '1');\n}\nexports.c32normalize = c32normalize;\n/\n * Decode a c32 string back into a hex string. Note that the c32 input\n * string is assumed to be big-endian (and the resulting hex string will\n * be as well).\n * @param {string} c32input - the c32-encoded input to decode\n * @param {number} minLength - the minimum length of the output hex string (in bytes)\n * @returns {string} the hex-encoded representation of the data, as a string\n /\nfunction c32decode(c32input, minLength) {\n c32input = c32normalize(c32input);\n // must result in a c32 string\n if (!c32input.match(`^[${exports.c32}]$`)) {\n throw new Error('Not a c32-encoded string');\n }\n const zeroPrefix = c32input.match(`^${exports.c32[0]}`);\n const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;\n let res = [];\n let carry = 0;\n let carryBits = 0;\n for (let i = c32input.length - 1; i >= 0; i--) {\n if (carryBits === 4) {\n res.unshift(hex[carry]);\n carryBits = 0;\n carry = 0;\n }\n const currentCode = exports.c32.indexOf(c32input[i]) << carryBits;\n const currentValue = currentCode + carry;\n const currentHexDigit = hex[currentValue % 16];\n carryBits += 1;\n carry = currentValue >> 4;\n if (carry > 1 << carryBits) {\n throw new Error('Panic error in decoding.');\n }\n res.unshift(currentHexDigit);\n }\n // one last carry\n res.unshift(hex[carry]);\n if (res.length % 2 === 1) {\n res.unshift('0');\n }\n let hexLeadingZeros = 0;\n for (let i = 0; i < res.length; i++) {\n if (res[i] !== '0') {\n break;\n }\n else {\n hexLeadingZeros++;\n }\n }\n res = res.slice(hexLeadingZeros - (hexLeadingZeros % 2));\n let hexStr = res.join('');\n for (let i = 0; i < numLeadingZeroBytes; i++) {\n hexStr = `00${hexStr}`;\n }\n if (minLength) {\n const count = minLength 2 - hexStr.length;\n for (let i = 0; i < count; i += 2) {\n hexStr = `00${hexStr}`;\n }\n }\n return hexStr;\n}\nexports.c32decode = c32decode;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.b58ToC32 = exports.c32ToB58 = exports.versions = exports.c32normalize = exports.c32addressDecode = exports.c32address = exports.c32checkDecode = exports.c32checkEncode = exports.c32decode = exports.c32encode = void 0;\nconst encoding_1 = require(\"./encoding\");\nObject.defineProperty(exports, \"c32encode\", { enumerable: true, get: function () { return encoding_1.c32encode; } });\nObject.defineProperty(exports, \"c32decode\", { enumerable: true, get: function () { return encoding_1.c32decode; } });\nObject.defineProperty(exports, \"c32normalize\", { enumerable: true, get: function () { return encoding_1.c32normalize; } });\nconst checksum_1 = require(\"./checksum\");\nObject.defineProperty(exports, \"c32checkEncode\", { enumerable: true, get: function () { return checksum_1.c32checkEncode; } });\nObject.defineProperty(exports, \"c32checkDecode\", { enumerable: true, get: function () { return checksum_1.c32checkDecode; } });\nconst address_1 = require(\"./address\");\nObject.defineProperty(exports, \"c32address\", { enumerable: true, get: function () { return address_1.c32address; } });\nObject.defineProperty(exports, \"c32addressDecode\", { enumerable: true, get: function () { return address_1.c32addressDecode; } });\nObject.defineProperty(exports, \"c32ToB58\", { enumerable: true, get: function () { return address_1.c32ToB58; } });\nObject.defineProperty(exports, \"b58ToC32\", { enumerable: true, get: function () { return address_1.b58ToC32; } });\nObject.defineProperty(exports, \"versions\", { enumerable: true, get: function () { return address_1.versions; } });\n","/*\n lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n /\n\n/* Used as the size to enable large array optimizations. /\nvar LARGE_ARRAY_SIZE = 200;\n\n/* Used to stand-in for `undefined` hash values. /\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/* Used as references for various `Number` constants. /\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/* `Object#toString` result references. /\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/\n Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n /\nvar reRegExpChar = /[\\\\^$.+?()[\\]{}\|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. /\nvar reFlags = /\\w$/;\n\n/** Used to detect host constructors (Safari). /\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/* Used to detect unsigned integer values. /\nvar reIsUint = /^(?:0\|[1-9]\\d)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. /\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/* Detect free variable `global` from Node.js. /\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/* Detect free variable `self`. /\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/* Used as a reference to the global object. /\nvar root = freeGlobal \|\| freeSelf \|\| Function('return this')();\n\n/* Detect free variable `exports`. /\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/* Detect free variable `module`. /\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/* Detect the popular CommonJS extension `module.exports`. /\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/\n Adds the key-value `pair` to `map`.\n \n @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n /\nfunction addMapEntry(map, pair) {\n // Don't return `map.set` because it's not chainable in IE 11.\n map.set(pair[0], pair[1]);\n return map;\n}\n\n/\n Adds `value` to `set`.\n \n @private\n * @param {Object} set The set to modify.\n * @param {} value The value to add.\n @returns {Object} Returns `set`.\n /\nfunction addSetEntry(set, value) {\n // Don't return `set.add` because it's not chainable in IE 11.\n set.add(value);\n return set;\n}\n\n/\n A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n /\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array ? array.length : 0;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\n/\n Appends the elements of `values` to `array`.\n \n @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n /\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/\n A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n \n @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {} [accumulator] The initial value.\n @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {} Returns the accumulated value.\n /\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array ? array.length : 0;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n}\n\n/*\n The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n \n @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n /\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/\n Gets the value at `key` of `object`.\n \n @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {} Returns the property value.\n /\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/*\n Checks if `value` is a host object in IE < 9.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n /\nfunction isHostObject(value) {\n // Many host objects are `Object` objects that can coerce to strings\n // despite having improperly defined `toString` methods.\n var result = false;\n if (value != null && typeof value.toString != 'function') {\n try {\n result = !!(value + '');\n } catch (e) {}\n }\n return result;\n}\n\n/\n Converts `map` to its key-value pairs.\n \n @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n /\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\n/\n Creates a unary function that invokes `func` with its argument transformed.\n \n @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n /\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/\n Converts `set` to an array of its values.\n \n @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n /\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\n/* Used for built-in method references. /\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/* Used to detect overreaching core-js shims. /\nvar coreJsData = root['__core-js_shared__'];\n\n/* Used to detect methods masquerading as native. /\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO \|\| '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/* Used to resolve the decompiled source of functions. /\nvar funcToString = funcProto.toString;\n\n/* Used to check objects for own properties. /\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/\n Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n /\nvar objectToString = objectProto.toString;\n\n/* Used to detect if a method is native. /\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty\|(function).?(?=\\\\\\()\| for .+?(?=\\\\\\])/g, '$1.?') + '$'\n);\n\n/* Built-in value references. /\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice;\n\n/ Built-in method references for those with the same name as other `lodash` methods. /\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeKeys = overArg(Object.keys, Object);\n\n/ Built-in method references that are verified to be native. /\nvar DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n/* Used to detect maps, sets, and weakmaps. /\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/* Used to convert symbols to primitives and strings. /\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/\n Creates a hash object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Hash(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the hash.\n \n @private\n * @name clear\n * @memberOf Hash\n /\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/\n Removes `key` and its value from the hash.\n \n @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction hashDelete(key) {\n return this.has(key) && delete this.__data__[key];\n}\n\n/\n Gets the hash value for `key`.\n \n @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/*\n Checks if a hash value for `key` exists.\n \n @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/\n Sets the hash `key` to `value`.\n \n @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the hash instance.\n /\nfunction hashSet(key, value) {\n var data = this.__data__;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/\n Creates an list cache object.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction ListCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the list cache.\n \n @private\n * @name clear\n * @memberOf ListCache\n /\nfunction listCacheClear() {\n this.__data__ = [];\n}\n\n/\n Removes `key` and its value from the list cache.\n \n @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n return true;\n}\n\n/\n Gets the list cache value for `key`.\n \n @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/*\n Checks if a list cache value for `key` exists.\n \n @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/\n Sets the list cache `key` to `value`.\n \n @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the list cache instance.\n /\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/\n Creates a map cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction MapCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/\n Removes all key-value entries from the map.\n \n @private\n * @name clear\n * @memberOf MapCache\n /\nfunction mapCacheClear() {\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map \|\| ListCache),\n 'string': new Hash\n };\n}\n\n/\n Removes `key` and its value from the map.\n \n @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction mapCacheDelete(key) {\n return getMapData(this, key)['delete'](key);\n}\n\n/\n Gets the map value for `key`.\n \n @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/*\n Checks if a map value for `key` exists.\n \n @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/\n Sets the map `key` to `value`.\n \n @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the map cache instance.\n /\nfunction mapCacheSet(key, value) {\n getMapData(this, key).set(key, value);\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/\n Creates a stack cache object to store key-value pairs.\n \n @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n /\nfunction Stack(entries) {\n this.__data__ = new ListCache(entries);\n}\n\n/\n Removes all key-value entries from the stack.\n \n @private\n * @name clear\n * @memberOf Stack\n /\nfunction stackClear() {\n this.__data__ = new ListCache;\n}\n\n/\n Removes `key` and its value from the stack.\n \n @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n /\nfunction stackDelete(key) {\n return this.__data__['delete'](key);\n}\n\n/\n Gets the stack value for `key`.\n \n @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {} Returns the entry value.\n /\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/*\n Checks if a stack value for `key` exists.\n \n @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n /\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/\n Sets the stack `key` to `value`.\n \n @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {} value The value to set.\n @returns {Object} Returns the stack cache instance.\n /\nfunction stackSet(key, value) {\n var cache = this.__data__;\n if (cache instanceof ListCache) {\n var pairs = cache.__data__;\n if (!Map \|\| (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n return this;\n }\n cache = this.__data__ = new MapCache(pairs);\n }\n cache.set(key, value);\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/\n Creates an array of the enumerable property names of the array-like `value`.\n \n @private\n * @param {} value The value to query.\n @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n /\nfunction arrayLikeKeys(value, inherited) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n // Safari 9 makes `arguments.length` enumerable in strict mode.\n var result = (isArray(value) \|\| isArguments(value))\n ? baseTimes(value.length, String)\n : [];\n\n var length = result.length,\n skipIndexes = !!length;\n\n for (var key in value) {\n if ((inherited \|\| hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (key == 'length' \|\| isIndex(key, length)))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n \n @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {} value The value to assign.\n /\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) \|\|\n (value === undefined && !(key in object))) {\n object[key] = value;\n }\n}\n\n/*\n Gets the index at which the `key` is found in `array` of key-value pairs.\n \n @private\n * @param {Array} array The array to inspect.\n * @param {} key The key to search for.\n @returns {number} Returns the index of the matched value, else `-1`.\n /\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/\n The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n \n @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n /\nfunction baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n}\n\n/\n The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n \n @private\n * @param {} value The value to clone.\n @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {} Returns the cloned value.\n /\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n var result;\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag \|\| tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag \|\| tag == argsTag \|\| (isFunc && !object)) {\n if (isHostObject(value)) {\n return object ? value : {};\n }\n result = initCloneObject(isFunc ? {} : value);\n if (!isDeep) {\n return copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, baseClone, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack \|\| (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (!isArr) {\n var props = isFull ? getAllKeys(value) : keys(value);\n }\n arrayEach(props \|\| value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n });\n return result;\n}\n\n/*\n The base implementation of `_.create` without support for assigning\n * properties to the created object.\n \n @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n /\nfunction baseCreate(proto) {\n return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/\n The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/\n The base implementation of `getTag`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nfunction baseGetTag(value) {\n return objectToString.call(value);\n}\n\n/\n The base implementation of `_.isNative` without bad shim checks.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n /\nfunction baseIsNative(value) {\n if (!isObject(value) \|\| isMasked(value)) {\n return false;\n }\n var pattern = (isFunction(value) \|\| isHostObject(value)) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/\n The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n /\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\n/\n Creates a clone of `buffer`.\n \n @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n /\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var result = new buffer.constructor(buffer.length);\n buffer.copy(result);\n return result;\n}\n\n/\n Creates a clone of `arrayBuffer`.\n \n @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n /\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\n/\n Creates a clone of `dataView`.\n \n @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n /\nfunction cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/\n Creates a clone of `map`.\n \n @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n /\nfunction cloneMap(map, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/\n Creates a clone of `regexp`.\n \n @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n /\nfunction cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n}\n\n/\n Creates a clone of `set`.\n \n @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n /\nfunction cloneSet(set, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/\n Creates a clone of the `symbol` object.\n \n @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n /\nfunction cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/\n Creates a clone of `typedArray`.\n \n @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n /\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/\n Copies the values of `source` to `array`.\n \n @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n /\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array \|\| (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\n/\n Copies properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n /\nfunction copyObject(source, props, object, customizer) {\n object \|\| (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n assignValue(object, key, newValue === undefined ? source[key] : newValue);\n }\n return object;\n}\n\n/\n Copies own symbol properties of `source` to `object`.\n \n @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n /\nfunction copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n}\n\n/\n Creates an array of own enumerable property names and symbols of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n /\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/\n Gets the data for `map`.\n \n @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {} Returns the map data.\n /\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/*\n Gets the native function at `key` of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {} Returns the function if it's native, else `undefined`.\n /\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/*\n Creates an array of the own enumerable symbol properties of `object`.\n \n @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n /\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/\n Gets the `toStringTag` of `value`.\n \n @private\n * @param {} value The value to query.\n @returns {string} Returns the `toStringTag`.\n /\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) \|\|\n (Map && getTag(new Map) != mapTag) \|\|\n (Promise && getTag(Promise.resolve()) != promiseTag) \|\|\n (Set && getTag(new Set) != setTag) \|\|\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = objectToString.call(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : undefined;\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\n/\n Initializes an array clone.\n \n @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n /\nfunction initCloneArray(array) {\n var length = array.length,\n result = array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n}\n\n/\n Initializes an object clone.\n \n @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\n/\n Initializes an object clone based on its `toStringTag`.\n \n Note: This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n \n @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n /\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return cloneMap(object, isDeep, cloneFunc);\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return cloneSet(object, isDeep, cloneFunc);\n\n case symbolTag:\n return cloneSymbol(object);\n }\n}\n\n/\n Checks if `value` is a valid array-like index.\n \n @private\n * @param {} value The value to check.\n @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n /\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' \|\| reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/\n Checks if `value` is suitable for use as unique object key.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n /\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' \|\| type == 'number' \|\| type == 'symbol' \|\| type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/\n Checks if `func` has its source masked.\n \n @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n /\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/\n Checks if `value` is likely a prototype object.\n \n @private\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n /\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) \|\| objectProto;\n\n return value === proto;\n}\n\n/\n Converts `func` to its source code.\n \n @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n /\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/\n This method is like `_.clone` except that it recursively clones `value`.\n \n @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {} value The value to recursively clone.\n @returns {} Returns the deep cloned value.\n @see _.clone\n * @example\n \n var objects = [{ 'a': 1 }, { 'b': 2 }];\n \n var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n /\nfunction cloneDeep(value) {\n return baseClone(value, true, true);\n}\n\n/\n Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to compare.\n @param {} other The other value to compare.\n @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n \n var object = { 'a': 1 };\n * var other = { 'a': 1 };\n \n _.eq(object, object);\n * // => true\n \n _.eq(object, other);\n * // => false\n \n _.eq('a', 'a');\n * // => true\n \n _.eq('a', Object('a'));\n * // => false\n \n _.eq(NaN, NaN);\n * // => true\n /\nfunction eq(value, other) {\n return value === other \|\| (value !== value && other !== other);\n}\n\n/\n Checks if `value` is likely an `arguments` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n \n _.isArguments(function() { return arguments; }());\n * // => true\n \n _.isArguments([1, 2, 3]);\n * // => false\n /\nfunction isArguments(value) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n (!propertyIsEnumerable.call(value, 'callee') \|\| objectToString.call(value) == argsTag);\n}\n\n/\n Checks if `value` is classified as an `Array` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n \n _.isArray([1, 2, 3]);\n * // => true\n \n _.isArray(document.body.children);\n * // => false\n \n _.isArray('abc');\n * // => false\n \n _.isArray(_.noop);\n * // => false\n /\nvar isArray = Array.isArray;\n\n/\n Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n \n _.isArrayLike([1, 2, 3]);\n * // => true\n \n _.isArrayLike(document.body.children);\n * // => true\n \n _.isArrayLike('abc');\n * // => true\n \n _.isArrayLike(_.noop);\n * // => false\n /\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/\n This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n \n _.isArrayLikeObject([1, 2, 3]);\n * // => true\n \n _.isArrayLikeObject(document.body.children);\n * // => true\n \n _.isArrayLikeObject('abc');\n * // => false\n \n _.isArrayLikeObject(_.noop);\n * // => false\n /\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/\n Checks if `value` is a buffer.\n \n @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n \n _.isBuffer(new Buffer(2));\n * // => true\n \n _.isBuffer(new Uint8Array(2));\n * // => false\n /\nvar isBuffer = nativeIsBuffer \|\| stubFalse;\n\n/\n Checks if `value` is classified as a `Function` object.\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n \n _.isFunction(_);\n * // => true\n \n _.isFunction(/abc/);\n * // => false\n /\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag \|\| tag == genTag;\n}\n\n/\n Checks if `value` is a valid array-like length.\n \n Note: This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n \n _.isLength(3);\n * // => true\n \n _.isLength(Number.MIN_VALUE);\n * // => false\n \n _.isLength(Infinity);\n * // => false\n \n _.isLength('3');\n * // => false\n /\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/\n Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n \n @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n \n _.isObject({});\n * // => true\n \n _.isObject([1, 2, 3]);\n * // => true\n \n _.isObject(_.noop);\n * // => true\n \n _.isObject(null);\n * // => false\n /\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' \|\| type == 'function');\n}\n\n/\n Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n \n @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {} value The value to check.\n @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n \n _.isObjectLike({});\n * // => true\n \n _.isObjectLike([1, 2, 3]);\n * // => true\n \n _.isObjectLike(_.noop);\n * // => false\n \n _.isObjectLike(null);\n * // => false\n /\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/\n Creates an array of the own enumerable property names of `object`.\n \n Note: Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n \n @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n \n function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n \n Foo.prototype.c = 3;\n \n _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n \n _.keys('hi');\n * // => ['0', '1']\n /\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/\n This method returns a new empty array.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n \n var arrays = _.times(2, _.stubArray);\n \n console.log(arrays);\n * // => [[], []]\n \n console.log(arrays[0] === arrays[1]);\n * // => false\n /\nfunction stubArray() {\n return [];\n}\n\n/\n This method returns `false`.\n \n @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n \n _.times(2, _.stubFalse);\n * // => [false, false]\n /\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = cloneDeep;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this \|\| new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import { Logger } from './logger';\nexport const BLOCKSTACK_HANDLER = 'blockstack';\nexport function nextYear() {\n return new Date(new Date().setFullYear(new Date().getFullYear() + 1));\n}\nexport function nextMonth() {\n return new Date(new Date().setMonth(new Date().getMonth() + 1));\n}\nexport function nextHour() {\n return new Date(new Date().setHours(new Date().getHours() + 1));\n}\nexport function megabytesToBytes(megabytes) {\n if (!Number.isFinite(megabytes)) {\n return 0;\n }\n return Math.floor(megabytes 1024 * 1024);\n}\nexport function getAesCbcOutputLength(inputByteLength) {\n const cipherTextLength = (Math.floor(inputByteLength / 16) + 1) * 16;\n return cipherTextLength;\n}\nexport function getBase64OutputLength(inputByteLength) {\n const encodedLength = Math.ceil(inputByteLength / 3) * 4;\n return encodedLength;\n}\nexport function updateQueryStringParameter(uri, key, value) {\n const re = new RegExp(`([?&])${key}=.?(&\|$)`, 'i');\n const separator = uri.indexOf('?') !== -1 ? '&' : '?';\n if (uri.match(re)) {\n return uri.replace(re, `$1${key}=${value}$2`);\n }\n else {\n return `${uri}${separator}${key}=${value}`;\n }\n}\nexport function isLaterVersion(v1, v2) {\n if (v1 === undefined \|\| v1 === '') {\n v1 = '0.0.0';\n }\n if (v2 === undefined \|\| v1 === '') {\n v2 = '0.0.0';\n }\n const v1tuple = v1.split('.').map(x => parseInt(x, 10));\n const v2tuple = v2.split('.').map(x => parseInt(x, 10));\n for (let index = 0; index < v2.length; index++) {\n if (index >= v1.length) {\n v2tuple.push(0);\n }\n if (v1tuple[index] < v2tuple[index]) {\n return false;\n }\n }\n return true;\n}\nexport function makeUUID4() {\n let d = new Date().getTime();\n if (typeof performance !== 'undefined' && typeof performance.now === 'function') {\n d += performance.now();\n }\n return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n const r = (d + Math.random() 16) % 16 \| 0;\n d = Math.floor(d / 16);\n return (c === 'x' ? r : (r & 0x3) \| 0x8).toString(16);\n });\n}\nexport function isSameOriginAbsoluteUrl(uri1, uri2) {\n try {\n const parsedUri1 = new URL(uri1);\n const parsedUri2 = new URL(uri2);\n const port1 = parseInt(parsedUri1.port \|\| '0', 10) \| 0 \|\| (parsedUri1.protocol === 'https:' ? 443 : 80);\n const port2 = parseInt(parsedUri2.port \|\| '0', 10) \| 0 \|\| (parsedUri2.protocol === 'https:' ? 443 : 80);\n const match = {\n scheme: parsedUri1.protocol === parsedUri2.protocol,\n hostname: parsedUri1.hostname === parsedUri2.hostname,\n port: port1 === port2,\n absolute: (uri1.includes('http://') \|\| uri1.includes('https://')) &&\n (uri2.includes('http://') \|\| uri2.includes('https://')),\n };\n return match.scheme && match.hostname && match.port && match.absolute;\n }\n catch (error) {\n console.log(error);\n console.log('Parsing error in same URL origin check');\n return false;\n }\n}\nexport function getGlobalScope() {\n if (typeof self !== 'undefined') {\n return self;\n }\n if (typeof window !== 'undefined') {\n return window;\n }\n if (typeof global !== 'undefined') {\n return global;\n }\n throw new Error('Unexpected runtime environment - no supported global scope (`window`, `self`, `global`) available');\n}\nfunction getAPIUsageErrorMessage(scopeObject, apiName, usageDesc) {\n if (usageDesc) {\n return `Use of '${usageDesc}' requires \\`${apiName}\\` which is unavailable on the '${scopeObject}' object within the currently executing environment.`;\n }\n else {\n return `\\`${apiName}\\` is unavailable on the '${scopeObject}' object within the currently executing environment.`;\n }\n}\nexport function getGlobalObject(name, { throwIfUnavailable, usageDesc, returnEmptyObject } = {}) {\n let globalScope = undefined;\n try {\n globalScope = getGlobalScope();\n if (globalScope) {\n const obj = globalScope[name];\n if (obj) {\n return obj;\n }\n }\n }\n catch (error) {\n Logger.error(`Error getting object '${name}' from global scope '${globalScope}': ${error}`);\n }\n if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n Logger.error(errMsg);\n throw new Error(errMsg);\n }\n if (returnEmptyObject) {\n return {};\n }\n return undefined;\n}\nexport function getGlobalObjects(names, { throwIfUnavailable, usageDesc, returnEmptyObject } = {}) {\n let globalScope;\n try {\n globalScope = getGlobalScope();\n }\n catch (error) {\n Logger.error(`Error getting global scope: ${error}`);\n if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, names[0].toString(), usageDesc);\n Logger.error(errMsg);\n throw errMsg;\n }\n else if (returnEmptyObject) {\n globalScope = {};\n }\n }\n const result = {};\n for (let i = 0; i < names.length; i++) {\n const name = names[i];\n try {\n if (globalScope) {\n const obj = globalScope[name];\n if (obj) {\n result[name] = obj;\n }\n else if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n Logger.error(errMsg);\n throw new Error(errMsg);\n }\n else if (returnEmptyObject) {\n result[name] = {};\n }\n }\n }\n catch (error) {\n if (throwIfUnavailable) {\n const errMsg = getAPIUsageErrorMessage(globalScope, name.toString(), usageDesc);\n Logger.error(errMsg);\n throw new Error(errMsg);\n }\n }\n }\n return result;\n}\nexport function intToBytes(value, byteLength) {\n return bigIntToBytes(intToBigInt(value), byteLength);\n}\nexport function intToBigInt(value) {\n if (typeof value === 'bigint')\n return value;\n if (typeof value === 'string')\n return BigInt(value);\n if (typeof value === 'number') {\n if (!Number.isInteger(value)) {\n throw new RangeError(`Invalid value. Values of type 'number' must be an integer.`);\n }\n if (value > Number.MAX_SAFE_INTEGER) {\n throw new RangeError(`Invalid value. Values of type 'number' must be less than or equal to ${Number.MAX_SAFE_INTEGER}. For larger values, try using a BigInt instead.`);\n }\n return BigInt(value);\n }\n if (isInstance(value, Uint8Array))\n return BigInt(`0x${bytesToHex(value)}`);\n throw new TypeError(`intToBigInt: Invalid value type. Must be a number, bigint, BigInt-compatible string, or Uint8Array.`);\n}\nexport function with0x(value) {\n return /^0x/i.test(value)\n ? value\n : `0x${value}`;\n}\nexport function without0x(value) {\n return /^0x/i.test(value)\n ? value.slice(2)\n : value;\n}\nexport function hexToBigInt(hex) {\n if (typeof hex !== 'string')\n throw new TypeError(`hexToBigInt: expected string, got ${typeof hex}`);\n return BigInt(`0x${hex}`);\n}\nexport function intToHex(integer, byteLength = 8) {\n const value = typeof integer === 'bigint' ? integer : intToBigInt(integer);\n return value.toString(16).padStart(byteLength * 2, '0');\n}\nexport function hexToInt(hex) {\n return parseInt(hex, 16);\n}\nexport function bigIntToBytes(value, length = 16) {\n const hex = intToHex(value, length);\n return hexToBytes(hex);\n}\nexport function toTwos(value, width) {\n if (value < -(BigInt(1) << (width - BigInt(1))) \|\|\n (BigInt(1) << (width - BigInt(1))) - BigInt(1) < value) {\n throw `Unable to represent integer in width: ${width}`;\n }\n if (value >= BigInt(0)) {\n return BigInt(value);\n }\n return value + (BigInt(1) << width);\n}\nfunction nthBit(value, n) {\n return value & (BigInt(1) << n);\n}\nexport function bytesToTwosBigInt(bytes) {\n return fromTwos(BigInt(`0x${bytesToHex(bytes)}`), BigInt(bytes.byteLength * 8));\n}\nexport function fromTwos(value, width) {\n if (nthBit(value, width - BigInt(1))) {\n return value - (BigInt(1) << width);\n }\n return value;\n}\nconst hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\nexport function bytesToHex(uint8a) {\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Uint8Array expected');\n let hex = '';\n for (const u of uint8a) {\n hex += hexes[u];\n }\n return hex;\n}\nexport function hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError(`hexToBytes: expected string, got ${typeof hex}`);\n }\n hex = without0x(hex);\n hex = hex.length % 2 ? `0${hex}` : hex;\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i * 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\nexport function utf8ToBytes(str) {\n return new TextEncoder().encode(str);\n}\nexport function bytesToUtf8(arr) {\n return new TextDecoder().decode(arr);\n}\nexport function asciiToBytes(str) {\n const byteArray = [];\n for (let i = 0; i < str.length; i++) {\n byteArray.push(str.charCodeAt(i) & 0xff);\n }\n return new Uint8Array(byteArray);\n}\nexport function bytesToAscii(arr) {\n return String.fromCharCode.apply(null, arr);\n}\nfunction isNotOctet(octet) {\n return !Number.isInteger(octet) \|\| octet < 0 \|\| octet > 255;\n}\nexport function octetsToBytes(numbers) {\n if (numbers.some(isNotOctet))\n throw new Error('Some values are invalid bytes.');\n return new Uint8Array(numbers);\n}\nexport function concatBytes(...arrays) {\n if (!arrays.every(a => a instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\nexport function concatArray(elements) {\n return concatBytes(...elements.map(e => {\n if (typeof e === 'number')\n return octetsToBytes([e]);\n if (e instanceof Array)\n return octetsToBytes(e);\n return e;\n }));\n}\nexport function isInstance(object, clazz) {\n return object instanceof clazz \|\| object?.constructor?.name?.toLowerCase() === clazz.name;\n}\nexport function validateHash256(hex) {\n hex = without0x(hex);\n if (hex.length !== 64)\n return false;\n return /^[0-9a-fA-F]+$/.test(hex);\n}\n//# sourceMappingURL=utils.js.map","export const HIRO_MAINNET_URL = 'https://api.mainnet.hiro.so';\nexport const HIRO_TESTNET_URL = 'https://api.testnet.hiro.so';\nexport const DEVNET_URL = 'http://localhost:3999';\nexport const GAIA_URL = 'https://hub.blockstack.org';\nexport const PRIVATE_KEY_BYTES_COMPRESSED = 33;\nexport const PRIVATE_KEY_BYTES_UNCOMPRESSED = 32;\n//# sourceMappingURL=constants.js.map","const defaultFetchOpts = {\n referrerPolicy: 'origin',\n headers: {\n 'x-hiro-product': 'stacksjs',\n },\n};\nexport const getFetchOptions = () => {\n return defaultFetchOpts;\n};\nexport const setFetchOptions = (ops) => {\n return Object.assign(defaultFetchOpts, ops);\n};\nexport async function fetchWrapper(input, init) {\n const fetchOpts = {};\n Object.assign(fetchOpts, defaultFetchOpts, init);\n const fetchResult = await fetch(input, fetchOpts);\n return fetchResult;\n}\nexport function hostMatches(host, pattern) {\n if (typeof pattern === 'string')\n return pattern === host;\n return pattern.exec(host);\n}\nexport function createApiKeyMiddleware({ apiKey, host = /(.)api(.)(\\.stacks\\.co\|\\.hiro\\.so)$/i, httpHeader = 'x-api-key', }) {\n return {\n pre: context => {\n const reqUrl = new URL(context.url);\n if (!hostMatches(reqUrl.host, host))\n return;\n const headers = context.init.headers instanceof Headers\n ? context.init.headers\n : (context.init.headers = new Headers(context.init.headers));\n headers.set(httpHeader, apiKey);\n },\n };\n}\nfunction argsForCreateFetchFn(args) {\n let fetchLib = fetchWrapper;\n let middlewares = [];\n if (args.length > 0 && typeof args[0] === 'function') {\n fetchLib = args.shift();\n }\n if (args.length > 0) {\n middlewares = args;\n }\n return { fetchLib, middlewares };\n}\nexport function createFetchFn(...args) {\n const { fetchLib, middlewares } = argsForCreateFetchFn(args);\n const fetchFn = async (url, init) => {\n let fetchParams = { url, init: init ?? {} };\n for (const middleware of middlewares) {\n if (typeof middleware.pre === 'function') {\n const result = await Promise.resolve(middleware.pre({\n fetch: fetchLib,\n ...fetchParams,\n }));\n fetchParams = result ?? fetchParams;\n }\n }\n let response = await fetchLib(fetchParams.url, fetchParams.init);\n for (const middleware of middlewares) {\n if (typeof middleware.post === 'function') {\n const result = await Promise.resolve(middleware.post({\n fetch: fetchLib,\n url: fetchParams.url,\n init: fetchParams.init,\n response: response?.clone() ?? response,\n }));\n response = result ?? response;\n }\n }\n return response;\n };\n return fetchFn;\n}\n//# sourceMappingURL=fetch.js.map","export var ChainId;\n(function (ChainId) {\n ChainId[ChainId[\"Mainnet\"] = 1] = \"Mainnet\";\n ChainId[ChainId[\"Testnet\"] = 2147483648] = \"Testnet\";\n})(ChainId \|\| (ChainId = {}));\nexport var PeerNetworkId;\n(function (PeerNetworkId) {\n PeerNetworkId[PeerNetworkId[\"Mainnet\"] = 385875968] = \"Mainnet\";\n PeerNetworkId[PeerNetworkId[\"Testnet\"] = 4278190080] = \"Testnet\";\n})(PeerNetworkId \|\| (PeerNetworkId = {}));\nexport const DEFAULT_CHAIN_ID = ChainId.Mainnet;\nexport var TransactionVersion;\n(function (TransactionVersion) {\n TransactionVersion[TransactionVersion[\"Mainnet\"] = 0] = \"Mainnet\";\n TransactionVersion[TransactionVersion[\"Testnet\"] = 128] = \"Testnet\";\n})(TransactionVersion \|\| (TransactionVersion = {}));\nexport var AddressVersion;\n(function (AddressVersion) {\n AddressVersion[AddressVersion[\"MainnetSingleSig\"] = 22] = \"MainnetSingleSig\";\n AddressVersion[AddressVersion[\"MainnetMultiSig\"] = 20] = \"MainnetMultiSig\";\n AddressVersion[AddressVersion[\"TestnetSingleSig\"] = 26] = \"TestnetSingleSig\";\n AddressVersion[AddressVersion[\"TestnetMultiSig\"] = 21] = \"TestnetMultiSig\";\n})(AddressVersion \|\| (AddressVersion = {}));\nexport const DEFAULT_TRANSACTION_VERSION = TransactionVersion.Mainnet;\nexport function whenTransactionVersion(transactionVersion) {\n return (map) => map[transactionVersion];\n}\n//# sourceMappingURL=constants.js.map","import { DEVNET_URL, HIRO_MAINNET_URL, HIRO_TESTNET_URL, createFetchFn, createApiKeyMiddleware, } from '@stacks/common';\nimport { AddressVersion, ChainId, PeerNetworkId, TransactionVersion } from './constants';\nexport const STACKS_MAINNET = {\n chainId: ChainId.Mainnet,\n transactionVersion: TransactionVersion.Mainnet,\n peerNetworkId: PeerNetworkId.Mainnet,\n magicBytes: 'X2',\n bootAddress: 'SP000000000000000000002Q6VF78',\n addressVersion: {\n singleSig: AddressVersion.MainnetSingleSig,\n multiSig: AddressVersion.MainnetMultiSig,\n },\n client: { baseUrl: HIRO_MAINNET_URL },\n};\nexport const STACKS_TESTNET = {\n chainId: ChainId.Testnet,\n transactionVersion: TransactionVersion.Testnet,\n peerNetworkId: PeerNetworkId.Testnet,\n magicBytes: 'T2',\n bootAddress: 'ST000000000000000000002AMW42H',\n addressVersion: {\n singleSig: AddressVersion.TestnetSingleSig,\n multiSig: AddressVersion.TestnetMultiSig,\n },\n client: { baseUrl: HIRO_TESTNET_URL },\n};\nexport const STACKS_DEVNET = {\n ...STACKS_TESTNET,\n addressVersion: { ...STACKS_TESTNET.addressVersion },\n magicBytes: 'id',\n client: { baseUrl: DEVNET_URL },\n};\nexport const STACKS_MOCKNET = {\n ...STACKS_DEVNET,\n addressVersion: { ...STACKS_DEVNET.addressVersion },\n client: { ...STACKS_DEVNET.client },\n};\nexport const StacksNetworks = ['mainnet', 'testnet', 'devnet', 'mocknet'];\nexport function networkFromName(name) {\n switch (name) {\n case 'mainnet':\n return STACKS_MAINNET;\n case 'testnet':\n return STACKS_TESTNET;\n case 'devnet':\n return STACKS_DEVNET;\n case 'mocknet':\n return STACKS_MOCKNET;\n default:\n throw new Error(`Unknown network name: ${name}`);\n }\n}\nexport function networkFrom(network) {\n if (typeof network === 'string')\n return networkFromName(network);\n return network;\n}\nexport function defaultUrlFromNetwork(network) {\n if (!network)\n return HIRO_MAINNET_URL;\n network = networkFrom(network);\n return !network \|\| network.transactionVersion === TransactionVersion.Mainnet\n ? HIRO_MAINNET_URL\n : network.magicBytes === 'id'\n ? DEVNET_URL\n : HIRO_TESTNET_URL;\n}\nexport function clientFromNetwork(network) {\n if (network.client.fetch)\n return network.client;\n return {\n ...network.client,\n fetch: createFetchFn(),\n };\n}\nexport function createNetwork(arg1, arg2) {\n const baseNetwork = networkFrom(typeof arg1 === 'object' && 'network' in arg1 ? arg1.network : arg1);\n const newNetwork = {\n ...baseNetwork,\n addressVersion: { ...baseNetwork.addressVersion },\n client: { ...baseNetwork.client },\n };\n if (typeof arg1 === 'object' && 'network' in arg1) {\n if (arg1.client) {\n newNetwork.client.baseUrl = arg1.client.baseUrl ?? newNetwork.client.baseUrl;\n newNetwork.client.fetch = arg1.client.fetch ?? newNetwork.client.fetch;\n }\n if (typeof arg1.apiKey === 'string') {\n const middleware = createApiKeyMiddleware(arg1);\n newNetwork.client.fetch = newNetwork.client.fetch\n ? createFetchFn(newNetwork.client.fetch, middleware)\n : createFetchFn(middleware);\n }\n return newNetwork;\n }\n if (typeof arg2 === 'string') {\n const middleware = createApiKeyMiddleware({ apiKey: arg2 });\n newNetwork.client.fetch = newNetwork.client.fetch\n ? createFetchFn(newNetwork.client.fetch, middleware)\n : createFetchFn(middleware);\n return newNetwork;\n }\n return newNetwork;\n}\n//# sourceMappingURL=network.js.map","export function equals(a, b) {\n if (a.byteLength !== b.byteLength)\n return false;\n for (let i = 0; i < a.byteLength; i++) {\n if (a[i] !== b[i])\n return false;\n }\n return true;\n}\nexport function alloc(length, value) {\n const a = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n a[i] = value;\n }\n return a;\n}\nexport function readUInt16BE(source, offset) {\n return ((source[offset + 0] << 8) \| source[offset + 1]) >>> 0;\n}\nexport function writeUInt16BE(destination, value, offset = 0) {\n destination[offset + 0] = value >>> 8;\n destination[offset + 1] = value >>> 0;\n return destination;\n}\nexport function readUInt8(source, offset) {\n return source[offset];\n}\nexport function writeUInt8(destination, value, offset = 0) {\n destination[offset] = value;\n return destination;\n}\nexport function readUInt16LE(source, offset) {\n return ((source[offset + 0] << 0) >>> 0) \| ((source[offset + 1] << 8) >>> 0);\n}\nexport function writeUInt16LE(destination, value, offset = 0) {\n destination[offset + 0] = value & 255;\n value >>>= 8;\n destination[offset + 1] = value & 255;\n return destination;\n}\nexport function readUInt32BE(source, offset) {\n return (source[offset] * 2 ** 24 +\n source[offset + 1] * 2 ** 16 +\n source[offset + 2] * 2 ** 8 +\n source[offset + 3]);\n}\nexport function writeUInt32BE(destination, value, offset = 0) {\n destination[offset + 3] = value;\n value >>>= 8;\n destination[offset + 2] = value;\n value >>>= 8;\n destination[offset + 1] = value;\n value >>>= 8;\n destination[offset] = value;\n return destination;\n}\nexport function readUInt32LE(source, offset) {\n return (((source[offset + 0] << 0) >>> 0) \|\n ((source[offset + 1] << 8) >>> 0) \|\n ((source[offset + 2] << 16) >>> 0) \|\n ((source[offset + 3] << 24) >>> 0));\n}\nexport function writeUInt32LE(destination, value, offset = 0) {\n destination[offset + 0] = value & 255;\n value >>>= 8;\n destination[offset + 1] = value & 255;\n value >>>= 8;\n destination[offset + 2] = value & 255;\n value >>>= 8;\n destination[offset + 3] = value & 255;\n return destination;\n}\n//# sourceMappingURL=buffer.js.map","export const BLOCKSTACK_DEFAULT_GAIA_HUB_URL = 'https://hub.blockstack.org';\nexport const MAX_STRING_LENGTH_BYTES = 128;\nexport const CLARITY_INT_SIZE = 128;\nexport const CLARITY_INT_BYTE_SIZE = 16;\nexport const COINBASE_BYTES_LENGTH = 32;\nexport const VRF_PROOF_BYTES_LENGTH = 80;\nexport const RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;\nexport const COMPRESSED_PUBKEY_LENGTH_BYTES = 32;\nexport const UNCOMPRESSED_PUBKEY_LENGTH_BYTES = 64;\nexport const MEMO_MAX_LENGTH_BYTES = 34;\nconst MAX_PAYLOAD_LEN = 1 + 16 * 1024 * 1024;\nconst PREAMBLE_ENCODED_SIZE = 165;\nconst MAX_RELAYERS_LEN = 16;\nconst PEER_ADDRESS_ENCODED_SIZE = 16;\nconst HASH160_ENCODED_SIZE = 20;\nconst NEIGHBOR_ADDRESS_ENCODED_SIZE = PEER_ADDRESS_ENCODED_SIZE + 2 + HASH160_ENCODED_SIZE;\nconst RELAY_DATA_ENCODED_SIZE = NEIGHBOR_ADDRESS_ENCODED_SIZE + 4;\nexport const STRING_MAX_LENGTH = MAX_PAYLOAD_LEN + (PREAMBLE_ENCODED_SIZE + MAX_RELAYERS_LEN * RELAY_DATA_ENCODED_SIZE);\nexport var PayloadType;\n(function (PayloadType) {\n PayloadType[PayloadType[\"TokenTransfer\"] = 0] = \"TokenTransfer\";\n PayloadType[PayloadType[\"SmartContract\"] = 1] = \"SmartContract\";\n PayloadType[PayloadType[\"VersionedSmartContract\"] = 6] = \"VersionedSmartContract\";\n PayloadType[PayloadType[\"ContractCall\"] = 2] = \"ContractCall\";\n PayloadType[PayloadType[\"PoisonMicroblock\"] = 3] = \"PoisonMicroblock\";\n PayloadType[PayloadType[\"Coinbase\"] = 4] = \"Coinbase\";\n PayloadType[PayloadType[\"CoinbaseToAltRecipient\"] = 5] = \"CoinbaseToAltRecipient\";\n PayloadType[PayloadType[\"TenureChange\"] = 7] = \"TenureChange\";\n PayloadType[PayloadType[\"NakamotoCoinbase\"] = 8] = \"NakamotoCoinbase\";\n})(PayloadType \|\| (PayloadType = {}));\nexport var ClarityVersion;\n(function (ClarityVersion) {\n ClarityVersion[ClarityVersion[\"Clarity1\"] = 1] = \"Clarity1\";\n ClarityVersion[ClarityVersion[\"Clarity2\"] = 2] = \"Clarity2\";\n ClarityVersion[ClarityVersion[\"Clarity3\"] = 3] = \"Clarity3\";\n})(ClarityVersion \|\| (ClarityVersion = {}));\nexport var AnchorMode;\n(function (AnchorMode) {\n AnchorMode[AnchorMode[\"OnChainOnly\"] = 1] = \"OnChainOnly\";\n AnchorMode[AnchorMode[\"OffChainOnly\"] = 2] = \"OffChainOnly\";\n AnchorMode[AnchorMode[\"Any\"] = 3] = \"Any\";\n})(AnchorMode \|\| (AnchorMode = {}));\nexport const AnchorModeNames = ['onChainOnly', 'offChainOnly', 'any'];\nconst AnchorModeMap = {\n [AnchorModeNames[0]]: AnchorMode.OnChainOnly,\n [AnchorModeNames[1]]: AnchorMode.OffChainOnly,\n [AnchorModeNames[2]]: AnchorMode.Any,\n [AnchorMode.OnChainOnly]: AnchorMode.OnChainOnly,\n [AnchorMode.OffChainOnly]: AnchorMode.OffChainOnly,\n [AnchorMode.Any]: AnchorMode.Any,\n};\nexport function anchorModeFrom(mode) {\n if (mode in AnchorModeMap)\n return AnchorModeMap[mode];\n throw new Error(`Invalid anchor mode \"${mode}\", must be one of: ${AnchorModeNames.join(', ')}`);\n}\nexport var PostConditionMode;\n(function (PostConditionMode) {\n PostConditionMode[PostConditionMode[\"Allow\"] = 1] = \"Allow\";\n PostConditionMode[PostConditionMode[\"Deny\"] = 2] = \"Deny\";\n})(PostConditionMode \|\| (PostConditionMode = {}));\nexport var PostConditionType;\n(function (PostConditionType) {\n PostConditionType[PostConditionType[\"STX\"] = 0] = \"STX\";\n PostConditionType[PostConditionType[\"Fungible\"] = 1] = \"Fungible\";\n PostConditionType[PostConditionType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(PostConditionType \|\| (PostConditionType = {}));\nexport var AuthType;\n(function (AuthType) {\n AuthType[AuthType[\"Standard\"] = 4] = \"Standard\";\n AuthType[AuthType[\"Sponsored\"] = 5] = \"Sponsored\";\n})(AuthType \|\| (AuthType = {}));\nexport var AddressHashMode;\n(function (AddressHashMode) {\n AddressHashMode[AddressHashMode[\"P2PKH\"] = 0] = \"P2PKH\";\n AddressHashMode[AddressHashMode[\"P2SH\"] = 1] = \"P2SH\";\n AddressHashMode[AddressHashMode[\"P2WPKH\"] = 2] = \"P2WPKH\";\n AddressHashMode[AddressHashMode[\"P2WSH\"] = 3] = \"P2WSH\";\n AddressHashMode[AddressHashMode[\"P2SHNonSequential\"] = 5] = \"P2SHNonSequential\";\n AddressHashMode[AddressHashMode[\"P2WSHNonSequential\"] = 7] = \"P2WSHNonSequential\";\n})(AddressHashMode \|\| (AddressHashMode = {}));\nexport { AddressVersion } from '@stacks/network';\nexport var PubKeyEncoding;\n(function (PubKeyEncoding) {\n PubKeyEncoding[PubKeyEncoding[\"Compressed\"] = 0] = \"Compressed\";\n PubKeyEncoding[PubKeyEncoding[\"Uncompressed\"] = 1] = \"Uncompressed\";\n})(PubKeyEncoding \|\| (PubKeyEncoding = {}));\nexport var FungibleConditionCode;\n(function (FungibleConditionCode) {\n FungibleConditionCode[FungibleConditionCode[\"Equal\"] = 1] = \"Equal\";\n FungibleConditionCode[FungibleConditionCode[\"Greater\"] = 2] = \"Greater\";\n FungibleConditionCode[FungibleConditionCode[\"GreaterEqual\"] = 3] = \"GreaterEqual\";\n FungibleConditionCode[FungibleConditionCode[\"Less\"] = 4] = \"Less\";\n FungibleConditionCode[FungibleConditionCode[\"LessEqual\"] = 5] = \"LessEqual\";\n})(FungibleConditionCode \|\| (FungibleConditionCode = {}));\nexport var NonFungibleConditionCode;\n(function (NonFungibleConditionCode) {\n NonFungibleConditionCode[NonFungibleConditionCode[\"Sends\"] = 16] = \"Sends\";\n NonFungibleConditionCode[NonFungibleConditionCode[\"DoesNotSend\"] = 17] = \"DoesNotSend\";\n})(NonFungibleConditionCode \|\| (NonFungibleConditionCode = {}));\nexport var PostConditionPrincipalId;\n(function (PostConditionPrincipalId) {\n PostConditionPrincipalId[PostConditionPrincipalId[\"Origin\"] = 1] = \"Origin\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Standard\"] = 2] = \"Standard\";\n PostConditionPrincipalId[PostConditionPrincipalId[\"Contract\"] = 3] = \"Contract\";\n})(PostConditionPrincipalId \|\| (PostConditionPrincipalId = {}));\nexport var AssetType;\n(function (AssetType) {\n AssetType[AssetType[\"STX\"] = 0] = \"STX\";\n AssetType[AssetType[\"Fungible\"] = 1] = \"Fungible\";\n AssetType[AssetType[\"NonFungible\"] = 2] = \"NonFungible\";\n})(AssetType \|\| (AssetType = {}));\nexport var TenureChangeCause;\n(function (TenureChangeCause) {\n TenureChangeCause[TenureChangeCause[\"BlockFound\"] = 0] = \"BlockFound\";\n TenureChangeCause[TenureChangeCause[\"Extended\"] = 1] = \"Extended\";\n})(TenureChangeCause \|\| (TenureChangeCause = {}));\nexport var AuthFieldType;\n(function (AuthFieldType) {\n AuthFieldType[AuthFieldType[\"PublicKeyCompressed\"] = 0] = \"PublicKeyCompressed\";\n AuthFieldType[AuthFieldType[\"PublicKeyUncompressed\"] = 1] = \"PublicKeyUncompressed\";\n AuthFieldType[AuthFieldType[\"SignatureCompressed\"] = 2] = \"SignatureCompressed\";\n AuthFieldType[AuthFieldType[\"SignatureUncompressed\"] = 3] = \"SignatureUncompressed\";\n})(AuthFieldType \|\| (AuthFieldType = {}));\nexport var TxRejectedReason;\n(function (TxRejectedReason) {\n TxRejectedReason[\"Serialization\"] = \"Serialization\";\n TxRejectedReason[\"Deserialization\"] = \"Deserialization\";\n TxRejectedReason[\"SignatureValidation\"] = \"SignatureValidation\";\n TxRejectedReason[\"FeeTooLow\"] = \"FeeTooLow\";\n TxRejectedReason[\"BadNonce\"] = \"BadNonce\";\n TxRejectedReason[\"NotEnoughFunds\"] = \"NotEnoughFunds\";\n TxRejectedReason[\"NoSuchContract\"] = \"NoSuchContract\";\n TxRejectedReason[\"NoSuchPublicFunction\"] = \"NoSuchPublicFunction\";\n TxRejectedReason[\"BadFunctionArgument\"] = \"BadFunctionArgument\";\n TxRejectedReason[\"ContractAlreadyExists\"] = \"ContractAlreadyExists\";\n TxRejectedReason[\"PoisonMicroblocksDoNotConflict\"] = \"PoisonMicroblocksDoNotConflict\";\n TxRejectedReason[\"PoisonMicroblockHasUnknownPubKeyHash\"] = \"PoisonMicroblockHasUnknownPubKeyHash\";\n TxRejectedReason[\"PoisonMicroblockIsInvalid\"] = \"PoisonMicroblockIsInvalid\";\n TxRejectedReason[\"BadAddressVersionByte\"] = \"BadAddressVersionByte\";\n TxRejectedReason[\"NoCoinbaseViaMempool\"] = \"NoCoinbaseViaMempool\";\n TxRejectedReason[\"ServerFailureNoSuchChainTip\"] = \"ServerFailureNoSuchChainTip\";\n TxRejectedReason[\"ServerFailureDatabase\"] = \"ServerFailureDatabase\";\n TxRejectedReason[\"ServerFailureOther\"] = \"ServerFailureOther\";\n})(TxRejectedReason \|\| (TxRejectedReason = {}));\n//# sourceMappingURL=constants.js.map","class TransactionError extends Error {\n constructor(message) {\n super(message);\n this.message = message;\n this.name = this.constructor.name;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, this.constructor);\n }\n }\n}\nexport class SerializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class DeserializationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NoEstimateAvailableError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class NotImplementedError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class SigningError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\nexport class VerificationError extends TransactionError {\n constructor(message) {\n super(message);\n }\n}\n//# sourceMappingURL=errors.js.map","export function number(n) {\n if (!Number.isSafeInteger(n) \|\| n < 0)\n throw new Error(`Wrong positive integer: ${n}`);\n}\nexport function bool(b) {\n if (typeof b !== 'boolean')\n throw new Error(`Expected boolean, not ${b}`);\n}\nexport function bytes(b, ...lengths) {\n if (!(b instanceof Uint8Array))\n throw new TypeError('Expected Uint8Array');\n if (lengths.length > 0 && !lengths.includes(b.length))\n throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexport function hash(hash) {\n if (typeof hash !== 'function' \|\| typeof hash.create !== 'function')\n throw new Error('Hash should be wrapped by utils.wrapConstructor');\n number(hash.outputLen);\n number(hash.blockLen);\n}\nexport function exists(instance, checkFinished = true) {\n if (instance.destroyed)\n throw new Error('Hash instance has been destroyed');\n if (checkFinished && instance.finished)\n throw new Error('Hash#digest() has already been called');\n}\nexport function output(out, instance) {\n bytes(out);\n const min = instance.outputLen;\n if (out.length < min) {\n throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n }\n}\nconst assert = {\n number,\n bool,\n bytes,\n hash,\n exists,\n output,\n};\nexport default assert;\n","/! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) /\n// The import here is via the package name. This is to ensure\n// that exports mapping/resolution does fall into place.\nimport { crypto } from '@noble/hashes/crypto';\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) \| (word >>> shift);\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\n// So, just to be sure not to corrupt anything.\nif (!isLE)\n throw new Error('Non little-endian hardware is not supported');\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/*\n @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\n /\nexport function bytesToHex(uint8a) {\n // pre-caching improves the speed 6x\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Uint8Array expected');\n let hex = '';\n for (let i = 0; i < uint8a.length; i++) {\n hex += hexes[uint8a[i]];\n }\n return hex;\n}\n/\n @example hexToBytes('deadbeef')\n /\nexport function hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n }\n if (hex.length % 2)\n throw new Error('hexToBytes: received invalid unpadded hex');\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n let ts = Date.now();\n for (let i = 0; i < iters; i++) {\n cb(i);\n // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n const diff = Date.now() - ts;\n if (diff >= 0 && diff < tick)\n continue;\n await nextTick();\n ts += diff;\n }\n}\nexport function utf8ToBytes(str) {\n if (typeof str !== 'string') {\n throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\n }\n return new TextEncoder().encode(str);\n}\nexport function toBytes(data) {\n if (typeof data === 'string')\n data = utf8ToBytes(data);\n if (!(data instanceof Uint8Array))\n throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\n return data;\n}\n/*\n Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\n * @example concatBytes(buf1, buf2)\n /\nexport function concatBytes(...arrays) {\n if (!arrays.every((a) => a instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\n// For runtime check if class implements interface\nexport class Hash {\n // Safe version that clones internal state\n clone() {\n return this._cloneInto();\n }\n}\n// Check if object doens't have custom constructor (like Uint8Array/Array)\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\nexport function checkOpts(defaults, opts) {\n if (opts !== undefined && (typeof opts !== 'object' \|\| !isPlainObject(opts)))\n throw new TypeError('Options should be object or undefined');\n const merged = Object.assign(defaults, opts);\n return merged;\n}\nexport function wrapConstructor(hashConstructor) {\n const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\n const tmp = hashConstructor();\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = () => hashConstructor();\n return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n const tmp = hashCons({});\n hashC.outputLen = tmp.outputLen;\n hashC.blockLen = tmp.blockLen;\n hashC.create = (opts) => hashCons(opts);\n return hashC;\n}\n/\n Secure PRNG\n /\nexport function randomBytes(bytesLength = 32) {\n if (crypto.web) {\n return crypto.web.getRandomValues(new Uint8Array(bytesLength));\n }\n else if (crypto.node) {\n return new Uint8Array(crypto.node.randomBytes(bytesLength).buffer);\n }\n else {\n throw new Error(\"The environment doesn't have randomBytes function\");\n }\n}\n","export const crypto = {\n node: undefined,\n web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\n","import assert from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nclass HMAC extends Hash {\n constructor(hash, _key) {\n super();\n this.finished = false;\n this.destroyed = false;\n assert.hash(hash);\n const key = toBytes(_key);\n this.iHash = hash.create();\n if (typeof this.iHash.update !== 'function')\n throw new TypeError('Expected instance of class which extends utils.Hash');\n this.blockLen = this.iHash.blockLen;\n this.outputLen = this.iHash.outputLen;\n const blockLen = this.blockLen;\n const pad = new Uint8Array(blockLen);\n // blockLen can be bigger than outputLen\n pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n for (let i = 0; i < pad.length; i++)\n pad[i] ^= 0x36;\n this.iHash.update(pad);\n // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n this.oHash = hash.create();\n // Undo internal XOR && apply outer XOR\n for (let i = 0; i < pad.length; i++)\n pad[i] ^= 0x36 ^ 0x5c;\n this.oHash.update(pad);\n pad.fill(0);\n }\n update(buf) {\n assert.exists(this);\n this.iHash.update(buf);\n return this;\n }\n digestInto(out) {\n assert.exists(this);\n assert.bytes(out, this.outputLen);\n this.finished = true;\n this.iHash.digestInto(out);\n this.oHash.update(out);\n this.oHash.digestInto(out);\n this.destroy();\n }\n digest() {\n const out = new Uint8Array(this.oHash.outputLen);\n this.digestInto(out);\n return out;\n }\n _cloneInto(to) {\n // Create new instance without calling constructor since key already in state and we don't know it.\n to \|\| (to = Object.create(Object.getPrototypeOf(this), {}));\n const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n to = to;\n to.finished = finished;\n to.destroyed = destroyed;\n to.blockLen = blockLen;\n to.outputLen = outputLen;\n to.oHash = oHash._cloneInto(to.oHash);\n to.iHash = iHash._cloneInto(to.iHash);\n return to;\n }\n destroy() {\n this.destroyed = true;\n this.oHash.destroy();\n this.iHash.destroy();\n }\n}\n/\n HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n /\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n","import assert from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n if (typeof view.setBigUint64 === 'function')\n return view.setBigUint64(byteOffset, value, isLE);\n const _32n = BigInt(32);\n const _u32_max = BigInt(0xffffffff);\n const wh = Number((value >> _32n) & _u32_max);\n const wl = Number(value & _u32_max);\n const h = isLE ? 4 : 0;\n const l = isLE ? 0 : 4;\n view.setUint32(byteOffset + h, wh, isLE);\n view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n constructor(blockLen, outputLen, padOffset, isLE) {\n super();\n this.blockLen = blockLen;\n this.outputLen = outputLen;\n this.padOffset = padOffset;\n this.isLE = isLE;\n this.finished = false;\n this.length = 0;\n this.pos = 0;\n this.destroyed = false;\n this.buffer = new Uint8Array(blockLen);\n this.view = createView(this.buffer);\n }\n update(data) {\n assert.exists(this);\n const { view, buffer, blockLen } = this;\n data = toBytes(data);\n const len = data.length;\n for (let pos = 0; pos < len;) {\n const take = Math.min(blockLen - this.pos, len - pos);\n // Fast path: we have at least one block in input, cast it to view and process\n if (take === blockLen) {\n const dataView = createView(data);\n for (; blockLen <= len - pos; pos += blockLen)\n this.process(dataView, pos);\n continue;\n }\n buffer.set(data.subarray(pos, pos + take), this.pos);\n this.pos += take;\n pos += take;\n if (this.pos === blockLen) {\n this.process(view, 0);\n this.pos = 0;\n }\n }\n this.length += data.length;\n this.roundClean();\n return this;\n }\n digestInto(out) {\n assert.exists(this);\n assert.output(out, this);\n this.finished = true;\n // Padding\n // We can avoid allocation of buffer for padding completely if it\n // was previously not allocated here. But it won't change performance.\n const { buffer, view, blockLen, isLE } = this;\n let { pos } = this;\n // append the bit '1' to the message\n buffer[pos++] = 0b10000000;\n this.buffer.subarray(pos).fill(0);\n // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n if (this.padOffset > blockLen - pos) {\n this.process(view, 0);\n pos = 0;\n }\n // Pad until full block byte with zeros\n for (let i = pos; i < blockLen; i++)\n buffer[i] = 0;\n // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n // You need to write around 2 exabytes (u64_max / 8 / (10246)) for this to happen.\n // So we just write lowest 64 bits of that value.\n setBigUint64(view, blockLen - 8, BigInt(this.length 8), isLE);\n this.process(view, 0);\n const oview = createView(out);\n const len = this.outputLen;\n // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n if (len % 4)\n throw new Error('_sha2: outputLen should be aligned to 32bit');\n const outLen = len / 4;\n const state = this.get();\n if (outLen > state.length)\n throw new Error('_sha2: outputLen bigger than state');\n for (let i = 0; i < outLen; i++)\n oview.setUint32(4 * i, state[i], isLE);\n }\n digest() {\n const { buffer, outputLen } = this;\n this.digestInto(buffer);\n const res = buffer.slice(0, outputLen);\n this.destroy();\n return res;\n }\n _cloneInto(to) {\n to \|\| (to = new this.constructor());\n to.set(...this.get());\n const { blockLen, buffer, length, finished, destroyed, pos } = this;\n to.length = length;\n to.pos = pos;\n to.finished = finished;\n to.destroyed = destroyed;\n if (length % blockLen)\n to.buffer.set(buffer);\n return to;\n }\n}\n","import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = new Uint32Array([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = new Uint32Array([\n 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = new Uint32Array(64);\nclass SHA256 extends SHA2 {\n constructor() {\n super(64, 32, 8, false);\n // We cannot use array here since array allows indexing by variable\n // which means optimizer/compiler cannot use registers.\n this.A = IV[0] \| 0;\n this.B = IV[1] \| 0;\n this.C = IV[2] \| 0;\n this.D = IV[3] \| 0;\n this.E = IV[4] \| 0;\n this.F = IV[5] \| 0;\n this.G = IV[6] \| 0;\n this.H = IV[7] \| 0;\n }\n get() {\n const { A, B, C, D, E, F, G, H } = this;\n return [A, B, C, D, E, F, G, H];\n }\n // prettier-ignore\n set(A, B, C, D, E, F, G, H) {\n this.A = A \| 0;\n this.B = B \| 0;\n this.C = C \| 0;\n this.D = D \| 0;\n this.E = E \| 0;\n this.F = F \| 0;\n this.G = G \| 0;\n this.H = H \| 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4)\n SHA256_W[i] = view.getUint32(offset, false);\n for (let i = 16; i < 64; i++) {\n const W15 = SHA256_W[i - 15];\n const W2 = SHA256_W[i - 2];\n const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) \| 0;\n }\n // Compression function main loop, 64 rounds\n let { A, B, C, D, E, F, G, H } = this;\n for (let i = 0; i < 64; i++) {\n const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) \| 0;\n const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n const T2 = (sigma0 + Maj(A, B, C)) \| 0;\n H = G;\n G = F;\n F = E;\n E = (D + T1) \| 0;\n D = C;\n C = B;\n B = A;\n A = (T1 + T2) \| 0;\n }\n // Add the compressed chunk to the current hash value\n A = (A + this.A) \| 0;\n B = (B + this.B) \| 0;\n C = (C + this.C) \| 0;\n D = (D + this.D) \| 0;\n E = (E + this.E) \| 0;\n F = (F + this.F) \| 0;\n G = (G + this.G) \| 0;\n H = (H + this.H) \| 0;\n this.set(A, B, C, D, E, F, G, H);\n }\n roundClean() {\n SHA256_W.fill(0);\n }\n destroy() {\n this.set(0, 0, 0, 0, 0, 0, 0, 0);\n this.buffer.fill(0);\n }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n constructor() {\n super();\n this.A = 0xc1059ed8 \| 0;\n this.B = 0x367cd507 \| 0;\n this.C = 0x3070dd17 \| 0;\n this.D = 0xf70e5939 \| 0;\n this.E = 0xffc00b31 \| 0;\n this.F = 0x68581511 \| 0;\n this.G = 0x64f98fa7 \| 0;\n this.H = 0xbefa4fa4 \| 0;\n this.outputLen = 28;\n }\n}\n/*\n SHA2-256 hash function\n * @param message - data that would be hashed\n /\nexport const sha256 = wrapConstructor(() => new SHA256());\nexport const sha224 = wrapConstructor(() => new SHA224());\n","/! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) /\nimport as nodeCrypto from 'crypto';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst _3n = BigInt(3);\nconst _8n = BigInt(8);\nconst CURVE = Object.freeze({\n a: _0n,\n b: BigInt(7),\n P: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\n n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\n h: _1n,\n Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n});\nconst divNearest = (a, b) => (a + b / _2n) / b;\nconst endo = {\n beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n splitScalar(k) {\n const { n } = CURVE;\n const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n const b2 = a1;\n const POW_2_128 = BigInt('0x100000000000000000000000000000000');\n const c1 = divNearest(b2 * k, n);\n const c2 = divNearest(-b1 * k, n);\n let k1 = mod(k - c1 * a1 - c2 * a2, n);\n let k2 = mod(-c1 * b1 - c2 * b2, n);\n const k1neg = k1 > POW_2_128;\n const k2neg = k2 > POW_2_128;\n if (k1neg)\n k1 = n - k1;\n if (k2neg)\n k2 = n - k2;\n if (k1 > POW_2_128 \|\| k2 > POW_2_128) {\n throw new Error('splitScalarEndo: Endomorphism failed, k=' + k);\n }\n return { k1neg, k1, k2neg, k2 };\n },\n};\nconst fieldLen = 32;\nconst groupLen = 32;\nconst hashLen = 32;\nconst compressedLen = fieldLen + 1;\nconst uncompressedLen = 2 * fieldLen + 1;\nexport { CURVE };\nfunction weierstrass(x) {\n const { a, b } = CURVE;\n const x2 = mod(x * x);\n const x3 = mod(x2 * x);\n return mod(x3 + a * x + b);\n}\nconst USE_ENDOMORPHISM = CURVE.a === _0n;\nclass ShaError extends Error {\n constructor(message) {\n super(message);\n }\n}\nfunction assertJacPoint(other) {\n if (!(other instanceof JacobianPoint))\n throw new TypeError('JacobianPoint expected');\n}\nclass JacobianPoint {\n constructor(x, y, z) {\n this.x = x;\n this.y = y;\n this.z = z;\n }\n static fromAffine(p) {\n if (!(p instanceof Point)) {\n throw new TypeError('JacobianPoint#fromAffine: expected Point');\n }\n if (p.equals(Point.ZERO))\n return JacobianPoint.ZERO;\n return new JacobianPoint(p.x, p.y, _1n);\n }\n static toAffineBatch(points) {\n const toInv = invertBatch(points.map((p) => p.z));\n return points.map((p, i) => p.toAffine(toInv[i]));\n }\n static normalizeZ(points) {\n return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine);\n }\n equals(other) {\n assertJacPoint(other);\n const { x: X1, y: Y1, z: Z1 } = this;\n const { x: X2, y: Y2, z: Z2 } = other;\n const Z1Z1 = mod(Z1 * Z1);\n const Z2Z2 = mod(Z2 * Z2);\n const U1 = mod(X1 * Z2Z2);\n const U2 = mod(X2 * Z1Z1);\n const S1 = mod(mod(Y1 * Z2) * Z2Z2);\n const S2 = mod(mod(Y2 * Z1) * Z1Z1);\n return U1 === U2 && S1 === S2;\n }\n negate() {\n return new JacobianPoint(this.x, mod(-this.y), this.z);\n }\n double() {\n const { x: X1, y: Y1, z: Z1 } = this;\n const A = mod(X1 * X1);\n const B = mod(Y1 * Y1);\n const C = mod(B * B);\n const x1b = X1 + B;\n const D = mod(_2n * (mod(x1b * x1b) - A - C));\n const E = mod(_3n * A);\n const F = mod(E * E);\n const X3 = mod(F - _2n * D);\n const Y3 = mod(E * (D - X3) - _8n * C);\n const Z3 = mod(_2n * Y1 * Z1);\n return new JacobianPoint(X3, Y3, Z3);\n }\n add(other) {\n assertJacPoint(other);\n const { x: X1, y: Y1, z: Z1 } = this;\n const { x: X2, y: Y2, z: Z2 } = other;\n if (X2 === _0n \|\| Y2 === _0n)\n return this;\n if (X1 === _0n \|\| Y1 === _0n)\n return other;\n const Z1Z1 = mod(Z1 * Z1);\n const Z2Z2 = mod(Z2 * Z2);\n const U1 = mod(X1 * Z2Z2);\n const U2 = mod(X2 * Z1Z1);\n const S1 = mod(mod(Y1 * Z2) * Z2Z2);\n const S2 = mod(mod(Y2 * Z1) * Z1Z1);\n const H = mod(U2 - U1);\n const r = mod(S2 - S1);\n if (H === _0n) {\n if (r === _0n) {\n return this.double();\n }\n else {\n return JacobianPoint.ZERO;\n }\n }\n const HH = mod(H * H);\n const HHH = mod(H * HH);\n const V = mod(U1 * HH);\n const X3 = mod(r * r - HHH - _2n * V);\n const Y3 = mod(r * (V - X3) - S1 * HHH);\n const Z3 = mod(Z1 * Z2 * H);\n return new JacobianPoint(X3, Y3, Z3);\n }\n subtract(other) {\n return this.add(other.negate());\n }\n multiplyUnsafe(scalar) {\n const P0 = JacobianPoint.ZERO;\n if (typeof scalar === 'bigint' && scalar === _0n)\n return P0;\n let n = normalizeScalar(scalar);\n if (n === _1n)\n return this;\n if (!USE_ENDOMORPHISM) {\n let p = P0;\n let d = this;\n while (n > _0n) {\n if (n & _1n)\n p = p.add(d);\n d = d.double();\n n >>= _1n;\n }\n return p;\n }\n let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n let k1p = P0;\n let k2p = P0;\n let d = this;\n while (k1 > _0n \|\| k2 > _0n) {\n if (k1 & _1n)\n k1p = k1p.add(d);\n if (k2 & _1n)\n k2p = k2p.add(d);\n d = d.double();\n k1 >>= _1n;\n k2 >>= _1n;\n }\n if (k1neg)\n k1p = k1p.negate();\n if (k2neg)\n k2p = k2p.negate();\n k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);\n return k1p.add(k2p);\n }\n precomputeWindow(W) {\n const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1;\n const points = [];\n let p = this;\n let base = p;\n for (let window = 0; window < windows; window++) {\n base = p;\n points.push(base);\n for (let i = 1; i < 2 (W - 1); i++) {\n base = base.add(p);\n points.push(base);\n }\n p = base.double();\n }\n return points;\n }\n wNAF(n, affinePoint) {\n if (!affinePoint && this.equals(JacobianPoint.BASE))\n affinePoint = Point.BASE;\n const W = (affinePoint && affinePoint._WINDOW_SIZE) \|\| 1;\n if (256 % W) {\n throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');\n }\n let precomputes = affinePoint && pointPrecomputes.get(affinePoint);\n if (!precomputes) {\n precomputes = this.precomputeWindow(W);\n if (affinePoint && W !== 1) {\n precomputes = JacobianPoint.normalizeZ(precomputes);\n pointPrecomputes.set(affinePoint, precomputes);\n }\n }\n let p = JacobianPoint.ZERO;\n let f = JacobianPoint.BASE;\n const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W);\n const windowSize = 2 (W - 1);\n const mask = BigInt(2 W - 1);\n const maxNumber = 2 W;\n const shiftBy = BigInt(W);\n for (let window = 0; window < windows; window++) {\n const offset = window * windowSize;\n let wbits = Number(n & mask);\n n >>= shiftBy;\n if (wbits > windowSize) {\n wbits -= maxNumber;\n n += _1n;\n }\n const offset1 = offset;\n const offset2 = offset + Math.abs(wbits) - 1;\n const cond1 = window % 2 !== 0;\n const cond2 = wbits < 0;\n if (wbits === 0) {\n f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n }\n else {\n p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n }\n }\n return { p, f };\n }\n multiply(scalar, affinePoint) {\n let n = normalizeScalar(scalar);\n let point;\n let fake;\n if (USE_ENDOMORPHISM) {\n const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);\n let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);\n k1p = constTimeNegate(k1neg, k1p);\n k2p = constTimeNegate(k2neg, k2p);\n k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);\n point = k1p.add(k2p);\n fake = f1p.add(f2p);\n }\n else {\n const { p, f } = this.wNAF(n, affinePoint);\n point = p;\n fake = f;\n }\n return JacobianPoint.normalizeZ([point, fake])[0];\n }\n toAffine(invZ) {\n const { x, y, z } = this;\n const is0 = this.equals(JacobianPoint.ZERO);\n if (invZ == null)\n invZ = is0 ? _8n : invert(z);\n const iz1 = invZ;\n const iz2 = mod(iz1 * iz1);\n const iz3 = mod(iz2 * iz1);\n const ax = mod(x * iz2);\n const ay = mod(y * iz3);\n const zz = mod(z * iz1);\n if (is0)\n return Point.ZERO;\n if (zz !== _1n)\n throw new Error('invZ was invalid');\n return new Point(ax, ay);\n }\n}\nJacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);\nJacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);\nfunction constTimeNegate(condition, item) {\n const neg = item.negate();\n return condition ? neg : item;\n}\nconst pointPrecomputes = new WeakMap();\nexport class Point {\n constructor(x, y) {\n this.x = x;\n this.y = y;\n }\n _setWindowSize(windowSize) {\n this._WINDOW_SIZE = windowSize;\n pointPrecomputes.delete(this);\n }\n hasEvenY() {\n return this.y % _2n === _0n;\n }\n static fromCompressedHex(bytes) {\n const isShort = bytes.length === 32;\n const x = bytesToNumber(isShort ? bytes : bytes.subarray(1));\n if (!isValidFieldElement(x))\n throw new Error('Point is not on curve');\n const y2 = weierstrass(x);\n let y = sqrtMod(y2);\n const isYOdd = (y & _1n) === _1n;\n if (isShort) {\n if (isYOdd)\n y = mod(-y);\n }\n else {\n const isFirstByteOdd = (bytes[0] & 1) === 1;\n if (isFirstByteOdd !== isYOdd)\n y = mod(-y);\n }\n const point = new Point(x, y);\n point.assertValidity();\n return point;\n }\n static fromUncompressedHex(bytes) {\n const x = bytesToNumber(bytes.subarray(1, fieldLen + 1));\n const y = bytesToNumber(bytes.subarray(fieldLen + 1, fieldLen * 2 + 1));\n const point = new Point(x, y);\n point.assertValidity();\n return point;\n }\n static fromHex(hex) {\n const bytes = ensureBytes(hex);\n const len = bytes.length;\n const header = bytes[0];\n if (len === fieldLen)\n return this.fromCompressedHex(bytes);\n if (len === compressedLen && (header === 0x02 \|\| header === 0x03)) {\n return this.fromCompressedHex(bytes);\n }\n if (len === uncompressedLen && header === 0x04)\n return this.fromUncompressedHex(bytes);\n throw new Error(`Point.fromHex: received invalid point. Expected 32-${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes, not ${len}`);\n }\n static fromPrivateKey(privateKey) {\n return Point.BASE.multiply(normalizePrivateKey(privateKey));\n }\n static fromSignature(msgHash, signature, recovery) {\n const { r, s } = normalizeSignature(signature);\n if (![0, 1, 2, 3].includes(recovery))\n throw new Error('Cannot recover: invalid recovery bit');\n const h = truncateHash(ensureBytes(msgHash));\n const { n } = CURVE;\n const radj = recovery === 2 \|\| recovery === 3 ? r + n : r;\n const rinv = invert(radj, n);\n const u1 = mod(-h * rinv, n);\n const u2 = mod(s * rinv, n);\n const prefix = recovery & 1 ? '03' : '02';\n const R = Point.fromHex(prefix + numTo32bStr(radj));\n const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);\n if (!Q)\n throw new Error('Cannot recover signature: point at infinify');\n Q.assertValidity();\n return Q;\n }\n toRawBytes(isCompressed = false) {\n return hexToBytes(this.toHex(isCompressed));\n }\n toHex(isCompressed = false) {\n const x = numTo32bStr(this.x);\n if (isCompressed) {\n const prefix = this.hasEvenY() ? '02' : '03';\n return `${prefix}${x}`;\n }\n else {\n return `04${x}${numTo32bStr(this.y)}`;\n }\n }\n toHexX() {\n return this.toHex(true).slice(2);\n }\n toRawX() {\n return this.toRawBytes(true).slice(1);\n }\n assertValidity() {\n const msg = 'Point is not on elliptic curve';\n const { x, y } = this;\n if (!isValidFieldElement(x) \|\| !isValidFieldElement(y))\n throw new Error(msg);\n const left = mod(y * y);\n const right = weierstrass(x);\n if (mod(left - right) !== _0n)\n throw new Error(msg);\n }\n equals(other) {\n return this.x === other.x && this.y === other.y;\n }\n negate() {\n return new Point(this.x, mod(-this.y));\n }\n double() {\n return JacobianPoint.fromAffine(this).double().toAffine();\n }\n add(other) {\n return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine();\n }\n subtract(other) {\n return this.add(other.negate());\n }\n multiply(scalar) {\n return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine();\n }\n multiplyAndAddUnsafe(Q, a, b) {\n const P = JacobianPoint.fromAffine(this);\n const aP = a === _0n \|\| a === _1n \|\| this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);\n const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);\n const sum = aP.add(bQ);\n return sum.equals(JacobianPoint.ZERO) ? undefined : sum.toAffine();\n }\n}\nPoint.BASE = new Point(CURVE.Gx, CURVE.Gy);\nPoint.ZERO = new Point(_0n, _0n);\nfunction sliceDER(s) {\n return Number.parseInt(s[0], 16) >= 8 ? '00' + s : s;\n}\nfunction parseDERInt(data) {\n if (data.length < 2 \|\| data[0] !== 0x02) {\n throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);\n }\n const len = data[1];\n const res = data.subarray(2, len + 2);\n if (!len \|\| res.length !== len) {\n throw new Error(`Invalid signature integer: wrong length`);\n }\n if (res[0] === 0x00 && res[1] <= 0x7f) {\n throw new Error('Invalid signature integer: trailing length');\n }\n return { data: bytesToNumber(res), left: data.subarray(len + 2) };\n}\nfunction parseDERSignature(data) {\n if (data.length < 2 \|\| data[0] != 0x30) {\n throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);\n }\n if (data[1] !== data.length - 2) {\n throw new Error('Invalid signature: incorrect length');\n }\n const { data: r, left: sBytes } = parseDERInt(data.subarray(2));\n const { data: s, left: rBytesLeft } = parseDERInt(sBytes);\n if (rBytesLeft.length) {\n throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);\n }\n return { r, s };\n}\nexport class Signature {\n constructor(r, s) {\n this.r = r;\n this.s = s;\n this.assertValidity();\n }\n static fromCompact(hex) {\n const arr = hex instanceof Uint8Array;\n const name = 'Signature.fromCompact';\n if (typeof hex !== 'string' && !arr)\n throw new TypeError(`${name}: Expected string or Uint8Array`);\n const str = arr ? bytesToHex(hex) : hex;\n if (str.length !== 128)\n throw new Error(`${name}: Expected 64-byte hex`);\n return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));\n }\n static fromDER(hex) {\n const arr = hex instanceof Uint8Array;\n if (typeof hex !== 'string' && !arr)\n throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);\n const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));\n return new Signature(r, s);\n }\n static fromHex(hex) {\n return this.fromDER(hex);\n }\n assertValidity() {\n const { r, s } = this;\n if (!isWithinCurveOrder(r))\n throw new Error('Invalid Signature: r must be 0 < r < n');\n if (!isWithinCurveOrder(s))\n throw new Error('Invalid Signature: s must be 0 < s < n');\n }\n hasHighS() {\n const HALF = CURVE.n >> _1n;\n return this.s > HALF;\n }\n normalizeS() {\n return this.hasHighS() ? new Signature(this.r, mod(-this.s, CURVE.n)) : this;\n }\n toDERRawBytes() {\n return hexToBytes(this.toDERHex());\n }\n toDERHex() {\n const sHex = sliceDER(numberToHexUnpadded(this.s));\n const rHex = sliceDER(numberToHexUnpadded(this.r));\n const sHexL = sHex.length / 2;\n const rHexL = rHex.length / 2;\n const sLen = numberToHexUnpadded(sHexL);\n const rLen = numberToHexUnpadded(rHexL);\n const length = numberToHexUnpadded(rHexL + sHexL + 4);\n return `30${length}02${rLen}${rHex}02${sLen}${sHex}`;\n }\n toRawBytes() {\n return this.toDERRawBytes();\n }\n toHex() {\n return this.toDERHex();\n }\n toCompactRawBytes() {\n return hexToBytes(this.toCompactHex());\n }\n toCompactHex() {\n return numTo32bStr(this.r) + numTo32bStr(this.s);\n }\n}\nfunction concatBytes(...arrays) {\n if (!arrays.every((b) => b instanceof Uint8Array))\n throw new Error('Uint8Array list expected');\n if (arrays.length === 1)\n return arrays[0];\n const length = arrays.reduce((a, arr) => a + arr.length, 0);\n const result = new Uint8Array(length);\n for (let i = 0, pad = 0; i < arrays.length; i++) {\n const arr = arrays[i];\n result.set(arr, pad);\n pad += arr.length;\n }\n return result;\n}\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\nfunction bytesToHex(uint8a) {\n if (!(uint8a instanceof Uint8Array))\n throw new Error('Expected Uint8Array');\n let hex = '';\n for (let i = 0; i < uint8a.length; i++) {\n hex += hexes[uint8a[i]];\n }\n return hex;\n}\nconst POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');\nfunction numTo32bStr(num) {\n if (typeof num !== 'bigint')\n throw new Error('Expected bigint');\n if (!(_0n <= num && num < POW_2_256))\n throw new Error('Expected number 0 <= n < 2^256');\n return num.toString(16).padStart(64, '0');\n}\nfunction numTo32b(num) {\n const b = hexToBytes(numTo32bStr(num));\n if (b.length !== 32)\n throw new Error('Error: expected 32 bytes');\n return b;\n}\nfunction numberToHexUnpadded(num) {\n const hex = num.toString(16);\n return hex.length & 1 ? `0${hex}` : hex;\n}\nfunction hexToNumber(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToNumber: expected string, got ' + typeof hex);\n }\n return BigInt(`0x${hex}`);\n}\nfunction hexToBytes(hex) {\n if (typeof hex !== 'string') {\n throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\n }\n if (hex.length % 2)\n throw new Error('hexToBytes: received invalid unpadded hex' + hex.length);\n const array = new Uint8Array(hex.length / 2);\n for (let i = 0; i < array.length; i++) {\n const j = i * 2;\n const hexByte = hex.slice(j, j + 2);\n const byte = Number.parseInt(hexByte, 16);\n if (Number.isNaN(byte) \|\| byte < 0)\n throw new Error('Invalid byte sequence');\n array[i] = byte;\n }\n return array;\n}\nfunction bytesToNumber(bytes) {\n return hexToNumber(bytesToHex(bytes));\n}\nfunction ensureBytes(hex) {\n return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);\n}\nfunction normalizeScalar(num) {\n if (typeof num === 'number' && Number.isSafeInteger(num) && num > 0)\n return BigInt(num);\n if (typeof num === 'bigint' && isWithinCurveOrder(num))\n return num;\n throw new TypeError('Expected valid private scalar: 0 < scalar < curve.n');\n}\nfunction mod(a, b = CURVE.P) {\n const result = a % b;\n return result >= _0n ? result : b + result;\n}\nfunction pow2(x, power) {\n const { P } = CURVE;\n let res = x;\n while (power-- > _0n) {\n res = res;\n res %= P;\n }\n return res;\n}\nfunction sqrtMod(x) {\n const { P } = CURVE;\n const _6n = BigInt(6);\n const _11n = BigInt(11);\n const _22n = BigInt(22);\n const _23n = BigInt(23);\n const _44n = BigInt(44);\n const _88n = BigInt(88);\n const b2 = (x x * x) % P;\n const b3 = (b2 * b2 * x) % P;\n const b6 = (pow2(b3, _3n) * b3) % P;\n const b9 = (pow2(b6, _3n) * b3) % P;\n const b11 = (pow2(b9, _2n) * b2) % P;\n const b22 = (pow2(b11, _11n) * b11) % P;\n const b44 = (pow2(b22, _22n) * b22) % P;\n const b88 = (pow2(b44, _44n) * b44) % P;\n const b176 = (pow2(b88, _88n) * b88) % P;\n const b220 = (pow2(b176, _44n) * b44) % P;\n const b223 = (pow2(b220, _3n) * b3) % P;\n const t1 = (pow2(b223, _23n) * b22) % P;\n const t2 = (pow2(t1, _6n) * b2) % P;\n const rt = pow2(t2, _2n);\n const xc = (rt * rt) % P;\n if (xc !== x)\n throw new Error('Cannot find square root');\n return rt;\n}\nfunction invert(number, modulo = CURVE.P) {\n if (number === _0n \|\| modulo <= _0n) {\n throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n }\n let a = mod(number, modulo);\n let b = modulo;\n let x = _0n, y = _1n, u = _1n, v = _0n;\n while (a !== _0n) {\n const q = b / a;\n const r = b % a;\n const m = x - u * q;\n const n = y - v * q;\n b = a, a = r, x = u, y = v, u = m, v = n;\n }\n const gcd = b;\n if (gcd !== _1n)\n throw new Error('invert: does not exist');\n return mod(x, modulo);\n}\nfunction invertBatch(nums, p = CURVE.P) {\n const scratch = new Array(nums.length);\n const lastMultiplied = nums.reduce((acc, num, i) => {\n if (num === _0n)\n return acc;\n scratch[i] = acc;\n return mod(acc * num, p);\n }, _1n);\n const inverted = invert(lastMultiplied, p);\n nums.reduceRight((acc, num, i) => {\n if (num === _0n)\n return acc;\n scratch[i] = mod(acc * scratch[i], p);\n return mod(acc * num, p);\n }, inverted);\n return scratch;\n}\nfunction bits2int_2(bytes) {\n const delta = bytes.length * 8 - groupLen * 8;\n const num = bytesToNumber(bytes);\n return delta > 0 ? num >> BigInt(delta) : num;\n}\nfunction truncateHash(hash, truncateOnly = false) {\n const h = bits2int_2(hash);\n if (truncateOnly)\n return h;\n const { n } = CURVE;\n return h >= n ? h - n : h;\n}\nlet _sha256Sync;\nlet _hmacSha256Sync;\nclass HmacDrbg {\n constructor(hashLen, qByteLen) {\n this.hashLen = hashLen;\n this.qByteLen = qByteLen;\n if (typeof hashLen !== 'number' \|\| hashLen < 2)\n throw new Error('hashLen must be a number');\n if (typeof qByteLen !== 'number' \|\| qByteLen < 2)\n throw new Error('qByteLen must be a number');\n this.v = new Uint8Array(hashLen).fill(1);\n this.k = new Uint8Array(hashLen).fill(0);\n this.counter = 0;\n }\n hmac(...values) {\n return utils.hmacSha256(this.k, ...values);\n }\n hmacSync(...values) {\n return _hmacSha256Sync(this.k, ...values);\n }\n checkSync() {\n if (typeof _hmacSha256Sync !== 'function')\n throw new ShaError('hmacSha256Sync needs to be set');\n }\n incr() {\n if (this.counter >= 1000)\n throw new Error('Tried 1,000 k values for sign(), all were invalid');\n this.counter += 1;\n }\n async reseed(seed = new Uint8Array()) {\n this.k = await this.hmac(this.v, Uint8Array.from([0x00]), seed);\n this.v = await this.hmac(this.v);\n if (seed.length === 0)\n return;\n this.k = await this.hmac(this.v, Uint8Array.from([0x01]), seed);\n this.v = await this.hmac(this.v);\n }\n reseedSync(seed = new Uint8Array()) {\n this.checkSync();\n this.k = this.hmacSync(this.v, Uint8Array.from([0x00]), seed);\n this.v = this.hmacSync(this.v);\n if (seed.length === 0)\n return;\n this.k = this.hmacSync(this.v, Uint8Array.from([0x01]), seed);\n this.v = this.hmacSync(this.v);\n }\n async generate() {\n this.incr();\n let len = 0;\n const out = [];\n while (len < this.qByteLen) {\n this.v = await this.hmac(this.v);\n const sl = this.v.slice();\n out.push(sl);\n len += this.v.length;\n }\n return concatBytes(...out);\n }\n generateSync() {\n this.checkSync();\n this.incr();\n let len = 0;\n const out = [];\n while (len < this.qByteLen) {\n this.v = this.hmacSync(this.v);\n const sl = this.v.slice();\n out.push(sl);\n len += this.v.length;\n }\n return concatBytes(...out);\n }\n}\nfunction isWithinCurveOrder(num) {\n return _0n < num && num < CURVE.n;\n}\nfunction isValidFieldElement(num) {\n return _0n < num && num < CURVE.P;\n}\nfunction kmdToSig(kBytes, m, d, lowS = true) {\n const { n } = CURVE;\n const k = truncateHash(kBytes, true);\n if (!isWithinCurveOrder(k))\n return;\n const kinv = invert(k, n);\n const q = Point.BASE.multiply(k);\n const r = mod(q.x, n);\n if (r === _0n)\n return;\n const s = mod(kinv * mod(m + d * r, n), n);\n if (s === _0n)\n return;\n let sig = new Signature(r, s);\n let recovery = (q.x === sig.r ? 0 : 2) \| Number(q.y & _1n);\n if (lowS && sig.hasHighS()) {\n sig = sig.normalizeS();\n recovery ^= 1;\n }\n return { sig, recovery };\n}\nfunction normalizePrivateKey(key) {\n let num;\n if (typeof key === 'bigint') {\n num = key;\n }\n else if (typeof key === 'number' && Number.isSafeInteger(key) && key > 0) {\n num = BigInt(key);\n }\n else if (typeof key === 'string') {\n if (key.length !== 2 * groupLen)\n throw new Error('Expected 32 bytes of private key');\n num = hexToNumber(key);\n }\n else if (key instanceof Uint8Array) {\n if (key.length !== groupLen)\n throw new Error('Expected 32 bytes of private key');\n num = bytesToNumber(key);\n }\n else {\n throw new TypeError('Expected valid private key');\n }\n if (!isWithinCurveOrder(num))\n throw new Error('Expected private key: 0 < key < n');\n return num;\n}\nfunction normalizePublicKey(publicKey) {\n if (publicKey instanceof Point) {\n publicKey.assertValidity();\n return publicKey;\n }\n else {\n return Point.fromHex(publicKey);\n }\n}\nfunction normalizeSignature(signature) {\n if (signature instanceof Signature) {\n signature.assertValidity();\n return signature;\n }\n try {\n return Signature.fromDER(signature);\n }\n catch (error) {\n return Signature.fromCompact(signature);\n }\n}\nexport function getPublicKey(privateKey, isCompressed = false) {\n return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n}\nexport function recoverPublicKey(msgHash, signature, recovery, isCompressed = false) {\n return Point.fromSignature(msgHash, signature, recovery).toRawBytes(isCompressed);\n}\nfunction isProbPub(item) {\n const arr = item instanceof Uint8Array;\n const str = typeof item === 'string';\n const len = (arr \|\| str) && item.length;\n if (arr)\n return len === compressedLen \|\| len === uncompressedLen;\n if (str)\n return len === compressedLen * 2 \|\| len === uncompressedLen * 2;\n if (item instanceof Point)\n return true;\n return false;\n}\nexport function getSharedSecret(privateA, publicB, isCompressed = false) {\n if (isProbPub(privateA))\n throw new TypeError('getSharedSecret: first arg must be private key');\n if (!isProbPub(publicB))\n throw new TypeError('getSharedSecret: second arg must be public key');\n const b = normalizePublicKey(publicB);\n b.assertValidity();\n return b.multiply(normalizePrivateKey(privateA)).toRawBytes(isCompressed);\n}\nfunction bits2int(bytes) {\n const slice = bytes.length > fieldLen ? bytes.slice(0, fieldLen) : bytes;\n return bytesToNumber(slice);\n}\nfunction bits2octets(bytes) {\n const z1 = bits2int(bytes);\n const z2 = mod(z1, CURVE.n);\n return int2octets(z2 < _0n ? z1 : z2);\n}\nfunction int2octets(num) {\n return numTo32b(num);\n}\nfunction initSigArgs(msgHash, privateKey, extraEntropy) {\n if (msgHash == null)\n throw new Error(`sign: expected valid message hash, not \"${msgHash}\"`);\n const h1 = ensureBytes(msgHash);\n const d = normalizePrivateKey(privateKey);\n const seedArgs = [int2octets(d), bits2octets(h1)];\n if (extraEntropy != null) {\n if (extraEntropy === true)\n extraEntropy = utils.randomBytes(fieldLen);\n const e = ensureBytes(extraEntropy);\n if (e.length !== fieldLen)\n throw new Error(`sign: Expected ${fieldLen} bytes of extra data`);\n seedArgs.push(e);\n }\n const seed = concatBytes(...seedArgs);\n const m = bits2int(h1);\n return { seed, m, d };\n}\nfunction finalizeSig(recSig, opts) {\n const { sig, recovery } = recSig;\n const { der, recovered } = Object.assign({ canonical: true, der: true }, opts);\n const hashed = der ? sig.toDERRawBytes() : sig.toCompactRawBytes();\n return recovered ? [hashed, recovery] : hashed;\n}\nasync function sign(msgHash, privKey, opts = {}) {\n const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\n const drbg = new HmacDrbg(hashLen, groupLen);\n await drbg.reseed(seed);\n let sig;\n while (!(sig = kmdToSig(await drbg.generate(), m, d, opts.canonical)))\n await drbg.reseed();\n return finalizeSig(sig, opts);\n}\nfunction signSync(msgHash, privKey, opts = {}) {\n const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\n const drbg = new HmacDrbg(hashLen, groupLen);\n drbg.reseedSync(seed);\n let sig;\n while (!(sig = kmdToSig(drbg.generateSync(), m, d, opts.canonical)))\n drbg.reseedSync();\n return finalizeSig(sig, opts);\n}\nexport { sign, signSync };\nconst vopts = { strict: true };\nexport function verify(signature, msgHash, publicKey, opts = vopts) {\n let sig;\n try {\n sig = normalizeSignature(signature);\n msgHash = ensureBytes(msgHash);\n }\n catch (error) {\n return false;\n }\n const { r, s } = sig;\n if (opts.strict && sig.hasHighS())\n return false;\n const h = truncateHash(msgHash);\n let P;\n try {\n P = normalizePublicKey(publicKey);\n }\n catch (error) {\n return false;\n }\n const { n } = CURVE;\n const sinv = invert(s, n);\n const u1 = mod(h * sinv, n);\n const u2 = mod(r * sinv, n);\n const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2);\n if (!R)\n return false;\n const v = mod(R.x, n);\n return v === r;\n}\nfunction schnorrChallengeFinalize(ch) {\n return mod(bytesToNumber(ch), CURVE.n);\n}\nclass SchnorrSignature {\n constructor(r, s) {\n this.r = r;\n this.s = s;\n this.assertValidity();\n }\n static fromHex(hex) {\n const bytes = ensureBytes(hex);\n if (bytes.length !== 64)\n throw new TypeError(`SchnorrSignature.fromHex: expected 64 bytes, not ${bytes.length}`);\n const r = bytesToNumber(bytes.subarray(0, 32));\n const s = bytesToNumber(bytes.subarray(32, 64));\n return new SchnorrSignature(r, s);\n }\n assertValidity() {\n const { r, s } = this;\n if (!isValidFieldElement(r) \|\| !isWithinCurveOrder(s))\n throw new Error('Invalid signature');\n }\n toHex() {\n return numTo32bStr(this.r) + numTo32bStr(this.s);\n }\n toRawBytes() {\n return hexToBytes(this.toHex());\n }\n}\nfunction schnorrGetPublicKey(privateKey) {\n return Point.fromPrivateKey(privateKey).toRawX();\n}\nclass InternalSchnorrSignature {\n constructor(message, privateKey, auxRand = utils.randomBytes()) {\n if (message == null)\n throw new TypeError(`sign: Expected valid message, not \"${message}\"`);\n this.m = ensureBytes(message);\n const { x, scalar } = this.getScalar(normalizePrivateKey(privateKey));\n this.px = x;\n this.d = scalar;\n this.rand = ensureBytes(auxRand);\n if (this.rand.length !== 32)\n throw new TypeError('sign: Expected 32 bytes of aux randomness');\n }\n getScalar(priv) {\n const point = Point.fromPrivateKey(priv);\n const scalar = point.hasEvenY() ? priv : CURVE.n - priv;\n return { point, scalar, x: point.toRawX() };\n }\n initNonce(d, t0h) {\n return numTo32b(d ^ bytesToNumber(t0h));\n }\n finalizeNonce(k0h) {\n const k0 = mod(bytesToNumber(k0h), CURVE.n);\n if (k0 === _0n)\n throw new Error('sign: Creation of signature failed. k is zero');\n const { point: R, x: rx, scalar: k } = this.getScalar(k0);\n return { R, rx, k };\n }\n finalizeSig(R, k, e, d) {\n return new SchnorrSignature(R.x, mod(k + e * d, CURVE.n)).toRawBytes();\n }\n error() {\n throw new Error('sign: Invalid signature produced');\n }\n async calc() {\n const { m, d, px, rand } = this;\n const tag = utils.taggedHash;\n const t = this.initNonce(d, await tag(TAGS.aux, rand));\n const { R, rx, k } = this.finalizeNonce(await tag(TAGS.nonce, t, px, m));\n const e = schnorrChallengeFinalize(await tag(TAGS.challenge, rx, px, m));\n const sig = this.finalizeSig(R, k, e, d);\n if (!(await schnorrVerify(sig, m, px)))\n this.error();\n return sig;\n }\n calcSync() {\n const { m, d, px, rand } = this;\n const tag = utils.taggedHashSync;\n const t = this.initNonce(d, tag(TAGS.aux, rand));\n const { R, rx, k } = this.finalizeNonce(tag(TAGS.nonce, t, px, m));\n const e = schnorrChallengeFinalize(tag(TAGS.challenge, rx, px, m));\n const sig = this.finalizeSig(R, k, e, d);\n if (!schnorrVerifySync(sig, m, px))\n this.error();\n return sig;\n }\n}\nasync function schnorrSign(msg, privKey, auxRand) {\n return new InternalSchnorrSignature(msg, privKey, auxRand).calc();\n}\nfunction schnorrSignSync(msg, privKey, auxRand) {\n return new InternalSchnorrSignature(msg, privKey, auxRand).calcSync();\n}\nfunction initSchnorrVerify(signature, message, publicKey) {\n const raw = signature instanceof SchnorrSignature;\n const sig = raw ? signature : SchnorrSignature.fromHex(signature);\n if (raw)\n sig.assertValidity();\n return {\n ...sig,\n m: ensureBytes(message),\n P: normalizePublicKey(publicKey),\n };\n}\nfunction finalizeSchnorrVerify(r, P, s, e) {\n const R = Point.BASE.multiplyAndAddUnsafe(P, normalizePrivateKey(s), mod(-e, CURVE.n));\n if (!R \|\| !R.hasEvenY() \|\| R.x !== r)\n return false;\n return true;\n}\nasync function schnorrVerify(signature, message, publicKey) {\n try {\n const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\n const e = schnorrChallengeFinalize(await utils.taggedHash(TAGS.challenge, numTo32b(r), P.toRawX(), m));\n return finalizeSchnorrVerify(r, P, s, e);\n }\n catch (error) {\n return false;\n }\n}\nfunction schnorrVerifySync(signature, message, publicKey) {\n try {\n const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\n const e = schnorrChallengeFinalize(utils.taggedHashSync(TAGS.challenge, numTo32b(r), P.toRawX(), m));\n return finalizeSchnorrVerify(r, P, s, e);\n }\n catch (error) {\n if (error instanceof ShaError)\n throw error;\n return false;\n }\n}\nexport const schnorr = {\n Signature: SchnorrSignature,\n getPublicKey: schnorrGetPublicKey,\n sign: schnorrSign,\n verify: schnorrVerify,\n signSync: schnorrSignSync,\n verifySync: schnorrVerifySync,\n};\nPoint.BASE._setWindowSize(8);\nconst crypto = {\n node: nodeCrypto,\n web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\n};\nconst TAGS = {\n challenge: 'BIP0340/challenge',\n aux: 'BIP0340/aux',\n nonce: 'BIP0340/nonce',\n};\nconst TAGGED_HASH_PREFIXES = {};\nexport const utils = {\n bytesToHex,\n hexToBytes,\n concatBytes,\n mod,\n invert,\n isValidPrivateKey(privateKey) {\n try {\n normalizePrivateKey(privateKey);\n return true;\n }\n catch (error) {\n return false;\n }\n },\n _bigintTo32Bytes: numTo32b,\n _normalizePrivateKey: normalizePrivateKey,\n hashToPrivateKey: (hash) => {\n hash = ensureBytes(hash);\n const minLen = groupLen + 8;\n if (hash.length < minLen \|\| hash.length > 1024) {\n throw new Error(`Expected valid bytes of private key as per FIPS 186`);\n }\n const num = mod(bytesToNumber(hash), CURVE.n - _1n) + _1n;\n return numTo32b(num);\n },\n randomBytes: (bytesLength = 32) => {\n if (crypto.web) {\n return crypto.web.getRandomValues(new Uint8Array(bytesLength));\n }\n else if (crypto.node) {\n const { randomBytes } = crypto.node;\n return Uint8Array.from(randomBytes(bytesLength));\n }\n else {\n throw new Error(\"The environment doesn't have randomBytes function\");\n }\n },\n randomPrivateKey: () => utils.hashToPrivateKey(utils.randomBytes(groupLen + 8)),\n precompute(windowSize = 8, point = Point.BASE) {\n const cached = point === Point.BASE ? point : new Point(point.x, point.y);\n cached._setWindowSize(windowSize);\n cached.multiply(_3n);\n return cached;\n },\n sha256: async (...messages) => {\n if (crypto.web) {\n const buffer = await crypto.web.subtle.digest('SHA-256', concatBytes(...messages));\n return new Uint8Array(buffer);\n }\n else if (crypto.node) {\n const { createHash } = crypto.node;\n const hash = createHash('sha256');\n messages.forEach((m) => hash.update(m));\n return Uint8Array.from(hash.digest());\n }\n else {\n throw new Error(\"The environment doesn't have sha256 function\");\n }\n },\n hmacSha256: async (key, ...messages) => {\n if (crypto.web) {\n const ckey = await crypto.web.subtle.importKey('raw', key, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);\n const message = concatBytes(...messages);\n const buffer = await crypto.web.subtle.sign('HMAC', ckey, message);\n return new Uint8Array(buffer);\n }\n else if (crypto.node) {\n const { createHmac } = crypto.node;\n const hash = createHmac('sha256', key);\n messages.forEach((m) => hash.update(m));\n return Uint8Array.from(hash.digest());\n }\n else {\n throw new Error(\"The environment doesn't have hmac-sha256 function\");\n }\n },\n sha256Sync: undefined,\n hmacSha256Sync: undefined,\n taggedHash: async (tag, ...messages) => {\n let tagP = TAGGED_HASH_PREFIXES[tag];\n if (tagP === undefined) {\n const tagH = await utils.sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n tagP = concatBytes(tagH, tagH);\n TAGGED_HASH_PREFIXES[tag] = tagP;\n }\n return utils.sha256(tagP, ...messages);\n },\n taggedHashSync: (tag, ...messages) => {\n if (typeof _sha256Sync !== 'function')\n throw new ShaError('sha256Sync is undefined, you need to set it');\n let tagP = TAGGED_HASH_PREFIXES[tag];\n if (tagP === undefined) {\n const tagH = _sha256Sync(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n tagP = concatBytes(tagH, tagH);\n TAGGED_HASH_PREFIXES[tag] = tagP;\n }\n return _sha256Sync(tagP, ...messages);\n },\n _JacobianPoint: JacobianPoint,\n};\nObject.defineProperties(utils, {\n sha256Sync: {\n configurable: false,\n get() {\n return _sha256Sync;\n },\n set(val) {\n if (!_sha256Sync)\n _sha256Sync = val;\n },\n },\n hmacSha256Sync: {\n configurable: false,\n get() {\n return _hmacSha256Sync;\n },\n set(val) {\n if (!_hmacSha256Sync)\n _hmacSha256Sync = val;\n },\n },\n});\n","import { hexToInt } from './utils';\nconst COORDINATE_BYTES = 32;\nexport function parseRecoverableSignatureVrs(signature) {\n if (signature.length < COORDINATE_BYTES * 2 * 2 + 1) {\n throw new Error('Invalid signature');\n }\n const recoveryIdHex = signature.slice(0, 2);\n const r = signature.slice(2, 2 + COORDINATE_BYTES * 2);\n const s = signature.slice(2 + COORDINATE_BYTES * 2);\n return {\n recoveryId: hexToInt(recoveryIdHex),\n r,\n s,\n };\n}\nexport function signatureVrsToRsv(signature) {\n return signature.slice(2) + signature.slice(0, 2);\n}\nexport function signatureRsvToVrs(signature) {\n return signature.slice(-2) + signature.slice(0, -2);\n}\n//# sourceMappingURL=signatures.js.map","import { hexToBytes } from './utils';\nexport function privateKeyToBytes(privateKey) {\n const privateKeyBuffer = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey;\n if (privateKeyBuffer.length != 32 && privateKeyBuffer.length != 33) {\n throw new Error(`Improperly formatted private-key. Private-key byte length should be 32 or 33. Length provided: ${privateKeyBuffer.length}`);\n }\n if (privateKeyBuffer.length == 33 && privateKeyBuffer[32] !== 1) {\n throw new Error('Improperly formatted private-key. 33 bytes indicate compressed key, but the last byte must be == 01');\n }\n return privateKeyBuffer;\n}\n//# sourceMappingURL=keys.js.map","import { SHA2 } from './_sha2.js';\nimport { wrapConstructor } from './utils.js';\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\nconst Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);\nconst Id = Uint8Array.from({ length: 16 }, (_, i) => i);\nconst Pi = Id.map((i) => (9 * i + 5) % 16);\nlet idxL = [Id];\nlet idxR = [Pi];\nfor (let i = 0; i < 4; i++)\n for (let j of [idxL, idxR])\n j.push(j[i].map((k) => Rho[k]));\nconst shifts = [\n [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],\n [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],\n [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],\n [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],\n [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],\n].map((i) => new Uint8Array(i));\nconst shiftsL = idxL.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst shiftsR = idxR.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst Kl = new Uint32Array([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);\nconst Kr = new Uint32Array([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);\n// The rotate left (circular left shift) operation for uint32\nconst rotl = (word, shift) => (word << shift) \| (word >>> (32 - shift));\n// It's called f() in spec.\nfunction f(group, x, y, z) {\n if (group === 0)\n return x ^ y ^ z;\n else if (group === 1)\n return (x & y) \| (~x & z);\n else if (group === 2)\n return (x \| ~y) ^ z;\n else if (group === 3)\n return (x & z) \| (y & ~z);\n else\n return x ^ (y \| ~z);\n}\n// Temporary buffer, not used to store anything between runs\nconst BUF = new Uint32Array(16);\nexport class RIPEMD160 extends SHA2 {\n constructor() {\n super(64, 20, 8, true);\n this.h0 = 0x67452301 \| 0;\n this.h1 = 0xefcdab89 \| 0;\n this.h2 = 0x98badcfe \| 0;\n this.h3 = 0x10325476 \| 0;\n this.h4 = 0xc3d2e1f0 \| 0;\n }\n get() {\n const { h0, h1, h2, h3, h4 } = this;\n return [h0, h1, h2, h3, h4];\n }\n set(h0, h1, h2, h3, h4) {\n this.h0 = h0 \| 0;\n this.h1 = h1 \| 0;\n this.h2 = h2 \| 0;\n this.h3 = h3 \| 0;\n this.h4 = h4 \| 0;\n }\n process(view, offset) {\n for (let i = 0; i < 16; i++, offset += 4)\n BUF[i] = view.getUint32(offset, true);\n // prettier-ignore\n let al = this.h0 \| 0, ar = al, bl = this.h1 \| 0, br = bl, cl = this.h2 \| 0, cr = cl, dl = this.h3 \| 0, dr = dl, el = this.h4 \| 0, er = el;\n // Instead of iterating 0 to 80, we split it into 5 groups\n // And use the groups in constants, functions, etc. Much simpler\n for (let group = 0; group < 5; group++) {\n const rGroup = 4 - group;\n const hbl = Kl[group], hbr = Kr[group]; // prettier-ignore\n const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n const sl = shiftsL[group], sr = shiftsR[group]; // prettier-ignore\n for (let i = 0; i < 16; i++) {\n const tl = (rotl(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el) \| 0;\n al = el, el = dl, dl = rotl(cl, 10) \| 0, cl = bl, bl = tl; // prettier-ignore\n }\n // 2 loops are 10% faster\n for (let i = 0; i < 16; i++) {\n const tr = (rotl(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er) \| 0;\n ar = er, er = dr, dr = rotl(cr, 10) \| 0, cr = br, br = tr; // prettier-ignore\n }\n }\n // Add the compressed chunk to the current hash value\n this.set((this.h1 + cl + dr) \| 0, (this.h2 + dl + er) \| 0, (this.h3 + el + ar) \| 0, (this.h4 + al + br) \| 0, (this.h0 + bl + cr) \| 0);\n }\n roundClean() {\n BUF.fill(0);\n }\n destroy() {\n this.destroyed = true;\n this.buffer.fill(0);\n this.set(0, 0, 0, 0, 0);\n }\n}\n/*\n RIPEMD-160 - a hash function from 1990s.\n * @param message - msg that would be hashed\n /\nexport const ripemd160 = wrapConstructor(() => new RIPEMD160());\n","const U32_MASK64 = BigInt(2 * 32 - 1);\nconst _32n = BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nexport function fromBig(n, le = false) {\n if (le)\n return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n return { h: Number((n >> _32n) & U32_MASK64) \| 0, l: Number(n & U32_MASK64) \| 0 };\n}\nexport function split(lst, le = false) {\n let Ah = new Uint32Array(lst.length);\n let Al = new Uint32Array(lst.length);\n for (let i = 0; i < lst.length; i++) {\n const { h, l } = fromBig(lst[i], le);\n [Ah[i], Al[i]] = [h, l];\n }\n return [Ah, Al];\n}\nexport const toBig = (h, l) => (BigInt(h >>> 0) << _32n) \| BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) \| (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) \| (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) \| (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) \| (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) \| (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (h, l) => l;\nconst rotr32L = (h, l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) \| (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) \| (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) \| (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) \| (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\n// Removing \"export\" has 5% perf penalty -_-\nexport function add(Ah, Al, Bh, Bl) {\n const l = (Al >>> 0) + (Bl >>> 0);\n return { h: (Ah + Bh + ((l / 2 32) \| 0)) \| 0, l: l \| 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 32) \| 0)) \| 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 32) \| 0)) \| 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 32) \| 0)) \| 0;\n// prettier-ignore\nconst u64 = {\n fromBig, split, toBig,\n shrSH, shrSL,\n rotrSH, rotrSL, rotrBH, rotrBL,\n rotr32H, rotr32L,\n rotlSH, rotlSL, rotlBH, rotlBL,\n add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n","import { SHA2 } from './_sha2.js';\nimport u64 from './_u64.js';\nimport { wrapConstructor } from './utils.js';\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = u64.split([\n '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n)));\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = new Uint32Array(80);\nconst SHA512_W_L = new Uint32Array(80);\nexport class SHA512 extends SHA2 {\n constructor() {\n super(128, 64, 16, false);\n // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n // Also looks cleaner and easier to verify with spec.\n // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0x6a09e667 \| 0;\n this.Al = 0xf3bcc908 \| 0;\n this.Bh = 0xbb67ae85 \| 0;\n this.Bl = 0x84caa73b \| 0;\n this.Ch = 0x3c6ef372 \| 0;\n this.Cl = 0xfe94f82b \| 0;\n this.Dh = 0xa54ff53a \| 0;\n this.Dl = 0x5f1d36f1 \| 0;\n this.Eh = 0x510e527f \| 0;\n this.El = 0xade682d1 \| 0;\n this.Fh = 0x9b05688c \| 0;\n this.Fl = 0x2b3e6c1f \| 0;\n this.Gh = 0x1f83d9ab \| 0;\n this.Gl = 0xfb41bd6b \| 0;\n this.Hh = 0x5be0cd19 \| 0;\n this.Hl = 0x137e2179 \| 0;\n }\n // prettier-ignore\n get() {\n const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n }\n // prettier-ignore\n set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n this.Ah = Ah \| 0;\n this.Al = Al \| 0;\n this.Bh = Bh \| 0;\n this.Bl = Bl \| 0;\n this.Ch = Ch \| 0;\n this.Cl = Cl \| 0;\n this.Dh = Dh \| 0;\n this.Dl = Dl \| 0;\n this.Eh = Eh \| 0;\n this.El = El \| 0;\n this.Fh = Fh \| 0;\n this.Fl = Fl \| 0;\n this.Gh = Gh \| 0;\n this.Gl = Gl \| 0;\n this.Hh = Hh \| 0;\n this.Hl = Hl \| 0;\n }\n process(view, offset) {\n // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4) {\n SHA512_W_H[i] = view.getUint32(offset);\n SHA512_W_L[i] = view.getUint32((offset += 4));\n }\n for (let i = 16; i < 80; i++) {\n // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n const W15h = SHA512_W_H[i - 15] \| 0;\n const W15l = SHA512_W_L[i - 15] \| 0;\n const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n const W2h = SHA512_W_H[i - 2] \| 0;\n const W2l = SHA512_W_L[i - 2] \| 0;\n const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n SHA512_W_H[i] = SUMh \| 0;\n SHA512_W_L[i] = SUMl \| 0;\n }\n let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n // Compression function main loop, 80 rounds\n for (let i = 0; i < 80; i++) {\n // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) \| 0;\n const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n const CHIl = (El & Fl) ^ (~El & Gl);\n // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n // prettier-ignore\n const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n const T1l = T1ll \| 0;\n // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n Hh = Gh \| 0;\n Hl = Gl \| 0;\n Gh = Fh \| 0;\n Gl = Fl \| 0;\n Fh = Eh \| 0;\n Fl = El \| 0;\n ({ h: Eh, l: El } = u64.add(Dh \| 0, Dl \| 0, T1h \| 0, T1l \| 0));\n Dh = Ch \| 0;\n Dl = Cl \| 0;\n Ch = Bh \| 0;\n Cl = Bl \| 0;\n Bh = Ah \| 0;\n Bl = Al \| 0;\n const All = u64.add3L(T1l, sigma0l, MAJl);\n Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n Al = All \| 0;\n }\n // Add the compressed chunk to the current hash value\n ({ h: Ah, l: Al } = u64.add(this.Ah \| 0, this.Al \| 0, Ah \| 0, Al \| 0));\n ({ h: Bh, l: Bl } = u64.add(this.Bh \| 0, this.Bl \| 0, Bh \| 0, Bl \| 0));\n ({ h: Ch, l: Cl } = u64.add(this.Ch \| 0, this.Cl \| 0, Ch \| 0, Cl \| 0));\n ({ h: Dh, l: Dl } = u64.add(this.Dh \| 0, this.Dl \| 0, Dh \| 0, Dl \| 0));\n ({ h: Eh, l: El } = u64.add(this.Eh \| 0, this.El \| 0, Eh \| 0, El \| 0));\n ({ h: Fh, l: Fl } = u64.add(this.Fh \| 0, this.Fl \| 0, Fh \| 0, Fl \| 0));\n ({ h: Gh, l: Gl } = u64.add(this.Gh \| 0, this.Gl \| 0, Gh \| 0, Gl \| 0));\n ({ h: Hh, l: Hl } = u64.add(this.Hh \| 0, this.Hl \| 0, Hh \| 0, Hl \| 0));\n this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n }\n roundClean() {\n SHA512_W_H.fill(0);\n SHA512_W_L.fill(0);\n }\n destroy() {\n this.buffer.fill(0);\n this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n }\n}\nclass SHA512_224 extends SHA512 {\n constructor() {\n super();\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0x8c3d37c8 \| 0;\n this.Al = 0x19544da2 \| 0;\n this.Bh = 0x73e19966 \| 0;\n this.Bl = 0x89dcd4d6 \| 0;\n this.Ch = 0x1dfab7ae \| 0;\n this.Cl = 0x32ff9c82 \| 0;\n this.Dh = 0x679dd514 \| 0;\n this.Dl = 0x582f9fcf \| 0;\n this.Eh = 0x0f6d2b69 \| 0;\n this.El = 0x7bd44da8 \| 0;\n this.Fh = 0x77e36f73 \| 0;\n this.Fl = 0x04c48942 \| 0;\n this.Gh = 0x3f9d85a8 \| 0;\n this.Gl = 0x6a1d36c8 \| 0;\n this.Hh = 0x1112e6ad \| 0;\n this.Hl = 0x91d692a1 \| 0;\n this.outputLen = 28;\n }\n}\nclass SHA512_256 extends SHA512 {\n constructor() {\n super();\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0x22312194 \| 0;\n this.Al = 0xfc2bf72c \| 0;\n this.Bh = 0x9f555fa3 \| 0;\n this.Bl = 0xc84c64c2 \| 0;\n this.Ch = 0x2393b86b \| 0;\n this.Cl = 0x6f53b151 \| 0;\n this.Dh = 0x96387719 \| 0;\n this.Dl = 0x5940eabd \| 0;\n this.Eh = 0x96283ee2 \| 0;\n this.El = 0xa88effe3 \| 0;\n this.Fh = 0xbe5e1e25 \| 0;\n this.Fl = 0x53863992 \| 0;\n this.Gh = 0x2b0199fc \| 0;\n this.Gl = 0x2c85b8aa \| 0;\n this.Hh = 0x0eb72ddc \| 0;\n this.Hl = 0x81c52ca2 \| 0;\n this.outputLen = 32;\n }\n}\nclass SHA384 extends SHA512 {\n constructor() {\n super();\n // h -- high 32 bits, l -- low 32 bits\n this.Ah = 0xcbbb9d5d \| 0;\n this.Al = 0xc1059ed8 \| 0;\n this.Bh = 0x629a292a \| 0;\n this.Bl = 0x367cd507 \| 0;\n this.Ch = 0x9159015a \| 0;\n this.Cl = 0x3070dd17 \| 0;\n this.Dh = 0x152fecd8 \| 0;\n this.Dl = 0xf70e5939 \| 0;\n this.Eh = 0x67332667 \| 0;\n this.El = 0xffc00b31 \| 0;\n this.Fh = 0x8eb44a87 \| 0;\n this.Fl = 0x68581511 \| 0;\n this.Gh = 0xdb0c2e0d \| 0;\n this.Gl = 0x64f98fa7 \| 0;\n this.Hh = 0x47b5481d \| 0;\n this.Hl = 0xbefa4fa4 \| 0;\n this.outputLen = 48;\n }\n}\nexport const sha512 = wrapConstructor(() => new SHA512());\nexport const sha512_224 = wrapConstructor(() => new SHA512_224());\nexport const sha512_256 = wrapConstructor(() => new SHA512_256());\nexport const sha384 = wrapConstructor(() => new SHA384());\n","import { bytesToHex, hexToBytes, readUInt16BE, readUInt32BE, readUInt8 } from '@stacks/common';\nfunction createEnumChecker(enumVariable) {\n const enumValues = Object.values(enumVariable).filter(v => typeof v === 'number');\n const enumValueSet = new Set(enumValues);\n return (value) => enumValueSet.has(value);\n}\nconst enumCheckFunctions = new Map();\nexport function isEnum(enumVariable, value) {\n const checker = enumCheckFunctions.get(enumVariable);\n if (checker !== undefined) {\n return checker(value);\n }\n const newChecker = createEnumChecker(enumVariable);\n enumCheckFunctions.set(enumVariable, newChecker);\n return isEnum(enumVariable, value);\n}\nexport class BytesReader {\n constructor(bytes) {\n this.consumed = 0;\n this.source = typeof bytes === 'string' ? hexToBytes(bytes) : bytes;\n }\n readBytes(length) {\n const view = this.source.subarray(this.consumed, this.consumed + length);\n this.consumed += length;\n return view;\n }\n readUInt32BE() {\n return readUInt32BE(this.readBytes(4), 0);\n }\n readUInt8() {\n return readUInt8(this.readBytes(1), 0);\n }\n readUInt16BE() {\n return readUInt16BE(this.readBytes(2), 0);\n }\n readBigUIntLE(length) {\n const bytes = this.readBytes(length).slice().reverse();\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n readBigUIntBE(length) {\n const bytes = this.readBytes(length);\n const hex = bytesToHex(bytes);\n return BigInt(`0x${hex}`);\n }\n get readOffset() {\n return this.consumed;\n }\n set readOffset(val) {\n this.consumed = val;\n }\n get internalBytes() {\n return this.source;\n }\n readUInt8Enum(enumVariable, invalidEnumErrorFormatter) {\n const num = this.readUInt8();\n if (isEnum(enumVariable, num)) {\n return num;\n }\n throw invalidEnumErrorFormatter(num);\n }\n}\n//# sourceMappingURL=BytesReader.js.map","export var ClarityType;\n(function (ClarityType) {\n ClarityType[\"Int\"] = \"int\";\n ClarityType[\"UInt\"] = \"uint\";\n ClarityType[\"Buffer\"] = \"buffer\";\n ClarityType[\"BoolTrue\"] = \"true\";\n ClarityType[\"BoolFalse\"] = \"false\";\n ClarityType[\"PrincipalStandard\"] = \"address\";\n ClarityType[\"PrincipalContract\"] = \"contract\";\n ClarityType[\"ResponseOk\"] = \"ok\";\n ClarityType[\"ResponseErr\"] = \"err\";\n ClarityType[\"OptionalNone\"] = \"none\";\n ClarityType[\"OptionalSome\"] = \"some\";\n ClarityType[\"List\"] = \"list\";\n ClarityType[\"Tuple\"] = \"tuple\";\n ClarityType[\"StringASCII\"] = \"ascii\";\n ClarityType[\"StringUTF8\"] = \"utf8\";\n})(ClarityType \|\| (ClarityType = {}));\nexport var ClarityWireType;\n(function (ClarityWireType) {\n ClarityWireType[ClarityWireType[\"int\"] = 0] = \"int\";\n ClarityWireType[ClarityWireType[\"uint\"] = 1] = \"uint\";\n ClarityWireType[ClarityWireType[\"buffer\"] = 2] = \"buffer\";\n ClarityWireType[ClarityWireType[\"true\"] = 3] = \"true\";\n ClarityWireType[ClarityWireType[\"false\"] = 4] = \"false\";\n ClarityWireType[ClarityWireType[\"address\"] = 5] = \"address\";\n ClarityWireType[ClarityWireType[\"contract\"] = 6] = \"contract\";\n ClarityWireType[ClarityWireType[\"ok\"] = 7] = \"ok\";\n ClarityWireType[ClarityWireType[\"err\"] = 8] = \"err\";\n ClarityWireType[ClarityWireType[\"none\"] = 9] = \"none\";\n ClarityWireType[ClarityWireType[\"some\"] = 10] = \"some\";\n ClarityWireType[ClarityWireType[\"list\"] = 11] = \"list\";\n ClarityWireType[ClarityWireType[\"tuple\"] = 12] = \"tuple\";\n ClarityWireType[ClarityWireType[\"ascii\"] = 13] = \"ascii\";\n ClarityWireType[ClarityWireType[\"utf8\"] = 14] = \"utf8\";\n})(ClarityWireType \|\| (ClarityWireType = {}));\nexport function clarityTypeToByte(type) {\n return ClarityWireType[type];\n}\nexport function clarityByteToType(wireType) {\n return ClarityWireType[wireType];\n}\n//# sourceMappingURL=constants.js.map","import { bytesToTwosBigInt, hexToBytes, intToBigInt, isInstance, } from '@stacks/common';\nimport { ClarityType } from '../constants';\nconst MAX_U128 = BigInt('0xffffffffffffffffffffffffffffffff');\nconst MIN_U128 = BigInt(0);\nconst MAX_I128 = BigInt('0x7fffffffffffffffffffffffffffffff');\nconst MIN_I128 = BigInt('-170141183460469231731687303715884105728');\nexport const intCV = (value) => {\n if (typeof value === 'string' && value.toLowerCase().startsWith('0x')) {\n value = bytesToTwosBigInt(hexToBytes(value));\n }\n if (isInstance(value, Uint8Array))\n value = bytesToTwosBigInt(value);\n const bigInt = intToBigInt(value);\n if (bigInt > MAX_I128) {\n throw new RangeError(`Cannot construct clarity integer from value greater than ${MAX_I128}`);\n }\n else if (bigInt < MIN_I128) {\n throw new RangeError(`Cannot construct clarity integer form value less than ${MIN_I128}`);\n }\n return { type: ClarityType.Int, value: bigInt };\n};\nexport const uintCV = (value) => {\n const bigInt = intToBigInt(value);\n if (bigInt < MIN_U128) {\n throw new RangeError('Cannot construct unsigned clarity integer from negative value');\n }\n else if (bigInt > MAX_U128) {\n throw new RangeError(`Cannot construct unsigned clarity integer greater than ${MAX_U128}`);\n }\n return { type: ClarityType.UInt, value: bigInt };\n};\n//# sourceMappingURL=intCV.js.map","import { bytesToHex, utf8ToBytes } from '@stacks/common';\nimport { ClarityType } from '../constants';\nexport const bufferCV = (buffer) => {\n if (buffer.byteLength > 1048576) {\n throw new Error('Cannot construct clarity buffer that is greater than 1MB');\n }\n return { type: ClarityType.Buffer, value: bytesToHex(buffer) };\n};\nexport const bufferCVFromString = (str) => bufferCV(utf8ToBytes(str));\n//# sourceMappingURL=bufferCV.js.map","import { ClarityType } from '../constants';\nexport const trueCV = () => ({ type: ClarityType.BoolTrue });\nexport const falseCV = () => ({ type: ClarityType.BoolFalse });\nexport const boolCV = (bool) => (bool ? trueCV() : falseCV());\n//# sourceMappingURL=booleanCV.js.map","export var StacksWireType;\n(function (StacksWireType) {\n StacksWireType[StacksWireType[\"Address\"] = 0] = \"Address\";\n StacksWireType[StacksWireType[\"Principal\"] = 1] = \"Principal\";\n StacksWireType[StacksWireType[\"LengthPrefixedString\"] = 2] = \"LengthPrefixedString\";\n StacksWireType[StacksWireType[\"MemoString\"] = 3] = \"MemoString\";\n StacksWireType[StacksWireType[\"Asset\"] = 4] = \"Asset\";\n StacksWireType[StacksWireType[\"PostCondition\"] = 5] = \"PostCondition\";\n StacksWireType[StacksWireType[\"PublicKey\"] = 6] = \"PublicKey\";\n StacksWireType[StacksWireType[\"LengthPrefixedList\"] = 7] = \"LengthPrefixedList\";\n StacksWireType[StacksWireType[\"Payload\"] = 8] = \"Payload\";\n StacksWireType[StacksWireType[\"MessageSignature\"] = 9] = \"MessageSignature\";\n StacksWireType[StacksWireType[\"StructuredDataSignature\"] = 10] = \"StructuredDataSignature\";\n StacksWireType[StacksWireType[\"TransactionAuthField\"] = 11] = \"TransactionAuthField\";\n})(StacksWireType \|\| (StacksWireType = {}));\nexport function whenWireType(wireType) {\n return (wireTypeMap) => wireTypeMap[wireType];\n}\n//# sourceMappingURL=types.js.map","import { hexToBytes, intToBigInt } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport { ClarityType, principalCV } from '../clarity';\nimport { AddressVersion, COINBASE_BYTES_LENGTH, MAX_STRING_LENGTH_BYTES, MEMO_MAX_LENGTH_BYTES, PayloadType, PostConditionPrincipalId, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { exceedsMaxLengthBytes } from '../utils';\nimport { StacksWireType, } from './types';\nexport function createEmptyAddress() {\n return {\n type: StacksWireType.Address,\n version: AddressVersion.MainnetSingleSig,\n hash160: '0'.repeat(40),\n };\n}\nexport function createMemoString(content) {\n if (content && exceedsMaxLengthBytes(content, MEMO_MAX_LENGTH_BYTES)) {\n throw new Error(`Memo exceeds maximum length of ${MEMO_MAX_LENGTH_BYTES} bytes`);\n }\n return { type: StacksWireType.MemoString, content };\n}\nexport function createLPList(values, lengthPrefixBytes) {\n return {\n type: StacksWireType.LengthPrefixedList,\n lengthPrefixBytes: lengthPrefixBytes \|\| 4,\n values,\n };\n}\nexport function createMessageSignature(signature) {\n const length = hexToBytes(signature).byteLength;\n if (length != RECOVERABLE_ECDSA_SIG_LENGTH_BYTES) {\n throw Error('Invalid signature');\n }\n return {\n type: StacksWireType.MessageSignature,\n data: signature,\n };\n}\nexport function createTokenTransferPayload(recipient, amount, memo) {\n if (typeof recipient === 'string') {\n recipient = principalCV(recipient);\n }\n if (typeof memo === 'string') {\n memo = createMemoString(memo);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TokenTransfer,\n recipient,\n amount: intToBigInt(amount),\n memo: memo ?? createMemoString(''),\n };\n}\nexport function createContractCallPayload(contractAddress, contractName, functionName, functionArgs) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof functionName === 'string') {\n functionName = createLPString(functionName);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.ContractCall,\n contractAddress: typeof contractAddress === 'string' ? createAddress(contractAddress) : contractAddress,\n contractName,\n functionName,\n functionArgs,\n };\n}\nexport function codeBodyString(content) {\n return createLPString(content, 4, 100000);\n}\nexport function createSmartContractPayload(contractName, codeBody, clarityVersion) {\n if (typeof contractName === 'string') {\n contractName = createLPString(contractName);\n }\n if (typeof codeBody === 'string') {\n codeBody = codeBodyString(codeBody);\n }\n if (typeof clarityVersion === 'number') {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.VersionedSmartContract,\n clarityVersion,\n contractName,\n codeBody,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.SmartContract,\n contractName,\n codeBody,\n };\n}\nexport function createPoisonPayload() {\n return { type: StacksWireType.Payload, payloadType: PayloadType.PoisonMicroblock };\n}\nexport function createCoinbasePayload(coinbaseBytes, altRecipient) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (altRecipient != undefined) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.CoinbaseToAltRecipient,\n coinbaseBytes,\n recipient: altRecipient,\n };\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.Coinbase,\n coinbaseBytes,\n };\n}\nexport function createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof) {\n if (coinbaseBytes.byteLength != COINBASE_BYTES_LENGTH) {\n throw Error(`Coinbase buffer size must be ${COINBASE_BYTES_LENGTH} bytes`);\n }\n if (vrfProof.byteLength != VRF_PROOF_BYTES_LENGTH) {\n throw Error(`VRF proof buffer size must be ${VRF_PROOF_BYTES_LENGTH} bytes`);\n }\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.NakamotoCoinbase,\n coinbaseBytes,\n recipient: recipient.type === ClarityType.OptionalSome ? recipient.value : undefined,\n vrfProof,\n };\n}\nexport function createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash) {\n return {\n type: StacksWireType.Payload,\n payloadType: PayloadType.TenureChange,\n tenureHash,\n previousTenureHash,\n burnViewHash,\n previousTenureEnd,\n previousTenureBlocks,\n cause,\n publicKeyHash,\n };\n}\nexport function createLPString(content, lengthPrefixBytes, maxLengthBytes) {\n const prefixLength = lengthPrefixBytes \|\| 1;\n const maxLength = maxLengthBytes \|\| MAX_STRING_LENGTH_BYTES;\n if (exceedsMaxLengthBytes(content, maxLength)) {\n throw new Error(`String length exceeds maximum bytes ${maxLength}`);\n }\n return {\n type: StacksWireType.LengthPrefixedString,\n content,\n lengthPrefixBytes: prefixLength,\n maxLengthBytes: maxLength,\n };\n}\nexport function createAsset(addressString, contractName, assetName) {\n return {\n type: StacksWireType.Asset,\n address: createAddress(addressString),\n contractName: createLPString(contractName),\n assetName: createLPString(assetName),\n };\n}\nexport function createAddress(c32AddressString) {\n const addressData = c32addressDecode(c32AddressString);\n return {\n type: StacksWireType.Address,\n version: addressData[0],\n hash160: addressData[1],\n };\n}\nexport function createContractPrincipal(addressString, contractName) {\n const addr = createAddress(addressString);\n const name = createLPString(contractName);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Contract,\n address: addr,\n contractName: name,\n };\n}\nexport function createStandardPrincipal(addressString) {\n const addr = createAddress(addressString);\n return {\n type: StacksWireType.Principal,\n prefix: PostConditionPrincipalId.Standard,\n address: addr,\n };\n}\nexport function createTransactionAuthField(pubKeyEncoding, contents) {\n return {\n pubKeyEncoding,\n type: StacksWireType.TransactionAuthField,\n contents,\n };\n}\n//# sourceMappingURL=create.js.map","import { c32address } from 'c32check';\nimport { AddressHashMode, PayloadType } from '../constants';\nimport { publicKeyIsCompressed } from '../keys';\nimport { hashP2PKH, hashP2SH, hashP2WPKH, hashP2WSH } from '../utils';\nimport { createAsset, createContractPrincipal, createStandardPrincipal } from './create';\nimport { serializePublicKeyBytes } from './serialization';\nimport { StacksWireType, } from './types';\nexport function addressFromPublicKeys(version, hashMode, numSigs, publicKeys) {\n if (publicKeys.length === 0) {\n throw Error('Invalid number of public keys');\n }\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n if (publicKeys.length !== 1 \|\| numSigs !== 1) {\n throw Error('Invalid number of public keys or signatures');\n }\n }\n if (hashMode === AddressHashMode.P2WPKH \|\|\n hashMode === AddressHashMode.P2WSH \|\|\n hashMode === AddressHashMode.P2WSHNonSequential) {\n if (!publicKeys.map(p => p.data).every(publicKeyIsCompressed)) {\n throw Error('Public keys must be compressed for segwit');\n }\n }\n switch (hashMode) {\n case AddressHashMode.P2PKH:\n return addressFromVersionHash(version, hashP2PKH(publicKeys[0].data));\n case AddressHashMode.P2WPKH:\n return addressFromVersionHash(version, hashP2WPKH(publicKeys[0].data));\n case AddressHashMode.P2SH:\n case AddressHashMode.P2SHNonSequential:\n return addressFromVersionHash(version, hashP2SH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n case AddressHashMode.P2WSH:\n case AddressHashMode.P2WSHNonSequential:\n return addressFromVersionHash(version, hashP2WSH(numSigs, publicKeys.map(serializePublicKeyBytes)));\n }\n}\nexport function addressFromVersionHash(version, hash) {\n return { type: StacksWireType.Address, version, hash160: hash };\n}\nexport function addressToString(address) {\n return c32address(address.version, address.hash160);\n}\nexport function isTokenTransferPayload(p) {\n return p.payloadType === PayloadType.TokenTransfer;\n}\nexport function isContractCallPayload(p) {\n return p.payloadType === PayloadType.ContractCall;\n}\nexport function isSmartContractPayload(p) {\n return p.payloadType === PayloadType.SmartContract;\n}\nexport function isPoisonPayload(p) {\n return p.payloadType === PayloadType.PoisonMicroblock;\n}\nexport function isCoinbasePayload(p) {\n return p.payloadType === PayloadType.Coinbase;\n}\nexport function parseAssetString(id) {\n const [assetAddress, assetContractName, assetTokenName] = id.split(/\\.\|::/);\n const asset = createAsset(assetAddress, assetContractName, assetTokenName);\n return asset;\n}\nexport function parsePrincipalString(principalString) {\n if (principalString.includes('.')) {\n const [address, contractName] = principalString.split('.');\n return createContractPrincipal(address, contractName);\n }\n else {\n return createStandardPrincipal(principalString);\n }\n}\n//# sourceMappingURL=helpers.js.map","import { utf8ToBytes } from '@stacks/common';\nimport { addressToString, createAddress, createLPString, } from '../../wire';\nimport { ClarityType } from '../constants';\nexport function principalCV(principal) {\n if (principal.includes('.')) {\n const [address, contractName] = principal.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(principal);\n }\n}\nexport function standardPrincipalCV(addressString) {\n const addr = createAddress(addressString);\n return { type: ClarityType.PrincipalStandard, value: addressToString(addr) };\n}\nexport function standardPrincipalCVFromAddress(address) {\n return { type: ClarityType.PrincipalStandard, value: addressToString(address) };\n}\nexport function contractPrincipalCV(addressString, contractName) {\n const addr = createAddress(addressString);\n const lengthPrefixedContractName = createLPString(contractName);\n return contractPrincipalCVFromAddress(addr, lengthPrefixedContractName);\n}\nexport function contractPrincipalCVFromAddress(address, contractName) {\n if (utf8ToBytes(contractName.content).byteLength >= 128) {\n throw new Error('Contract name must be less than 128 bytes');\n }\n return {\n type: ClarityType.PrincipalContract,\n value: `${addressToString(address)}.${contractName.content}`,\n };\n}\nexport function contractPrincipalCVFromStandard(sp, contractName) {\n return {\n type: ClarityType.PrincipalContract,\n value: `${sp.value}.${contractName}`,\n };\n}\n//# sourceMappingURL=principalCV.js.map","import { ClarityType } from '../constants';\nexport function noneCV() {\n return { type: ClarityType.OptionalNone };\n}\nexport function someCV(value) {\n return { type: ClarityType.OptionalSome, value };\n}\nexport function optionalCVOf(value) {\n return value ? someCV(value) : noneCV();\n}\n//# sourceMappingURL=optionalCV.js.map","import { ClarityType } from '../constants';\nimport { isClarityName } from '../../utils';\nexport function tupleCV(data) {\n for (const key in data) {\n if (!isClarityName(key)) {\n throw new Error(`\"${key}\" is not a valid Clarity name`);\n }\n }\n return { type: ClarityType.Tuple, value: data };\n}\n//# sourceMappingURL=tupleCV.js.map","import { ripemd160 } from '@noble/hashes/ripemd160';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { sha512_256 } from '@noble/hashes/sha512';\nimport { utils } from '@noble/secp256k1';\nimport { bytesToHex, concatArray, concatBytes, utf8ToBytes } from '@stacks/common';\nimport { c32addressDecode } from 'c32check';\nimport lodashCloneDeep from 'lodash.clonedeep';\nimport { deserializeCV, serializeCV } from './clarity';\nexport { verify as verifySignature } from '@noble/secp256k1';\nexport const randomBytes = (bytesLength) => utils.randomBytes(bytesLength);\nexport const leftPadHex = (hexString) => hexString.length % 2 ? `0${hexString}` : hexString;\nexport const leftPadHexToLength = (hexString, length) => hexString.padStart(length, '0');\nexport const rightPadHexToLength = (hexString, length) => hexString.padEnd(length, '0');\nexport const exceedsMaxLengthBytes = (string, maxLengthBytes) => string ? utf8ToBytes(string).length > maxLengthBytes : false;\nexport function cloneDeep(obj) {\n return lodashCloneDeep(obj);\n}\nexport function omit(obj, prop) {\n const clone = cloneDeep(obj);\n delete clone[prop];\n return clone;\n}\nexport const hash160 = (input) => {\n return ripemd160(sha256(input));\n};\nexport const txidFromData = (data) => {\n return bytesToHex(sha512_256(data));\n};\nexport const txidFromBytes = txidFromData;\nexport const hashP2PKH = (input) => {\n return bytesToHex(hash160(input));\n};\nexport const hashP2WPKH = (input) => {\n const keyHash = hash160(input);\n const redeemScript = concatBytes(new Uint8Array([0]), new Uint8Array([keyHash.length]), keyHash);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2SH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2SH multisig address can only contain up to 15 public keys');\n }\n const bytesArray = [];\n bytesArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n bytesArray.push(pubKey.length);\n bytesArray.push(pubKey);\n });\n bytesArray.push(80 + pubKeys.length);\n bytesArray.push(174);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport const hashP2WSH = (numSigs, pubKeys) => {\n if (numSigs > 15 \|\| pubKeys.length > 15) {\n throw Error('P2WSH multisig address can only contain up to 15 public keys');\n }\n const scriptArray = [];\n scriptArray.push(80 + numSigs);\n pubKeys.forEach(pubKey => {\n scriptArray.push(pubKey.length);\n scriptArray.push(pubKey);\n });\n scriptArray.push(80 + pubKeys.length);\n scriptArray.push(174);\n const script = concatArray(scriptArray);\n const digest = sha256(script);\n const bytesArray = [];\n bytesArray.push(0);\n bytesArray.push(digest.length);\n bytesArray.push(digest);\n const redeemScript = concatArray(bytesArray);\n const redeemScriptHash = hash160(redeemScript);\n return bytesToHex(redeemScriptHash);\n};\nexport function isClarityName(name) {\n const regex = /^[a-zA-Z]([a-zA-Z0-9]\|[-_!?+<>=/])$\|^[-+=/]$\|^[<>]=?$/;\n return regex.test(name) && name.length < 128;\n}\nexport function cvToHex(cv) {\n const serialized = serializeCV(cv);\n return `0x${serialized}`;\n}\nexport function hexToCV(hex) {\n return deserializeCV(hex);\n}\nexport const parseReadOnlyResponse = (response) => {\n if (response.okay)\n return hexToCV(response.result);\n throw new Error(response.cause);\n};\nexport const validateStacksAddress = (address) => {\n try {\n c32addressDecode(address);\n return true;\n }\n catch (e) {\n return false;\n }\n};\nexport function parseContractId(contractId) {\n const [address, name] = contractId.split('.');\n if (!address \|\| !name)\n throw new Error(`Invalid contract identifier: ${contractId}`);\n return [address, name];\n}\n//# sourceMappingURL=utils.js.map","import { ClarityType } from '../constants';\nexport const stringAsciiCV = (data) => {\n return { type: ClarityType.StringASCII, value: data };\n};\nexport const stringUtf8CV = (data) => {\n return { type: ClarityType.StringUTF8, value: data };\n};\nexport const stringCV = (data, encoding) => {\n switch (encoding) {\n case 'ascii':\n return stringAsciiCV(data);\n case 'utf8':\n return stringUtf8CV(data);\n }\n};\n//# sourceMappingURL=stringCV.js.map","import { bytesToAscii, bytesToTwosBigInt, bytesToUtf8, hexToBytes } from '@stacks/common';\nimport { ClarityWireType, bufferCV, contractPrincipalCVFromAddress, falseCV, intCV, listCV, noneCV, responseErrorCV, responseOkCV, someCV, standardPrincipalCVFromAddress, stringAsciiCV, stringUtf8CV, trueCV, tupleCV, uintCV, } from '.';\nimport { BytesReader } from '../BytesReader';\nimport { DeserializationError } from '../errors';\nimport { deserializeAddress, deserializeLPString } from '../wire';\nexport function deserializeCV(serializedClarityValue) {\n let bytesReader;\n if (typeof serializedClarityValue === 'string') {\n const hasHexPrefix = serializedClarityValue.slice(0, 2).toLowerCase() === '0x';\n bytesReader = new BytesReader(hexToBytes(hasHexPrefix ? serializedClarityValue.slice(2) : serializedClarityValue));\n }\n else if (serializedClarityValue instanceof Uint8Array) {\n bytesReader = new BytesReader(serializedClarityValue);\n }\n else {\n bytesReader = serializedClarityValue;\n }\n const type = bytesReader.readUInt8Enum(ClarityWireType, n => {\n throw new DeserializationError(`Cannot recognize Clarity Type: ${n}`);\n });\n switch (type) {\n case ClarityWireType.int:\n return intCV(bytesToTwosBigInt(bytesReader.readBytes(16)));\n case ClarityWireType.uint:\n return uintCV(bytesReader.readBytes(16));\n case ClarityWireType.buffer:\n const bufferLength = bytesReader.readUInt32BE();\n return bufferCV(bytesReader.readBytes(bufferLength));\n case ClarityWireType.true:\n return trueCV();\n case ClarityWireType.false:\n return falseCV();\n case ClarityWireType.address:\n const sAddress = deserializeAddress(bytesReader);\n return standardPrincipalCVFromAddress(sAddress);\n case ClarityWireType.contract:\n const cAddress = deserializeAddress(bytesReader);\n const contractName = deserializeLPString(bytesReader);\n return contractPrincipalCVFromAddress(cAddress, contractName);\n case ClarityWireType.ok:\n return responseOkCV(deserializeCV(bytesReader));\n case ClarityWireType.err:\n return responseErrorCV(deserializeCV(bytesReader));\n case ClarityWireType.none:\n return noneCV();\n case ClarityWireType.some:\n return someCV(deserializeCV(bytesReader));\n case ClarityWireType.list:\n const listLength = bytesReader.readUInt32BE();\n const listContents = [];\n for (let i = 0; i < listLength; i++) {\n listContents.push(deserializeCV(bytesReader));\n }\n return listCV(listContents);\n case ClarityWireType.tuple:\n const tupleLength = bytesReader.readUInt32BE();\n const tupleContents = {};\n for (let i = 0; i < tupleLength; i++) {\n const clarityName = deserializeLPString(bytesReader).content;\n if (clarityName === undefined) {\n throw new DeserializationError('\"content\" is undefined');\n }\n tupleContents[clarityName] = deserializeCV(bytesReader);\n }\n return tupleCV(tupleContents);\n case ClarityWireType.ascii:\n const asciiStrLen = bytesReader.readUInt32BE();\n const asciiStr = bytesToAscii(bytesReader.readBytes(asciiStrLen));\n return stringAsciiCV(asciiStr);\n case ClarityWireType.utf8:\n const utf8StrLen = bytesReader.readUInt32BE();\n const utf8Str = bytesToUtf8(bytesReader.readBytes(utf8StrLen));\n return stringUtf8CV(utf8Str);\n default:\n throw new DeserializationError('Unable to deserialize Clarity Value from Uint8Array. Could not find valid Clarity Type.');\n }\n}\n//# sourceMappingURL=deserialize.js.map","import { ClarityType } from '../constants';\nexport function responseErrorCV(value) {\n return { type: ClarityType.ResponseErr, value };\n}\nexport function responseOkCV(value) {\n return { type: ClarityType.ResponseOk, value };\n}\n//# sourceMappingURL=responseCV.js.map","import { ClarityType } from '../constants';\nexport function listCV(values) {\n return { type: ClarityType.List, value: values };\n}\n//# sourceMappingURL=listCV.js.map","import { bytesToHex, bytesToUtf8, concatArray, hexToBytes, hexToInt, intToBigInt, intToBytes, intToHex, isInstance, utf8ToBytes, writeUInt32BE, writeUInt8, } from '@stacks/common';\nimport { BytesReader } from '../BytesReader';\nimport { deserializeCV, noneCV, serializeCVBytes, someCV, } from '../clarity';\nimport { AuthFieldType, COINBASE_BYTES_LENGTH, COMPRESSED_PUBKEY_LENGTH_BYTES, ClarityVersion, FungibleConditionCode, STRING_MAX_LENGTH, MEMO_MAX_LENGTH_BYTES, NonFungibleConditionCode, PayloadType, PostConditionPrincipalId, PostConditionType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, TenureChangeCause, UNCOMPRESSED_PUBKEY_LENGTH_BYTES, VRF_PROOF_BYTES_LENGTH, } from '../constants';\nimport { DeserializationError, SerializationError } from '../errors';\nimport { compressPublicKey, createStacksPublicKey, uncompressPublicKey } from '../keys';\nimport { rightPadHexToLength } from '../utils';\nimport { createCoinbasePayload, createContractCallPayload, createLPList, createLPString, createMessageSignature, createNakamotoCoinbasePayload, createPoisonPayload, createSmartContractPayload, createTenureChangePayload, createTokenTransferPayload, createTransactionAuthField, } from './create';\nimport { StacksWireType, } from './types';\nexport function serializeStacksWire(wire) {\n return bytesToHex(serializeStacksWireBytes(wire));\n}\nexport function serializeStacksWireBytes(wire) {\n switch (wire.type) {\n case StacksWireType.Address:\n return serializeAddressBytes(wire);\n case StacksWireType.Principal:\n return serializePrincipalBytes(wire);\n case StacksWireType.LengthPrefixedString:\n return serializeLPStringBytes(wire);\n case StacksWireType.MemoString:\n return serializeMemoStringBytes(wire);\n case StacksWireType.Asset:\n return serializeAssetBytes(wire);\n case StacksWireType.PostCondition:\n return serializePostConditionWireBytes(wire);\n case StacksWireType.PublicKey:\n return serializePublicKeyBytes(wire);\n case StacksWireType.LengthPrefixedList:\n return serializeLPListBytes(wire);\n case StacksWireType.Payload:\n return serializePayloadBytes(wire);\n case StacksWireType.TransactionAuthField:\n return serializeTransactionAuthFieldBytes(wire);\n case StacksWireType.MessageSignature:\n return serializeMessageSignatureBytes(wire);\n }\n}\nexport function deserializeStacksWire(bytesReader, type, listType) {\n switch (type) {\n case StacksWireType.Address:\n return deserializeAddress(bytesReader);\n case StacksWireType.Principal:\n return deserializePrincipal(bytesReader);\n case StacksWireType.LengthPrefixedString:\n return deserializeLPString(bytesReader);\n case StacksWireType.MemoString:\n return deserializeMemoString(bytesReader);\n case StacksWireType.Asset:\n return deserializeAsset(bytesReader);\n case StacksWireType.PostCondition:\n return deserializePostConditionWire(bytesReader);\n case StacksWireType.PublicKey:\n return deserializePublicKey(bytesReader);\n case StacksWireType.Payload:\n return deserializePayload(bytesReader);\n case StacksWireType.LengthPrefixedList:\n if (!listType) {\n throw new DeserializationError('No list type specified');\n }\n return deserializeLPList(bytesReader, listType);\n case StacksWireType.MessageSignature:\n return deserializeMessageSignature(bytesReader);\n default:\n throw new Error('Could not recognize StacksWireType');\n }\n}\nexport function serializeAddress(address) {\n return bytesToHex(serializeAddressBytes(address));\n}\nexport function serializeAddressBytes(address) {\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(address.version, 1)));\n bytesArray.push(hexToBytes(address.hash160));\n return concatArray(bytesArray);\n}\nexport function deserializeAddress(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const version = hexToInt(bytesToHex(bytesReader.readBytes(1)));\n const data = bytesToHex(bytesReader.readBytes(20));\n return { type: StacksWireType.Address, version, hash160: data };\n}\nexport function serializePrincipal(principal) {\n return bytesToHex(serializePrincipalBytes(principal));\n}\nexport function serializePrincipalBytes(principal) {\n const bytesArray = [];\n bytesArray.push(principal.prefix);\n if (principal.prefix === PostConditionPrincipalId.Standard \|\|\n principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeAddressBytes(principal.address));\n }\n if (principal.prefix === PostConditionPrincipalId.Contract) {\n bytesArray.push(serializeLPStringBytes(principal.contractName));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePrincipal(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const prefix = bytesReader.readUInt8Enum(PostConditionPrincipalId, n => {\n throw new DeserializationError(`Unexpected Principal payload type: ${n}`);\n });\n if (prefix === PostConditionPrincipalId.Origin) {\n return { type: StacksWireType.Principal, prefix };\n }\n const address = deserializeAddress(bytesReader);\n if (prefix === PostConditionPrincipalId.Standard) {\n return { type: StacksWireType.Principal, prefix, address };\n }\n const contractName = deserializeLPString(bytesReader);\n return {\n type: StacksWireType.Principal,\n prefix,\n address,\n contractName,\n };\n}\nexport function serializeLPString(lps) {\n return bytesToHex(serializeLPStringBytes(lps));\n}\nexport function serializeLPStringBytes(lps) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(lps.content);\n const length = contentBytes.byteLength;\n bytesArray.push(hexToBytes(intToHex(length, lps.lengthPrefixBytes)));\n bytesArray.push(contentBytes);\n return concatArray(bytesArray);\n}\nexport function deserializeLPString(serialized, prefixBytes, maxLength) {\n prefixBytes = prefixBytes ? prefixBytes : 1;\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(prefixBytes)));\n const content = bytesToUtf8(bytesReader.readBytes(length));\n return createLPString(content, prefixBytes, maxLength ?? 128);\n}\nexport function serializeMemoString(memoString) {\n return bytesToHex(serializeMemoStringBytes(memoString));\n}\nexport function serializeMemoStringBytes(memoString) {\n const bytesArray = [];\n const contentBytes = utf8ToBytes(memoString.content);\n const paddedContent = rightPadHexToLength(bytesToHex(contentBytes), MEMO_MAX_LENGTH_BYTES 2);\n bytesArray.push(hexToBytes(paddedContent));\n return concatArray(bytesArray);\n}\nexport function deserializeMemoString(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n let content = bytesToUtf8(bytesReader.readBytes(MEMO_MAX_LENGTH_BYTES));\n content = content.replace(/\\u0000$/, '');\n return { type: StacksWireType.MemoString, content };\n}\nexport function serializeAsset(info) {\n return bytesToHex(serializeAssetBytes(info));\n}\nexport function serializeAssetBytes(info) {\n const bytesArray = [];\n bytesArray.push(serializeAddressBytes(info.address));\n bytesArray.push(serializeLPStringBytes(info.contractName));\n bytesArray.push(serializeLPStringBytes(info.assetName));\n return concatArray(bytesArray);\n}\nexport function deserializeAsset(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return {\n type: StacksWireType.Asset,\n address: deserializeAddress(bytesReader),\n contractName: deserializeLPString(bytesReader),\n assetName: deserializeLPString(bytesReader),\n };\n}\nexport function serializeLPList(lpList) {\n return bytesToHex(serializeLPListBytes(lpList));\n}\nexport function serializeLPListBytes(lpList) {\n const list = lpList.values;\n const bytesArray = [];\n bytesArray.push(hexToBytes(intToHex(list.length, lpList.lengthPrefixBytes)));\n for (const l of list) {\n bytesArray.push(serializeStacksWireBytes(l));\n }\n return concatArray(bytesArray);\n}\nexport function deserializeLPList(serialized, type, lengthPrefixBytes) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const length = hexToInt(bytesToHex(bytesReader.readBytes(lengthPrefixBytes \|\| 4)));\n const l = [];\n for (let index = 0; index < length; index++) {\n switch (type) {\n case StacksWireType.Address:\n l.push(deserializeAddress(bytesReader));\n break;\n case StacksWireType.LengthPrefixedString:\n l.push(deserializeLPString(bytesReader));\n break;\n case StacksWireType.MemoString:\n l.push(deserializeMemoString(bytesReader));\n break;\n case StacksWireType.Asset:\n l.push(deserializeAsset(bytesReader));\n break;\n case StacksWireType.PostCondition:\n l.push(deserializePostConditionWire(bytesReader));\n break;\n case StacksWireType.PublicKey:\n l.push(deserializePublicKey(bytesReader));\n break;\n case StacksWireType.TransactionAuthField:\n l.push(deserializeTransactionAuthField(bytesReader));\n break;\n }\n }\n return createLPList(l, lengthPrefixBytes);\n}\nexport function serializePostConditionWire(postCondition) {\n return bytesToHex(serializePostConditionWireBytes(postCondition));\n}\nexport function serializePostConditionWireBytes(postCondition) {\n const bytesArray = [];\n bytesArray.push(postCondition.conditionType);\n bytesArray.push(serializePrincipalBytes(postCondition.principal));\n if (postCondition.conditionType === PostConditionType.Fungible \|\|\n postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeAssetBytes(postCondition.asset));\n }\n if (postCondition.conditionType === PostConditionType.NonFungible) {\n bytesArray.push(serializeCVBytes(postCondition.assetName));\n }\n bytesArray.push(postCondition.conditionCode);\n if (postCondition.conditionType === PostConditionType.STX \|\|\n postCondition.conditionType === PostConditionType.Fungible) {\n if (postCondition.amount > BigInt('0xffffffffffffffff'))\n throw new SerializationError('The post-condition amount may not be larger than 8 bytes');\n bytesArray.push(intToBytes(postCondition.amount, 8));\n }\n return concatArray(bytesArray);\n}\nexport function deserializePostConditionWire(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const postConditionType = bytesReader.readUInt8Enum(PostConditionType, n => {\n throw new DeserializationError(`Could not read ${n} as PostConditionType`);\n });\n const principal = deserializePrincipal(bytesReader);\n let conditionCode;\n let asset;\n let amount;\n switch (postConditionType) {\n case PostConditionType.STX:\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal,\n conditionCode,\n amount,\n };\n case PostConditionType.Fungible:\n asset = deserializeAsset(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(FungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n amount = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal,\n conditionCode,\n amount,\n asset: asset,\n };\n case PostConditionType.NonFungible:\n asset = deserializeAsset(bytesReader);\n const assetName = deserializeCV(bytesReader);\n conditionCode = bytesReader.readUInt8Enum(NonFungibleConditionCode, n => {\n throw new DeserializationError(`Could not read ${n} as FungibleConditionCode`);\n });\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal,\n conditionCode,\n asset,\n assetName,\n };\n }\n}\nexport function serializePayload(payload) {\n return bytesToHex(serializePayloadBytes(payload));\n}\nexport function serializePayloadBytes(payload) {\n const bytesArray = [];\n bytesArray.push(payload.payloadType);\n switch (payload.payloadType) {\n case PayloadType.TokenTransfer:\n bytesArray.push(serializeCVBytes(payload.recipient));\n bytesArray.push(intToBytes(payload.amount, 8));\n bytesArray.push(serializeStacksWireBytes(payload.memo));\n break;\n case PayloadType.ContractCall:\n bytesArray.push(serializeStacksWireBytes(payload.contractAddress));\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.functionName));\n const numArgs = new Uint8Array(4);\n writeUInt32BE(numArgs, payload.functionArgs.length, 0);\n bytesArray.push(numArgs);\n payload.functionArgs.forEach(arg => {\n bytesArray.push(serializeCVBytes(arg));\n });\n break;\n case PayloadType.SmartContract:\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.VersionedSmartContract:\n bytesArray.push(payload.clarityVersion);\n bytesArray.push(serializeStacksWireBytes(payload.contractName));\n bytesArray.push(serializeStacksWireBytes(payload.codeBody));\n break;\n case PayloadType.PoisonMicroblock:\n break;\n case PayloadType.Coinbase:\n bytesArray.push(payload.coinbaseBytes);\n break;\n case PayloadType.CoinbaseToAltRecipient:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient));\n break;\n case PayloadType.NakamotoCoinbase:\n bytesArray.push(payload.coinbaseBytes);\n bytesArray.push(serializeCVBytes(payload.recipient ? someCV(payload.recipient) : noneCV()));\n bytesArray.push(payload.vrfProof);\n break;\n case PayloadType.TenureChange:\n bytesArray.push(hexToBytes(payload.tenureHash));\n bytesArray.push(hexToBytes(payload.previousTenureHash));\n bytesArray.push(hexToBytes(payload.burnViewHash));\n bytesArray.push(hexToBytes(payload.previousTenureEnd));\n bytesArray.push(writeUInt32BE(new Uint8Array(4), payload.previousTenureBlocks));\n bytesArray.push(writeUInt8(new Uint8Array(1), payload.cause));\n bytesArray.push(hexToBytes(payload.publicKeyHash));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializePayload(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const payloadType = bytesReader.readUInt8Enum(PayloadType, n => {\n throw new Error(`Cannot recognize PayloadType: ${n}`);\n });\n switch (payloadType) {\n case PayloadType.TokenTransfer:\n const recipient = deserializeCV(bytesReader);\n const amount = intToBigInt(bytesReader.readBytes(8));\n const memo = deserializeMemoString(bytesReader);\n return createTokenTransferPayload(recipient, amount, memo);\n case PayloadType.ContractCall:\n const contractAddress = deserializeAddress(bytesReader);\n const contractCallName = deserializeLPString(bytesReader);\n const functionName = deserializeLPString(bytesReader);\n const functionArgs = [];\n const numberOfArgs = bytesReader.readUInt32BE();\n for (let i = 0; i < numberOfArgs; i++) {\n const clarityValue = deserializeCV(bytesReader);\n functionArgs.push(clarityValue);\n }\n return createContractCallPayload(contractAddress, contractCallName, functionName, functionArgs);\n case PayloadType.SmartContract:\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, 100000);\n return createSmartContractPayload(smartContractName, codeBody);\n case PayloadType.VersionedSmartContract: {\n const clarityVersion = bytesReader.readUInt8Enum(ClarityVersion, n => {\n throw new Error(`Cannot recognize ClarityVersion: ${n}`);\n });\n const smartContractName = deserializeLPString(bytesReader);\n const codeBody = deserializeLPString(bytesReader, 4, STRING_MAX_LENGTH);\n return createSmartContractPayload(smartContractName, codeBody, clarityVersion);\n }\n case PayloadType.PoisonMicroblock:\n return createPoisonPayload();\n case PayloadType.Coinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n return createCoinbasePayload(coinbaseBytes);\n }\n case PayloadType.CoinbaseToAltRecipient: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const altRecipient = deserializeCV(bytesReader);\n return createCoinbasePayload(coinbaseBytes, altRecipient);\n }\n case PayloadType.NakamotoCoinbase: {\n const coinbaseBytes = bytesReader.readBytes(COINBASE_BYTES_LENGTH);\n const recipient = deserializeCV(bytesReader);\n const vrfProof = bytesReader.readBytes(VRF_PROOF_BYTES_LENGTH);\n return createNakamotoCoinbasePayload(coinbaseBytes, recipient, vrfProof);\n }\n case PayloadType.TenureChange:\n const tenureHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureHash = bytesToHex(bytesReader.readBytes(20));\n const burnViewHash = bytesToHex(bytesReader.readBytes(20));\n const previousTenureEnd = bytesToHex(bytesReader.readBytes(32));\n const previousTenureBlocks = bytesReader.readUInt32BE();\n const cause = bytesReader.readUInt8Enum(TenureChangeCause, n => {\n throw new Error(`Cannot recognize TenureChangeCause: ${n}`);\n });\n const publicKeyHash = bytesToHex(bytesReader.readBytes(20));\n return createTenureChangePayload(tenureHash, previousTenureHash, burnViewHash, previousTenureEnd, previousTenureBlocks, cause, publicKeyHash);\n }\n}\nexport function deserializeMessageSignature(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n return createMessageSignature(bytesToHex(bytesReader.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)));\n}\nexport function deserializeTransactionAuthField(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const authFieldType = bytesReader.readUInt8Enum(AuthFieldType, n => {\n throw new DeserializationError(`Could not read ${n} as AuthFieldType`);\n });\n switch (authFieldType) {\n case AuthFieldType.PublicKeyCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializePublicKey(bytesReader));\n case AuthFieldType.PublicKeyUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, createStacksPublicKey(uncompressPublicKey(deserializePublicKey(bytesReader).data)));\n case AuthFieldType.SignatureCompressed:\n return createTransactionAuthField(PubKeyEncoding.Compressed, deserializeMessageSignature(bytesReader));\n case AuthFieldType.SignatureUncompressed:\n return createTransactionAuthField(PubKeyEncoding.Uncompressed, deserializeMessageSignature(bytesReader));\n default:\n throw new Error(`Unknown auth field type: ${JSON.stringify(authFieldType)}`);\n }\n}\nexport function serializeMessageSignature(messageSignature) {\n return bytesToHex(serializeMessageSignatureBytes(messageSignature));\n}\nexport function serializeMessageSignatureBytes(messageSignature) {\n return hexToBytes(messageSignature.data);\n}\nexport function serializeTransactionAuthField(field) {\n return bytesToHex(serializeTransactionAuthFieldBytes(field));\n}\nexport function serializeTransactionAuthFieldBytes(field) {\n const bytesArray = [];\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.PublicKeyCompressed\n : AuthFieldType.PublicKeyUncompressed);\n bytesArray.push(hexToBytes(compressPublicKey(field.contents.data)));\n break;\n case StacksWireType.MessageSignature:\n bytesArray.push(field.pubKeyEncoding === PubKeyEncoding.Compressed\n ? AuthFieldType.SignatureCompressed\n : AuthFieldType.SignatureUncompressed);\n bytesArray.push(serializeMessageSignatureBytes(field.contents));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function serializePublicKey(key) {\n return bytesToHex(serializePublicKeyBytes(key));\n}\nexport function serializePublicKeyBytes(key) {\n return key.data.slice();\n}\nexport function deserializePublicKey(serialized) {\n const bytesReader = isInstance(serialized, BytesReader)\n ? serialized\n : new BytesReader(serialized);\n const fieldId = bytesReader.readUInt8();\n const keyLength = fieldId === 4 ? UNCOMPRESSED_PUBKEY_LENGTH_BYTES : COMPRESSED_PUBKEY_LENGTH_BYTES;\n return createStacksPublicKey(concatArray([fieldId, bytesReader.readBytes(keyLength)]));\n}\n//# sourceMappingURL=serialization.js.map","import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { getPublicKey as nobleGetPublicKey, Point, Signature, signSync, utils, } from '@noble/secp256k1';\nimport { bytesToHex, hexToBigInt, hexToBytes, intToHex, parseRecoverableSignatureVrs, PRIVATE_KEY_BYTES_COMPRESSED, privateKeyToBytes, signatureRsvToVrs, signatureVrsToRsv, } from '@stacks/common';\nimport { networkFrom, STACKS_MAINNET } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { addressHashModeToVersion } from './address';\nimport { AddressHashMode, PubKeyEncoding } from './constants';\nimport { hash160, hashP2PKH } from './utils';\nimport { addressFromVersionHash, addressToString, StacksWireType } from './wire';\nutils.hmacSha256Sync = (key, ...msgs) => {\n const h = hmac.create(sha256, key);\n msgs.forEach(msg => h.update(msg));\n return h.digest();\n};\nexport function getAddressFromPrivateKey(privateKey, network = 'mainnet') {\n network = networkFrom(network);\n const publicKey = privateKeyToPublic(privateKey);\n return getAddressFromPublicKey(publicKey, network);\n}\nexport function getAddressFromPublicKey(publicKey, network = 'mainnet') {\n network = networkFrom(network);\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n const addrVer = addressHashModeToVersion(AddressHashMode.P2PKH, network);\n const addr = addressFromVersionHash(addrVer, hashP2PKH(publicKey));\n const addrString = addressToString(addr);\n return addrString;\n}\nexport function createStacksPublicKey(publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return {\n type: StacksWireType.PublicKey,\n data: publicKey,\n };\n}\nexport function publicKeyFromSignatureVrs(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n const parsedSignature = parseRecoverableSignatureVrs(messageSignature);\n const signature = new Signature(hexToBigInt(parsedSignature.r), hexToBigInt(parsedSignature.s));\n const point = Point.fromSignature(messageHash, signature, parsedSignature.recoveryId);\n const compressed = pubKeyEncoding === PubKeyEncoding.Compressed;\n return point.toHex(compressed);\n}\nexport function publicKeyFromSignatureRsv(messageHash, messageSignature, pubKeyEncoding = PubKeyEncoding.Compressed) {\n return publicKeyFromSignatureVrs(messageHash, signatureRsvToVrs(messageSignature), pubKeyEncoding);\n}\nexport function privateKeyToHex(publicKey) {\n return typeof publicKey === 'string' ? publicKey : bytesToHex(publicKey);\n}\nexport const publicKeyToHex = privateKeyToHex;\nexport const isPrivateKeyCompressed = privateKeyIsCompressed;\nexport function privateKeyIsCompressed(privateKey) {\n const length = typeof privateKey === 'string' ? privateKey.length / 2 : privateKey.byteLength;\n return length === PRIVATE_KEY_BYTES_COMPRESSED;\n}\nexport const isPublicKeyCompressed = publicKeyIsCompressed;\nexport function publicKeyIsCompressed(publicKey) {\n return !publicKeyToHex(publicKey).startsWith('04');\n}\nexport function privateKeyToPublic(privateKey) {\n privateKey = privateKeyToBytes(privateKey);\n const isCompressed = privateKeyIsCompressed(privateKey);\n return bytesToHex(nobleGetPublicKey(privateKey.slice(0, 32), isCompressed));\n}\nexport function compressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(true);\n}\nexport function uncompressPublicKey(publicKey) {\n return Point.fromHex(publicKeyToHex(publicKey)).toHex(false);\n}\nexport const makeRandomPrivKey = randomPrivateKey;\nexport function randomPrivateKey() {\n return compressPrivateKey(utils.randomPrivateKey());\n}\nexport function signWithKey(privateKey, messageHash) {\n privateKey = privateKeyToBytes(privateKey);\n const [rawSignature, recoveryId] = signSync(messageHash, privateKey.slice(0, 32), {\n canonical: true,\n recovered: true,\n });\n if (recoveryId == null) {\n throw new Error('No signature recoveryId received');\n }\n const recoveryIdHex = intToHex(recoveryId, 1);\n return recoveryIdHex + Signature.fromHex(rawSignature).toCompactHex();\n}\nexport function signMessageHashRsv({ messageHash, privateKey, }) {\n return signatureVrsToRsv(signWithKey(privateKey, messageHash));\n}\nexport function compressPrivateKey(privateKey) {\n privateKey = privateKeyToHex(privateKey);\n return privateKey.length == PRIVATE_KEY_BYTES_COMPRESSED 2\n ? privateKey\n : `${privateKey}01`;\n}\nexport function privateKeyToAddress(privateKey, network) {\n const publicKey = privateKeyToPublic(privateKey);\n return publicKeyToAddressSingleSig(publicKey, network);\n}\nexport function publicKeyToAddress(...args) {\n if (typeof args[0] === 'number')\n return _publicKeyToAddress(...args);\n return publicKeyToAddressSingleSig(...args);\n}\nfunction _publicKeyToAddress(version, publicKey) {\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(version, bytesToHex(hash160(publicKey)));\n}\nexport function publicKeyToAddressSingleSig(publicKey, network) {\n network = network ? networkFrom(network) : STACKS_MAINNET;\n publicKey = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;\n return c32address(network.addressVersion.singleSig, bytesToHex(hash160(publicKey)));\n}\n//# sourceMappingURL=keys.js.map","import { asciiToBytes, bigIntToBytes, bytesToHex, concatArray, concatBytes, hexToBytes, toTwos, utf8ToBytes, writeUInt32BE, } from '@stacks/common';\nimport { CLARITY_INT_BYTE_SIZE, CLARITY_INT_SIZE } from '../constants';\nimport { SerializationError } from '../errors';\nimport { parseContractId } from '../utils';\nimport { createAddress, createLPString, serializeAddressBytes, serializeLPStringBytes, } from '../wire';\nimport { ClarityType, clarityTypeToByte } from './constants';\nfunction bytesWithTypeID(typeId, bytes) {\n return concatArray([clarityTypeToByte(typeId), bytes]);\n}\nfunction serializeBoolCV(value) {\n return new Uint8Array([clarityTypeToByte(value.type)]);\n}\nfunction serializeOptionalCV(cv) {\n if (cv.type === ClarityType.OptionalNone) {\n return new Uint8Array([clarityTypeToByte(cv.type)]);\n }\n else {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n }\n}\nfunction serializeBufferCV(cv) {\n const length = new Uint8Array(4);\n writeUInt32BE(length, Math.ceil(cv.value.length / 2), 0);\n return bytesWithTypeID(cv.type, concatBytes(length, hexToBytes(cv.value)));\n}\nfunction serializeIntCV(cv) {\n const bytes = bigIntToBytes(toTwos(BigInt(cv.value), BigInt(CLARITY_INT_SIZE)), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeUIntCV(cv) {\n const bytes = bigIntToBytes(BigInt(cv.value), CLARITY_INT_BYTE_SIZE);\n return bytesWithTypeID(cv.type, bytes);\n}\nfunction serializeStandardPrincipalCV(cv) {\n return bytesWithTypeID(cv.type, serializeAddressBytes(createAddress(cv.value)));\n}\nfunction serializeContractPrincipalCV(cv) {\n const [address, name] = parseContractId(cv.value);\n return bytesWithTypeID(cv.type, concatBytes(serializeAddressBytes(createAddress(address)), serializeLPStringBytes(createLPString(name))));\n}\nfunction serializeResponseCV(cv) {\n return bytesWithTypeID(cv.type, serializeCVBytes(cv.value));\n}\nfunction serializeListCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, cv.value.length, 0);\n bytesArray.push(length);\n for (const value of cv.value) {\n const serializedValue = serializeCVBytes(value);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeTupleCV(cv) {\n const bytesArray = [];\n const length = new Uint8Array(4);\n writeUInt32BE(length, Object.keys(cv.value).length, 0);\n bytesArray.push(length);\n const lexicographicOrder = Object.keys(cv.value).sort((a, b) => a.localeCompare(b));\n for (const key of lexicographicOrder) {\n const nameWithLength = createLPString(key);\n bytesArray.push(serializeLPStringBytes(nameWithLength));\n const serializedValue = serializeCVBytes(cv.value[key]);\n bytesArray.push(serializedValue);\n }\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringCV(cv, encoding) {\n const bytesArray = [];\n const str = encoding == 'ascii' ? asciiToBytes(cv.value) : utf8ToBytes(cv.value);\n const len = new Uint8Array(4);\n writeUInt32BE(len, str.length, 0);\n bytesArray.push(len);\n bytesArray.push(str);\n return bytesWithTypeID(cv.type, concatArray(bytesArray));\n}\nfunction serializeStringAsciiCV(cv) {\n return serializeStringCV(cv, 'ascii');\n}\nfunction serializeStringUtf8CV(cv) {\n return serializeStringCV(cv, 'utf8');\n}\nexport function serializeCV(value) {\n return bytesToHex(serializeCVBytes(value));\n}\nexport function serializeCVBytes(value) {\n switch (value.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return serializeBoolCV(value);\n case ClarityType.OptionalNone:\n case ClarityType.OptionalSome:\n return serializeOptionalCV(value);\n case ClarityType.Buffer:\n return serializeBufferCV(value);\n case ClarityType.UInt:\n return serializeUIntCV(value);\n case ClarityType.Int:\n return serializeIntCV(value);\n case ClarityType.PrincipalStandard:\n return serializeStandardPrincipalCV(value);\n case ClarityType.PrincipalContract:\n return serializeContractPrincipalCV(value);\n case ClarityType.ResponseOk:\n case ClarityType.ResponseErr:\n return serializeResponseCV(value);\n case ClarityType.List:\n return serializeListCV(value);\n case ClarityType.Tuple:\n return serializeTupleCV(value);\n case ClarityType.StringASCII:\n return serializeStringAsciiCV(value);\n case ClarityType.StringUTF8:\n return serializeStringUtf8CV(value);\n default:\n throw new SerializationError('Unable to serialize. Invalid Clarity Value.');\n }\n}\n//# sourceMappingURL=serialize.js.map","import { STACKS_MAINNET, TransactionVersion, networkFrom, } from '@stacks/network';\nimport { AddressHashMode, AddressVersion } from './constants';\nexport function addressHashModeToVersion(hashMode, network) {\n network = networkFrom(network ?? STACKS_MAINNET);\n switch (hashMode) {\n case AddressHashMode.P2PKH:\n switch (network.transactionVersion) {\n case TransactionVersion.Mainnet:\n return AddressVersion.MainnetSingleSig;\n case TransactionVersion.Testnet:\n return AddressVersion.TestnetSingleSig;\n default:\n throw new Error(`Unexpected transactionVersion ${network.transactionVersion} for hashMode ${hashMode}`);\n }\n case AddressHashMode.P2SH:\n case AddressHashMode.P2SHNonSequential:\n case AddressHashMode.P2WPKH:\n case AddressHashMode.P2WSH:\n case AddressHashMode.P2WSHNonSequential:\n switch (network.transactionVersion) {\n case TransactionVersion.Mainnet:\n return AddressVersion.MainnetMultiSig;\n case TransactionVersion.Testnet:\n return AddressVersion.TestnetMultiSig;\n default:\n throw new Error(`Unexpected transactionVersion ${network.transactionVersion} for hashMode ${hashMode}`);\n }\n default:\n throw new Error(`Unexpected hashMode ${hashMode}`);\n }\n}\n//# sourceMappingURL=address.js.map","import { bytesToHex, concatArray, hexToBytes, intToBigInt, intToBytes, writeUInt16BE, } from '@stacks/common';\nimport { AddressHashMode, AuthType, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { DeserializationError, SigningError, VerificationError } from './errors';\nimport { createStacksPublicKey, privateKeyToPublic, publicKeyFromSignatureVrs, publicKeyIsCompressed, signWithKey, } from './keys';\nimport { cloneDeep, leftPadHex, txidFromData } from './utils';\nimport { addressFromPublicKeys, createEmptyAddress, createLPList, deserializeLPList, deserializeMessageSignature, serializeLPListBytes, serializeMessageSignatureBytes, StacksWireType, } from './wire';\nexport function emptyMessageSignature() {\n return {\n type: StacksWireType.MessageSignature,\n data: bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES)),\n };\n}\nexport function createSpendingCondition(options) {\n if ('publicKey' in options) {\n return createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n return createMultiSigSpendingCondition(AddressHashMode.P2SH, options.numSignatures, options.publicKeys, options.nonce, options.fee);\n}\nexport function createSingleSigSpendingCondition(hashMode, pubKey, nonce, fee) {\n const signer = addressFromPublicKeys(0, hashMode, 1, [createStacksPublicKey(pubKey)]).hash160;\n const keyEncoding = publicKeyIsCompressed(pubKey)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n keyEncoding,\n signature: emptyMessageSignature(),\n };\n}\nexport function createMultiSigSpendingCondition(hashMode, numSigs, pubKeys, nonce, fee) {\n const stacksPublicKeys = pubKeys.map(createStacksPublicKey);\n const signer = addressFromPublicKeys(0, hashMode, numSigs, stacksPublicKeys).hash160;\n return {\n hashMode,\n signer,\n nonce: intToBigInt(nonce),\n fee: intToBigInt(fee),\n fields: [],\n signaturesRequired: numSigs,\n };\n}\nexport function isSingleSig(condition) {\n return 'signature' in condition;\n}\nexport function isSequentialMultiSig(hashMode) {\n return hashMode === AddressHashMode.P2SH \|\| hashMode === AddressHashMode.P2WSH;\n}\nexport function isNonSequentialMultiSig(hashMode) {\n return (hashMode === AddressHashMode.P2SHNonSequential \|\|\n hashMode === AddressHashMode.P2WSHNonSequential);\n}\nfunction clearCondition(condition) {\n const cloned = cloneDeep(condition);\n cloned.nonce = 0;\n cloned.fee = 0;\n if (isSingleSig(cloned)) {\n cloned.signature = emptyMessageSignature();\n }\n else {\n cloned.fields = [];\n }\n return {\n ...cloned,\n nonce: BigInt(0),\n fee: BigInt(0),\n };\n}\nexport function serializeSingleSigSpendingCondition(condition) {\n return bytesToHex(serializeSingleSigSpendingConditionBytes(condition));\n}\nexport function serializeSingleSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n condition.keyEncoding,\n serializeMessageSignatureBytes(condition.signature),\n ];\n return concatArray(bytesArray);\n}\nexport function serializeMultiSigSpendingCondition(condition) {\n return bytesToHex(serializeMultiSigSpendingConditionBytes(condition));\n}\nexport function serializeMultiSigSpendingConditionBytes(condition) {\n const bytesArray = [\n condition.hashMode,\n hexToBytes(condition.signer),\n intToBytes(condition.nonce, 8),\n intToBytes(condition.fee, 8),\n ];\n const fields = createLPList(condition.fields);\n bytesArray.push(serializeLPListBytes(fields));\n const numSigs = new Uint8Array(2);\n writeUInt16BE(numSigs, condition.signaturesRequired, 0);\n bytesArray.push(numSigs);\n return concatArray(bytesArray);\n}\nexport function deserializeSingleSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const fee = BigInt(`0x${bytesToHex(bytesReader.readBytes(8))}`);\n const keyEncoding = bytesReader.readUInt8Enum(PubKeyEncoding, n => {\n throw new DeserializationError(`Could not parse ${n} as PubKeyEncoding`);\n });\n if (hashMode === AddressHashMode.P2WPKH && keyEncoding != PubKeyEncoding.Compressed) {\n throw new DeserializationError('Failed to parse singlesig spending condition: incomaptible hash mode and key encoding');\n }\n const signature = deserializeMessageSignature(bytesReader);\n return {\n hashMode,\n signer,\n nonce,\n fee,\n keyEncoding,\n signature,\n };\n}\nexport function deserializeMultiSigSpendingCondition(hashMode, bytesReader) {\n const signer = bytesToHex(bytesReader.readBytes(20));\n const nonce = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fee = BigInt('0x' + bytesToHex(bytesReader.readBytes(8)));\n const fields = deserializeLPList(bytesReader, StacksWireType.TransactionAuthField)\n .values;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Failed to parse multisig spending condition: too many signatures');\n break;\n }\n }\n const signaturesRequired = bytesReader.readUInt16BE();\n if (haveUncompressed &&\n (hashMode === AddressHashMode.P2WSH \|\| hashMode === AddressHashMode.P2WSHNonSequential)) {\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n }\n return {\n hashMode,\n signer,\n nonce,\n fee,\n fields,\n signaturesRequired,\n };\n}\nexport function serializeSpendingCondition(condition) {\n return bytesToHex(serializeSpendingConditionBytes(condition));\n}\nexport function serializeSpendingConditionBytes(condition) {\n if (isSingleSig(condition))\n return serializeSingleSigSpendingConditionBytes(condition);\n return serializeMultiSigSpendingConditionBytes(condition);\n}\nexport function deserializeSpendingCondition(bytesReader) {\n const hashMode = bytesReader.readUInt8Enum(AddressHashMode, n => {\n throw new DeserializationError(`Could not parse ${n} as AddressHashMode`);\n });\n if (hashMode === AddressHashMode.P2PKH \|\| hashMode === AddressHashMode.P2WPKH) {\n return deserializeSingleSigSpendingCondition(hashMode, bytesReader);\n }\n else {\n return deserializeMultiSigSpendingCondition(hashMode, bytesReader);\n }\n}\nexport function sigHashPreSign(curSigHash, authType, fee, nonce) {\n const hashLength = 32 + 1 + 8 + 8;\n const sigHash = curSigHash +\n bytesToHex(new Uint8Array([authType])) +\n bytesToHex(intToBytes(fee, 8)) +\n bytesToHex(intToBytes(nonce, 8));\n if (hexToBytes(sigHash).byteLength !== hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(hexToBytes(sigHash));\n}\nfunction sigHashPostSign(curSigHash, pubKey, signature) {\n const hashLength = 32 + 1 + RECOVERABLE_ECDSA_SIG_LENGTH_BYTES;\n const pubKeyEncoding = publicKeyIsCompressed(pubKey.data)\n ? PubKeyEncoding.Compressed\n : PubKeyEncoding.Uncompressed;\n const sigHash = curSigHash + leftPadHex(pubKeyEncoding.toString(16)) + signature;\n const sigHashBytes = hexToBytes(sigHash);\n if (sigHashBytes.byteLength > hashLength) {\n throw Error('Invalid signature hash length');\n }\n return txidFromData(sigHashBytes);\n}\nexport function nextSignature(curSigHash, authType, fee, nonce, privateKey) {\n const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);\n const signature = signWithKey(privateKey, sigHashPre);\n const publicKey = createStacksPublicKey(privateKeyToPublic(privateKey));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n nextSig: signature,\n nextSigHash,\n };\n}\nexport function nextVerification(initialSigHash, authType, fee, nonce, pubKeyEncoding, signature) {\n const sigHashPre = sigHashPreSign(initialSigHash, authType, fee, nonce);\n const publicKey = createStacksPublicKey(publicKeyFromSignatureVrs(sigHashPre, signature, pubKeyEncoding));\n const nextSigHash = sigHashPostSign(sigHashPre, publicKey, signature);\n return {\n pubKey: publicKey,\n nextSigHash,\n };\n}\nfunction newInitialSigHash() {\n const spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, '', 0, 0);\n spendingCondition.signer = createEmptyAddress().hash160;\n spendingCondition.keyEncoding = PubKeyEncoding.Compressed;\n spendingCondition.signature = emptyMessageSignature();\n return spendingCondition;\n}\nfunction verify(condition, initialSigHash, authType) {\n if (isSingleSig(condition)) {\n return verifySingleSig(condition, initialSigHash, authType);\n }\n else {\n return verifyMultiSig(condition, initialSigHash, authType);\n }\n}\nfunction verifySingleSig(condition, initialSigHash, authType) {\n const { pubKey, nextSigHash } = nextVerification(initialSigHash, authType, condition.fee, condition.nonce, condition.keyEncoding, condition.signature.data);\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, 1, [pubKey]).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return nextSigHash;\n}\nfunction verifyMultiSig(condition, initialSigHash, authType) {\n const publicKeys = [];\n let curSigHash = initialSigHash;\n let haveUncompressed = false;\n let numSigs = 0;\n for (const field of condition.fields) {\n switch (field.contents.type) {\n case StacksWireType.PublicKey:\n if (!publicKeyIsCompressed(field.contents.data))\n haveUncompressed = true;\n publicKeys.push(field.contents);\n break;\n case StacksWireType.MessageSignature:\n if (field.pubKeyEncoding === PubKeyEncoding.Uncompressed)\n haveUncompressed = true;\n const { pubKey, nextSigHash } = nextVerification(curSigHash, authType, condition.fee, condition.nonce, field.pubKeyEncoding, field.contents.data);\n if (isSequentialMultiSig(condition.hashMode)) {\n curSigHash = nextSigHash;\n }\n publicKeys.push(pubKey);\n numSigs += 1;\n if (numSigs === 65536)\n throw new VerificationError('Too many signatures');\n break;\n }\n }\n if ((isSequentialMultiSig(condition.hashMode) && numSigs !== condition.signaturesRequired) \|\|\n (isNonSequentialMultiSig(condition.hashMode) && numSigs < condition.signaturesRequired))\n throw new VerificationError('Incorrect number of signatures');\n if (haveUncompressed &&\n (condition.hashMode === AddressHashMode.P2WSH \|\|\n condition.hashMode === AddressHashMode.P2WSHNonSequential))\n throw new VerificationError('Uncompressed keys are not allowed in this hash mode');\n const addrBytes = addressFromPublicKeys(0, condition.hashMode, condition.signaturesRequired, publicKeys).hash160;\n if (addrBytes !== condition.signer)\n throw new VerificationError(`Signer hash does not equal hash of public key(s): ${addrBytes} != ${condition.signer}`);\n return curSigHash;\n}\nexport function createStandardAuth(spendingCondition) {\n return {\n authType: AuthType.Standard,\n spendingCondition,\n };\n}\nexport function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {\n return {\n authType: AuthType.Sponsored,\n spendingCondition,\n sponsorSpendingCondition: sponsorSpendingCondition\n ? sponsorSpendingCondition\n : createSingleSigSpendingCondition(AddressHashMode.P2PKH, '0'.repeat(66), 0, 0),\n };\n}\nexport function intoInitialSighashAuth(auth) {\n if (auth.spendingCondition) {\n switch (auth.authType) {\n case AuthType.Standard:\n return createStandardAuth(clearCondition(auth.spendingCondition));\n case AuthType.Sponsored:\n return createSponsoredAuth(clearCondition(auth.spendingCondition), newInitialSigHash());\n default:\n throw new SigningError('Unexpected authorization type for signing');\n }\n }\n throw new Error('Authorization missing SpendingCondition');\n}\nexport function verifyOrigin(auth, initialSigHash) {\n switch (auth.authType) {\n case AuthType.Standard:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n case AuthType.Sponsored:\n return verify(auth.spendingCondition, initialSigHash, AuthType.Standard);\n default:\n throw new SigningError('Invalid origin auth type');\n }\n}\nexport function setFee(auth, amount) {\n switch (auth.authType) {\n case AuthType.Standard:\n const spendingCondition = {\n ...auth.spendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, spendingCondition };\n case AuthType.Sponsored:\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n fee: intToBigInt(amount),\n };\n return { ...auth, sponsorSpendingCondition };\n }\n}\nexport function getFee(auth) {\n switch (auth.authType) {\n case AuthType.Standard:\n return auth.spendingCondition.fee;\n case AuthType.Sponsored:\n return auth.sponsorSpendingCondition.fee;\n }\n}\nexport function setNonce(auth, nonce) {\n const spendingCondition = {\n ...auth.spendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n spendingCondition,\n };\n}\nexport function setSponsorNonce(auth, nonce) {\n const sponsorSpendingCondition = {\n ...auth.sponsorSpendingCondition,\n nonce: intToBigInt(nonce),\n };\n return {\n ...auth,\n sponsorSpendingCondition,\n };\n}\nexport function setSponsor(auth, sponsorSpendingCondition) {\n const sc = {\n ...sponsorSpendingCondition,\n nonce: intToBigInt(sponsorSpendingCondition.nonce),\n fee: intToBigInt(sponsorSpendingCondition.fee),\n };\n return {\n ...auth,\n sponsorSpendingCondition: sc,\n };\n}\nexport function serializeAuthorization(auth) {\n return bytesToHex(serializeAuthorizationBytes(auth));\n}\nexport function serializeAuthorizationBytes(auth) {\n const bytesArray = [];\n bytesArray.push(auth.authType);\n switch (auth.authType) {\n case AuthType.Standard:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n break;\n case AuthType.Sponsored:\n bytesArray.push(serializeSpendingConditionBytes(auth.spendingCondition));\n bytesArray.push(serializeSpendingConditionBytes(auth.sponsorSpendingCondition));\n break;\n }\n return concatArray(bytesArray);\n}\nexport function deserializeAuthorization(bytesReader) {\n const authType = bytesReader.readUInt8Enum(AuthType, n => {\n throw new DeserializationError(`Could not parse ${n} as AuthType`);\n });\n let spendingCondition;\n switch (authType) {\n case AuthType.Standard:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n return createStandardAuth(spendingCondition);\n case AuthType.Sponsored:\n spendingCondition = deserializeSpendingCondition(bytesReader);\n const sponsorSpendingCondition = deserializeSpendingCondition(bytesReader);\n return createSponsoredAuth(spendingCondition, sponsorSpendingCondition);\n }\n}\n//# sourceMappingURL=authorization.js.map","import { ClarityType } from './constants';\nimport { asciiToBytes, bytesToAscii, hexToBytes, utf8ToBytes } from '@stacks/common';\nexport function cvToString(val, encoding = 'hex') {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return 'true';\n case ClarityType.BoolFalse:\n return 'false';\n case ClarityType.Int:\n return val.value.toString();\n case ClarityType.UInt:\n return `u${val.value.toString()}`;\n case ClarityType.Buffer:\n if (encoding === 'tryAscii') {\n const str = bytesToAscii(hexToBytes(val.value));\n if (/[ -~]/.test(str)) {\n return JSON.stringify(str);\n }\n }\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return 'none';\n case ClarityType.OptionalSome:\n return `(some ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseErr:\n return `(err ${cvToString(val.value, encoding)})`;\n case ClarityType.ResponseOk:\n return `(ok ${cvToString(val.value, encoding)})`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return `(list ${val.value.map(v => cvToString(v, encoding)).join(' ')})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${cvToString(val.value[key], encoding)})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `\"${val.value}\"`;\n case ClarityType.StringUTF8:\n return `u\"${val.value}\"`;\n }\n}\nexport function cvToValue(val, strictJsonCompat = false) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n return true;\n case ClarityType.BoolFalse:\n return false;\n case ClarityType.Int:\n case ClarityType.UInt:\n if (strictJsonCompat) {\n return val.value.toString();\n }\n return val.value;\n case ClarityType.Buffer:\n return `0x${val.value}`;\n case ClarityType.OptionalNone:\n return null;\n case ClarityType.OptionalSome:\n return cvToJSON(val.value);\n case ClarityType.ResponseErr:\n return cvToJSON(val.value);\n case ClarityType.ResponseOk:\n return cvToJSON(val.value);\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return val.value;\n case ClarityType.List:\n return val.value.map(v => cvToJSON(v));\n case ClarityType.Tuple:\n const result = {};\n Object.keys(val.value).forEach(key => {\n result[key] = cvToJSON(val.value[key]);\n });\n return result;\n case ClarityType.StringASCII:\n return val.value;\n case ClarityType.StringUTF8:\n return val.value;\n }\n}\nexport function cvToJSON(val) {\n switch (val.type) {\n case ClarityType.ResponseErr:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: false };\n case ClarityType.ResponseOk:\n return { type: getCVTypeString(val), value: cvToValue(val, true), success: true };\n default:\n return { type: getCVTypeString(val), value: cvToValue(val, true) };\n }\n}\nexport function getCVTypeString(val) {\n switch (val.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return 'bool';\n case ClarityType.Int:\n return 'int';\n case ClarityType.UInt:\n return 'uint';\n case ClarityType.Buffer:\n return `(buff ${Math.ceil(val.value.length / 2)})`;\n case ClarityType.OptionalNone:\n return '(optional none)';\n case ClarityType.OptionalSome:\n return `(optional ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseErr:\n return `(response UnknownType ${getCVTypeString(val.value)})`;\n case ClarityType.ResponseOk:\n return `(response ${getCVTypeString(val.value)} UnknownType)`;\n case ClarityType.PrincipalStandard:\n case ClarityType.PrincipalContract:\n return 'principal';\n case ClarityType.List:\n return `(list ${val.value.length} ${val.value.length ? getCVTypeString(val.value[0]) : 'UnknownType'})`;\n case ClarityType.Tuple:\n return `(tuple ${Object.keys(val.value)\n .map(key => `(${key} ${getCVTypeString(val.value[key])})`)\n .join(' ')})`;\n case ClarityType.StringASCII:\n return `(string-ascii ${asciiToBytes(val.value).length})`;\n case ClarityType.StringUTF8:\n return `(string-utf8 ${utf8ToBytes(val.value).length})`;\n }\n}\nexport function isClarityType(input, withType) {\n return input.type === withType;\n}\n//# sourceMappingURL=clarityValue.js.map","import { hexToBytes, utf8ToBytes } from '@stacks/common';\nimport { ClarityType, bufferCV, bufferCVFromString, contractPrincipalCV, falseCV, getCVTypeString, intCV, noneCV, someCV, standardPrincipalCV, stringAsciiCV, stringUtf8CV, trueCV, uintCV, } from './clarity';\nimport { NotImplementedError } from './errors';\nimport { cloneDeep } from './utils';\nexport var ClarityAbiTypeId;\n(function (ClarityAbiTypeId) {\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeUInt128\"] = 1] = \"ClarityAbiTypeUInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeInt128\"] = 2] = \"ClarityAbiTypeInt128\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBool\"] = 3] = \"ClarityAbiTypeBool\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypePrincipal\"] = 4] = \"ClarityAbiTypePrincipal\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeNone\"] = 5] = \"ClarityAbiTypeNone\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeBuffer\"] = 6] = \"ClarityAbiTypeBuffer\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeResponse\"] = 7] = \"ClarityAbiTypeResponse\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeOptional\"] = 8] = \"ClarityAbiTypeOptional\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTuple\"] = 9] = \"ClarityAbiTypeTuple\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeList\"] = 10] = \"ClarityAbiTypeList\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringAscii\"] = 11] = \"ClarityAbiTypeStringAscii\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeStringUtf8\"] = 12] = \"ClarityAbiTypeStringUtf8\";\n ClarityAbiTypeId[ClarityAbiTypeId[\"ClarityAbiTypeTraitReference\"] = 13] = \"ClarityAbiTypeTraitReference\";\n})(ClarityAbiTypeId \|\| (ClarityAbiTypeId = {}));\nexport const isClarityAbiPrimitive = (val) => typeof val === 'string';\nexport const isClarityAbiBuffer = (val) => val.buffer !== undefined;\nexport const isClarityAbiStringAscii = (val) => val['string-ascii'] !== undefined;\nexport const isClarityAbiStringUtf8 = (val) => val['string-utf8'] !== undefined;\nexport const isClarityAbiResponse = (val) => val.response !== undefined;\nexport const isClarityAbiOptional = (val) => val.optional !== undefined;\nexport const isClarityAbiTuple = (val) => val.tuple !== undefined;\nexport const isClarityAbiList = (val) => val.list !== undefined;\nexport function getTypeUnion(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'uint128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeUInt128, type: val };\n }\n else if (val === 'int128') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeInt128, type: val };\n }\n else if (val === 'bool') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBool, type: val };\n }\n else if (val === 'principal') {\n return { id: ClarityAbiTypeId.ClarityAbiTypePrincipal, type: val };\n }\n else if (val === 'trait_reference') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTraitReference, type: val };\n }\n else if (val === 'none') {\n return { id: ClarityAbiTypeId.ClarityAbiTypeNone, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);\n }\n }\n else if (isClarityAbiBuffer(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeBuffer, type: val };\n }\n else if (isClarityAbiResponse(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeResponse, type: val };\n }\n else if (isClarityAbiOptional(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeOptional, type: val };\n }\n else if (isClarityAbiTuple(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeTuple, type: val };\n }\n else if (isClarityAbiList(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeList, type: val };\n }\n else if (isClarityAbiStringAscii(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringAscii, type: val };\n }\n else if (isClarityAbiStringUtf8(val)) {\n return { id: ClarityAbiTypeId.ClarityAbiTypeStringUtf8, type: val };\n }\n else {\n throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);\n }\n}\nexport function encodeAbiClarityValue(value, type) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n switch (union.id) {\n case ClarityAbiTypeId.ClarityAbiTypeUInt128:\n return uintCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeInt128:\n return intCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeBool:\n if (value === 'false' \|\| value === '0')\n return falseCV();\n else if (value === 'true' \|\| value === '1')\n return trueCV();\n else\n throw new Error(`Unexpected Clarity bool value: ${JSON.stringify(value)}`);\n case ClarityAbiTypeId.ClarityAbiTypePrincipal:\n if (value.includes('.')) {\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n }\n else {\n return standardPrincipalCV(value);\n }\n case ClarityAbiTypeId.ClarityAbiTypeTraitReference:\n const [addr, name] = value.split('.');\n return contractPrincipalCV(addr, name);\n case ClarityAbiTypeId.ClarityAbiTypeNone:\n return noneCV();\n case ClarityAbiTypeId.ClarityAbiTypeBuffer:\n return bufferCV(hexToBytes(value));\n case ClarityAbiTypeId.ClarityAbiTypeStringAscii:\n return stringAsciiCV(value);\n case ClarityAbiTypeId.ClarityAbiTypeStringUtf8:\n return stringUtf8CV(value);\n case ClarityAbiTypeId.ClarityAbiTypeOptional:\n return someCV(encodeAbiClarityValue(value, union.type.optional));\n case ClarityAbiTypeId.ClarityAbiTypeResponse:\n case ClarityAbiTypeId.ClarityAbiTypeTuple:\n case ClarityAbiTypeId.ClarityAbiTypeList:\n throw new NotImplementedError(`Unsupported encoding for Clarity type: ${union.id}`);\n default:\n throw new Error(`Unexpected Clarity type ID: ${JSON.stringify(union)}`);\n }\n}\nexport function encodeClarityValue(type, value) {\n const union = type.id\n ? type\n : getTypeUnion(type);\n if (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer) {\n return bufferCV(utf8ToBytes(value));\n }\n return encodeAbiClarityValue(value, union);\n}\nexport function getTypeString(val) {\n if (isClarityAbiPrimitive(val)) {\n if (val === 'int128') {\n return 'int';\n }\n else if (val === 'uint128') {\n return 'uint';\n }\n return val;\n }\n else if (isClarityAbiBuffer(val)) {\n return `(buff ${val.buffer.length})`;\n }\n else if (isClarityAbiStringAscii(val)) {\n return `(string-ascii ${val['string-ascii'].length})`;\n }\n else if (isClarityAbiStringUtf8(val)) {\n return `(string-utf8 ${val['string-utf8'].length})`;\n }\n else if (isClarityAbiResponse(val)) {\n return `(response ${getTypeString(val.response.ok)} ${getTypeString(val.response.error)})`;\n }\n else if (isClarityAbiOptional(val)) {\n return `(optional ${getTypeString(val.optional)})`;\n }\n else if (isClarityAbiTuple(val)) {\n return `(tuple ${val.tuple.map(t => `(${t.name} ${getTypeString(t.type)})`).join(' ')})`;\n }\n else if (isClarityAbiList(val)) {\n return `(list ${val.list.length} ${getTypeString(val.list.type)})`;\n }\n else {\n throw new Error(`Type string unsupported for Clarity type: ${JSON.stringify(val)}`);\n }\n}\nexport function abiFunctionToString(func) {\n const access = func.access === 'read_only' ? 'read-only' : func.access;\n return `(define-${access} (${func.name} ${func.args\n .map(arg => `(${arg.name} ${getTypeString(arg.type)})`)\n .join(' ')}))`;\n}\nfunction matchType(cv, abiType) {\n const union = getTypeUnion(abiType);\n switch (cv.type) {\n case ClarityType.BoolTrue:\n case ClarityType.BoolFalse:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeBool;\n case ClarityType.Int:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeInt128;\n case ClarityType.UInt:\n return union.id === ClarityAbiTypeId.ClarityAbiTypeUInt128;\n case ClarityType.Buffer:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeBuffer &&\n union.type.buffer.length >= Math.ceil(cv.value.length / 2));\n case ClarityType.StringASCII:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringAscii &&\n union.type['string-ascii'].length >= cv.value.length);\n case ClarityType.StringUTF8:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeStringUtf8 &&\n union.type['string-utf8'].length >= cv.value.length);\n case ClarityType.OptionalNone:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeNone \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeOptional);\n case ClarityType.OptionalSome:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeOptional &&\n matchType(cv.value, union.type.optional));\n case ClarityType.ResponseErr:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.error));\n case ClarityType.ResponseOk:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypeResponse &&\n matchType(cv.value, union.type.response.ok));\n case ClarityType.PrincipalContract:\n return (union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal \|\|\n union.id === ClarityAbiTypeId.ClarityAbiTypeTraitReference);\n case ClarityType.PrincipalStandard:\n return union.id === ClarityAbiTypeId.ClarityAbiTypePrincipal;\n case ClarityType.List:\n return (union.id == ClarityAbiTypeId.ClarityAbiTypeList &&\n union.type.list.length >= cv.value.length &&\n cv.value.every(val => matchType(val, union.type.list.type)));\n case ClarityType.Tuple:\n if (union.id == ClarityAbiTypeId.ClarityAbiTypeTuple) {\n const tuple = cloneDeep(cv.value);\n for (let i = 0; i < union.type.tuple.length; i++) {\n const abiTupleEntry = union.type.tuple[i];\n const key = abiTupleEntry.name;\n const val = tuple[key];\n if (val) {\n if (!matchType(val, abiTupleEntry.type)) {\n return false;\n }\n delete tuple[key];\n }\n else {\n return false;\n }\n }\n return true;\n }\n else {\n return false;\n }\n default:\n return false;\n }\n}\nexport function validateContractCall(payload, abi) {\n const filtered = abi.functions.filter(fn => fn.name === payload.functionName.content);\n if (filtered.length === 1) {\n const abiFunc = filtered[0];\n const abiArgs = abiFunc.args;\n if (payload.functionArgs.length !== abiArgs.length) {\n throw new Error(`Clarity function expects ${abiArgs.length} argument(s) but received ${payload.functionArgs.length}`);\n }\n for (let i = 0; i < payload.functionArgs.length; i++) {\n const payloadArg = payload.functionArgs[i];\n const abiArg = abiArgs[i];\n if (!matchType(payloadArg, abiArg.type)) {\n const argNum = i + 1;\n throw new Error(`Clarity function \\`${payload.functionName.content}\\` expects argument ${argNum} to be of type ${getTypeString(abiArg.type)}, not ${getCVTypeString(payloadArg)}`);\n }\n }\n return true;\n }\n else if (filtered.length === 0) {\n throw new Error(`ABI doesn't contain a function with the name ${payload.functionName.content}`);\n }\n else {\n throw new Error(`Malformed ABI. Contains multiple functions with the name ${payload.functionName.content}`);\n }\n}\nexport function parseToCV(input, type) {\n const typeString = getTypeString(type);\n if (isClarityAbiPrimitive(type)) {\n if (type === 'uint128') {\n return uintCV(input);\n }\n else if (type === 'int128') {\n return intCV(input);\n }\n else if (type === 'bool') {\n if (input.toLowerCase() === 'true') {\n return trueCV();\n }\n else if (input.toLowerCase() === 'false') {\n return falseCV();\n }\n else {\n throw new Error(`Invalid bool value: ${input}`);\n }\n }\n else if (type === 'principal') {\n if (input.includes('.')) {\n const [address, contractName] = input.split('.');\n return contractPrincipalCV(address, contractName);\n }\n else {\n return standardPrincipalCV(input);\n }\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n }\n else if (isClarityAbiBuffer(type)) {\n const inputLength = utf8ToBytes(input).byteLength;\n if (inputLength > type.buffer.length) {\n throw new Error(`Input exceeds specified buffer length limit of ${type.buffer.length}`);\n }\n return bufferCVFromString(input);\n }\n else if (isClarityAbiResponse(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiOptional(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiTuple(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else if (isClarityAbiList(type)) {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n else {\n throw new Error(`Contract function contains unsupported Clarity ABI type: ${typeString}`);\n }\n}\n//# sourceMappingURL=contract-abi.js.map","import { bytesToHex, concatArray, intToBigInt, isInstance, writeUInt32BE, } from '@stacks/common';\nimport { STACKS_MAINNET, STACKS_TESTNET, TransactionVersion, networkFrom, whenTransactionVersion, } from '@stacks/network';\nimport { serializePayloadBytes } from '.';\nimport { BytesReader } from './BytesReader';\nimport { deserializeAuthorization, intoInitialSighashAuth, isSingleSig, nextSignature, serializeAuthorizationBytes, setFee, setNonce, setSponsor, setSponsorNonce, verifyOrigin, } from './authorization';\nimport { AddressHashMode, AnchorMode, AuthType, PostConditionMode, PubKeyEncoding, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, } from './constants';\nimport { SerializationError, SigningError } from './errors';\nimport { createStacksPublicKey, privateKeyIsCompressed, publicKeyIsCompressed } from './keys';\nimport { cloneDeep, txidFromData } from './utils';\nimport { StacksWireType, createLPList, createMessageSignature, createTransactionAuthField, deserializeLPList, deserializePayload, serializeLPListBytes, } from './wire';\nexport class StacksTransactionWire {\n constructor({ auth, payload, postConditions = createLPList([]), postConditionMode = PostConditionMode.Deny, transactionVersion, chainId, network = 'mainnet', }) {\n network = networkFrom(network);\n this.transactionVersion = transactionVersion ?? network.transactionVersion;\n this.chainId = chainId ?? network.chainId;\n this.auth = auth;\n if ('amount' in payload) {\n this.payload = {\n ...payload,\n amount: intToBigInt(payload.amount),\n };\n }\n else {\n this.payload = payload;\n }\n this.postConditionMode = postConditionMode;\n this.postConditions = postConditions;\n this.anchorMode = AnchorMode.Any;\n }\n signBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyBegin() {\n const tx = cloneDeep(this);\n tx.auth = intoInitialSighashAuth(tx.auth);\n return tx.txid();\n }\n verifyOrigin() {\n return verifyOrigin(this.auth, this.verifyBegin());\n }\n signNextOrigin(sigHash, privateKey) {\n if (this.auth.spendingCondition === undefined) {\n throw new Error('\"auth.spendingCondition\" is undefined');\n }\n if (this.auth.authType === undefined) {\n throw new Error('\"auth.authType\" is undefined');\n }\n return this.signAndAppend(this.auth.spendingCondition, sigHash, AuthType.Standard, privateKey);\n }\n signNextSponsor(sigHash, privateKey) {\n if (this.auth.authType === AuthType.Sponsored) {\n return this.signAndAppend(this.auth.sponsorSpendingCondition, sigHash, AuthType.Sponsored, privateKey);\n }\n else {\n throw new Error('\"auth.sponsorSpendingCondition\" is undefined');\n }\n }\n appendPubkey(publicKey) {\n const wire = typeof publicKey === 'object' && 'type' in publicKey\n ? publicKey\n : createStacksPublicKey(publicKey);\n const cond = this.auth.spendingCondition;\n if (cond && !isSingleSig(cond)) {\n const compressed = publicKeyIsCompressed(wire.data);\n cond.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, wire));\n }\n else {\n throw new Error(`Can't append public key to a singlesig condition`);\n }\n }\n signAndAppend(condition, curSigHash, authType, privateKey) {\n const { nextSig, nextSigHash } = nextSignature(curSigHash, authType, condition.fee, condition.nonce, privateKey);\n if (isSingleSig(condition)) {\n condition.signature = createMessageSignature(nextSig);\n }\n else {\n const compressed = privateKeyIsCompressed(privateKey);\n condition.fields.push(createTransactionAuthField(compressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed, createMessageSignature(nextSig)));\n }\n return nextSigHash;\n }\n txid() {\n const serialized = this.serializeBytes();\n return txidFromData(serialized);\n }\n setSponsor(sponsorSpendingCondition) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsor(this.auth, sponsorSpendingCondition);\n }\n setFee(amount) {\n this.auth = setFee(this.auth, amount);\n }\n setNonce(nonce) {\n this.auth = setNonce(this.auth, nonce);\n }\n setSponsorNonce(nonce) {\n if (this.auth.authType != AuthType.Sponsored) {\n throw new SigningError('Cannot sponsor sign a non-sponsored transaction');\n }\n this.auth = setSponsorNonce(this.auth, nonce);\n }\n serialize() {\n return bytesToHex(this.serializeBytes());\n }\n serializeBytes() {\n if (this.transactionVersion === undefined) {\n throw new SerializationError('\"transactionVersion\" is undefined');\n }\n if (this.chainId === undefined) {\n throw new SerializationError('\"chainId\" is undefined');\n }\n if (this.auth === undefined) {\n throw new SerializationError('\"auth\" is undefined');\n }\n if (this.payload === undefined) {\n throw new SerializationError('\"payload\" is undefined');\n }\n const bytesArray = [];\n bytesArray.push(this.transactionVersion);\n const chainIdBytes = new Uint8Array(4);\n writeUInt32BE(chainIdBytes, this.chainId, 0);\n bytesArray.push(chainIdBytes);\n bytesArray.push(serializeAuthorizationBytes(this.auth));\n bytesArray.push(this.anchorMode);\n bytesArray.push(this.postConditionMode);\n bytesArray.push(serializeLPListBytes(this.postConditions));\n bytesArray.push(serializePayloadBytes(this.payload));\n return concatArray(bytesArray);\n }\n}\nexport function deserializeTransaction(tx) {\n const bytesReader = isInstance(tx, BytesReader) ? tx : new BytesReader(tx);\n const transactionVersion = bytesReader.readUInt8Enum(TransactionVersion, n => {\n throw new Error(`Could not parse ${n} as TransactionVersion`);\n });\n const chainId = bytesReader.readUInt32BE();\n const auth = deserializeAuthorization(bytesReader);\n const anchorMode = bytesReader.readUInt8Enum(AnchorMode, n => {\n throw new Error(`Could not parse ${n} as AnchorMode`);\n });\n const postConditionMode = bytesReader.readUInt8Enum(PostConditionMode, n => {\n throw new Error(`Could not parse ${n} as PostConditionMode`);\n });\n const postConditions = deserializeLPList(bytesReader, StacksWireType.PostCondition);\n const payload = deserializePayload(bytesReader);\n const transaction = new StacksTransactionWire({\n transactionVersion,\n chainId,\n auth,\n payload,\n postConditions,\n postConditionMode,\n });\n transaction.anchorMode = anchorMode;\n return transaction;\n}\nexport function deriveNetworkFromTx(transaction) {\n return whenTransactionVersion(transaction.transactionVersion)({\n [TransactionVersion.Mainnet]: STACKS_MAINNET,\n [TransactionVersion.Testnet]: STACKS_TESTNET,\n });\n}\nexport function estimateTransactionByteLength(transaction) {\n const hashMode = transaction.auth.spendingCondition.hashMode;\n const multiSigHashModes = [AddressHashMode.P2SH, AddressHashMode.P2WSH];\n if (multiSigHashModes.includes(hashMode)) {\n const multiSigSpendingCondition = transaction.auth\n .spendingCondition;\n const existingSignatures = multiSigSpendingCondition.fields.filter(field => field.contents.type === StacksWireType.MessageSignature).length;\n const totalSignatureLength = (multiSigSpendingCondition.signaturesRequired - existingSignatures) \n (RECOVERABLE_ECDSA_SIG_LENGTH_BYTES + 1);\n return transaction.serializeBytes().byteLength + totalSignatureLength;\n }\n else {\n return transaction.serializeBytes().byteLength;\n }\n}\nexport function serializeTransaction(transaction) {\n return transaction.serialize();\n}\nexport function serializeTransactionBytes(transaction) {\n return transaction.serializeBytes();\n}\nexport function transactionToHex(transaction) {\n return transaction.serialize();\n}\n//# sourceMappingURL=transaction.js.map","import { bytesToHex, validateHash256, with0x } from '@stacks/common';\nimport { clientFromNetwork, networkFrom } from '@stacks/network';\nimport { deserializeCV, serializeCV } from './clarity';\nimport { NoEstimateAvailableError } from './errors';\nimport { deriveNetworkFromTx, estimateTransactionByteLength, } from './transaction';\nimport { cvToHex, parseReadOnlyResponse } from './utils';\nimport { serializePayloadBytes } from './wire';\nexport const BROADCAST_PATH = '/v2/transactions';\nexport const TRANSFER_FEE_ESTIMATE_PATH = '/v2/fees/transfer';\nexport const TRANSACTION_FEE_ESTIMATE_PATH = '/v2/fees/transaction';\nexport const ACCOUNT_PATH = '/v2/accounts';\nexport const CONTRACT_ABI_PATH = '/v2/contracts/interface';\nexport const READONLY_FUNCTION_CALL_PATH = '/v2/contracts/call-read';\nexport const MAP_ENTRY_PATH = '/v2/map_entry';\nexport async function broadcastTransaction({ transaction: txOpt, attachment: attachOpt, network: _network, client: _client, }) {\n const tx = txOpt.serialize();\n const attachment = attachOpt\n ? typeof attachOpt === 'string'\n ? attachOpt\n : bytesToHex(attachOpt)\n : undefined;\n const json = attachOpt ? { tx, attachment } : { tx };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${BROADCAST_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n try {\n return (await response.json());\n }\n catch (e) {\n throw Error('Failed to broadcast transaction (unable to parse node response).', { cause: e });\n }\n }\n const text = await response.text();\n const txid = text.replace(/[\"]+/g, '');\n if (!validateHash256(txid))\n throw new Error(text);\n return { txid };\n}\nasync function _getNonceApi({ address, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}/extended/v1/address/${address}/nonces`;\n const response = await client.fetch(url);\n const result = await response.json();\n return BigInt(result.possible_next_nonce);\n}\nexport async function fetchNonce(opts) {\n try {\n return await _getNonceApi(opts);\n }\n catch (e) { }\n const network = networkFrom(opts.network ?? 'mainnet');\n const client = Object.assign({}, clientFromNetwork(network), opts.client);\n const url = `${client.baseUrl}${ACCOUNT_PATH}/${opts.address}?proof=0`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching nonce. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = (await response.json());\n return BigInt(json.nonce);\n}\nexport async function fetchFeeEstimateTransfer({ transaction: txOpt, network: _network, client: _client, }) {\n const network = typeof txOpt === 'number' ? 'mainnet' : _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSFER_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, {\n headers: { Accept: 'application/text' },\n });\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error estimating transfer fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const feeRateResult = await response.text();\n const txBytes = typeof txOpt === 'number'\n ? BigInt(txOpt)\n : BigInt(Math.ceil(txOpt.serializeBytes().byteLength));\n const feeRate = BigInt(feeRateResult);\n return feeRate txBytes;\n}\nexport async function fetchFeeEstimateTransaction({ payload, estimatedLength, network = 'mainnet', client: _client, }) {\n const json = {\n transaction_payload: payload,\n estimated_len: estimatedLength,\n };\n const options = {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify(json),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${TRANSACTION_FEE_ESTIMATE_PATH}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const body = await response.text().catch(() => '');\n if (body.includes('NoEstimateAvailable')) {\n let json = {};\n try {\n json = JSON.parse(body);\n }\n catch (err) {\n }\n throw new NoEstimateAvailableError(json?.reason_data?.message ?? '');\n }\n throw new Error(`Error estimating transaction fee. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${body}\"`);\n }\n const data = await response.json();\n return data.estimations;\n}\nexport async function fetchFeeEstimate({ transaction: txOpt, network: _network, client: _client, }) {\n const network = _network ?? deriveNetworkFromTx(txOpt);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n try {\n const estimatedLength = estimateTransactionByteLength(txOpt);\n return (await fetchFeeEstimateTransaction({\n payload: bytesToHex(serializePayloadBytes(txOpt.payload)),\n estimatedLength,\n network,\n client,\n }))[1].fee;\n }\n catch (error) {\n if (!(error instanceof NoEstimateAvailableError))\n throw error;\n return await fetchFeeEstimateTransfer({ transaction: txOpt, network });\n }\n}\nexport async function fetchAbi({ contractAddress: address, contractName: name, network = 'mainnet', client: _client, }) {\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${CONTRACT_ABI_PATH}/${address}/${name}`;\n const response = await client.fetch(url);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching contract ABI for contract \"${name}\" at address ${address}. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return JSON.parse(await response.text());\n}\nexport async function fetchCallReadOnlyFunction({ contractName, contractAddress, functionName, functionArgs, senderAddress, network = 'mainnet', client: _client, }) {\n const json = {\n sender: senderAddress,\n arguments: functionArgs.map(arg => cvToHex(arg)),\n };\n const options = {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(json),\n };\n const name = encodeURIComponent(functionName);\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${READONLY_FUNCTION_CALL_PATH}/${contractAddress}/${contractName}/${name}`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error calling read-only function. Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n return await response.json().then(parseReadOnlyResponse);\n}\nexport async function fetchContractMapEntry({ contractAddress, contractName, mapName, mapKey, network = 'mainnet', client: _client, }) {\n const keyHex = with0x(serializeCV(mapKey));\n const options = {\n method: 'POST',\n headers: {\n Accept: 'application/json',\n 'Content-Type': 'application/json',\n },\n body: JSON.stringify(keyHex),\n };\n const client = Object.assign({}, clientFromNetwork(networkFrom(network)), _client);\n const url = `${client.baseUrl}${MAP_ENTRY_PATH}/${contractAddress}/${contractName}/${mapName}?proof=0`;\n const response = await client.fetch(url, options);\n if (!response.ok) {\n const msg = await response.text().catch(() => '');\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${url} and failed with the message: \"${msg}\"`);\n }\n const json = await response.json();\n if (!json.data) {\n throw new Error(`Error fetching map entry for map \"${mapName}\" in contract \"${contractName}\" at address ${contractAddress}, using map key \"${keyHex}\". Response ${response.status}: ${response.statusText}. Attempted to fetch ${client.baseUrl} and failed with the response: \"${JSON.stringify(json)}\"`);\n }\n try {\n return deserializeCV(json.data);\n }\n catch (error) {\n throw new Error(`Error deserializing Clarity value \"${json.data}\": ${error}`);\n }\n}\n//# sourceMappingURL=fetch.js.map","import { PostConditionMode, PostConditionPrincipalId, PostConditionType, } from './constants';\nimport { StacksWireType, addressToString, parseAssetString, parsePrincipalString, serializePostConditionWire, } from './wire';\nvar PostConditionCodeWireType;\n(function (PostConditionCodeWireType) {\n PostConditionCodeWireType[PostConditionCodeWireType[\"eq\"] = 1] = \"eq\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gt\"] = 2] = \"gt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lt\"] = 4] = \"lt\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"gte\"] = 3] = \"gte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"lte\"] = 5] = \"lte\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"sent\"] = 16] = \"sent\";\n PostConditionCodeWireType[PostConditionCodeWireType[\"not-sent\"] = 17] = \"not-sent\";\n})(PostConditionCodeWireType \|\| (PostConditionCodeWireType = {}));\nexport function postConditionToWire(postcondition) {\n switch (postcondition.type) {\n case 'stx-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.STX,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n };\n case 'ft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.Fungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n amount: BigInt(postcondition.amount),\n asset: parseAssetString(postcondition.asset),\n };\n case 'nft-postcondition':\n return {\n type: StacksWireType.PostCondition,\n conditionType: PostConditionType.NonFungible,\n principal: postcondition.address === 'origin'\n ? { type: StacksWireType.Principal, prefix: PostConditionPrincipalId.Origin }\n : parsePrincipalString(postcondition.address),\n conditionCode: conditionTypeToByte(postcondition.condition),\n asset: parseAssetString(postcondition.asset),\n assetName: postcondition.assetId,\n };\n default:\n throw new Error('Invalid post condition type');\n }\n}\nexport function wireToPostCondition(wire) {\n switch (wire.conditionType) {\n case PostConditionType.STX:\n return {\n type: 'stx-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n };\n case PostConditionType.Fungible:\n return {\n type: 'ft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n amount: wire.amount.toString(),\n asset: assetWireToString(wire.asset),\n };\n case PostConditionType.NonFungible:\n return {\n type: 'nft-postcondition',\n address: principalWireToString(wire.principal),\n condition: conditionByteToType(wire.conditionCode),\n asset: assetWireToString(wire.asset),\n assetId: wire.assetName,\n };\n default: {\n const _exhaustiveCheck = wire;\n throw new Error(`Invalid post condition type: ${_exhaustiveCheck}`);\n }\n }\n}\nexport function conditionTypeToByte(condition) {\n return PostConditionCodeWireType[condition];\n}\nexport function conditionByteToType(wireType) {\n return PostConditionCodeWireType[wireType];\n}\nexport function postConditionToHex(postcondition) {\n const wire = postConditionToWire(postcondition);\n return serializePostConditionWire(wire);\n}\nexport function postConditionModeFrom(mode) {\n if (typeof mode === 'number')\n return mode;\n if (mode === 'allow')\n return PostConditionMode.Allow;\n if (mode === 'deny')\n return PostConditionMode.Deny;\n throw new Error(`Invalid post condition mode: ${mode}`);\n}\nfunction assetWireToString(asset) {\n const address = addressToString(asset.address);\n const contractId = `${address}.${asset.contractName.content}`;\n return `${contractId}::${asset.assetName.content}`;\n}\nfunction principalWireToString(principal) {\n switch (principal.prefix) {\n case PostConditionPrincipalId.Origin:\n return 'origin';\n case PostConditionPrincipalId.Standard:\n return addressToString(principal.address);\n case PostConditionPrincipalId.Contract:\n const address = addressToString(principal.address);\n return `${address}.${principal.contractName.content}`;\n default:\n const _exhaustiveCheck = principal;\n throw new Error(`Invalid principal type: ${_exhaustiveCheck}`);\n }\n}\n//# sourceMappingURL=postcondition.js.map","import { STACKS_MAINNET, clientFromNetwork, networkFrom, } from '@stacks/network';\nimport { c32address } from 'c32check';\nimport { createMultiSigSpendingCondition, createSingleSigSpendingCondition, createSponsoredAuth, createStandardAuth, isSingleSig, } from './authorization';\nimport { AddressHashMode, ClarityVersion, PayloadType, PostConditionMode, } from './constants';\nimport { validateContractCall } from './contract-abi';\nimport { fetchAbi, fetchFeeEstimate, fetchNonce } from './fetch';\nimport { createStacksPublicKey, privateKeyToHex, privateKeyToPublic, publicKeyToAddress, publicKeyToHex, } from './keys';\nimport { postConditionModeFrom, postConditionToWire } from './postcondition';\nimport { TransactionSigner } from './signer';\nimport { StacksTransactionWire, deriveNetworkFromTx } from './transaction';\nimport { omit } from './utils';\nimport { addressFromPublicKeys, createAddress, createContractCallPayload, createLPList, createSmartContractPayload, createTokenTransferPayload, deserializePostConditionWire, } from './wire';\nexport async function makeUnsignedSTXTokenTransfer(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n memo: '',\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n const payload = createTokenTransferPayload(options.recipient, options.amount, options.memo);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n });\n if (txOptions.fee == null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeSTXTokenTransfer(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedSTXTokenTransfer({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedSTXTokenTransfer(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeContractDeploy(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractDeploy({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractDeploy(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function makeUnsignedContractDeploy(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n clarityVersion: ClarityVersion.Clarity3,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), txOptions.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createSmartContractPayload(options.contractName, options.codeBody, options.clarityVersion);\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeUnsignedContractCall(txOptions) {\n const defaultOptions = {\n fee: BigInt(0),\n nonce: BigInt(0),\n network: STACKS_MAINNET,\n postConditionMode: PostConditionMode.Deny,\n sponsored: false,\n };\n const options = Object.assign(defaultOptions, txOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n options.postConditionMode = postConditionModeFrom(options.postConditionMode);\n const payload = createContractCallPayload(options.contractAddress, options.contractName, options.functionName, options.functionArgs);\n if (options?.validateWithAbi) {\n let abi;\n if (typeof options.validateWithAbi === 'boolean') {\n if (options?.network) {\n abi = await fetchAbi({ ...options });\n }\n else {\n throw new Error('Network option must be provided in order to validate with ABI');\n }\n }\n else {\n abi = options.validateWithAbi;\n }\n validateContractCall(payload, abi);\n }\n let spendingCondition = null;\n if ('publicKey' in options) {\n spendingCondition = createSingleSigSpendingCondition(AddressHashMode.P2PKH, options.publicKey, options.nonce, options.fee);\n }\n else {\n const hashMode = options.useNonSequentialMultiSig\n ? AddressHashMode.P2SHNonSequential\n : AddressHashMode.P2SH;\n const publicKeys = options.address\n ? sortPublicKeysForAddress(options.publicKeys.map(publicKeyToHex), options.numSignatures, hashMode, createAddress(options.address).hash160)\n : options.publicKeys.map(publicKeyToHex);\n spendingCondition = createMultiSigSpendingCondition(hashMode, options.numSignatures, publicKeys, options.nonce, options.fee);\n }\n const authorization = options.sponsored\n ? createSponsoredAuth(spendingCondition)\n : createStandardAuth(spendingCondition);\n const postConditions = (options.postConditions ?? []).map(pc => {\n if (typeof pc === 'string')\n return deserializePostConditionWire(pc);\n if (typeof pc.type === 'string')\n return postConditionToWire(pc);\n return pc;\n });\n const lpPostConditions = createLPList(postConditions);\n const transaction = new StacksTransactionWire({\n transactionVersion: options.network.transactionVersion,\n chainId: options.network.chainId,\n auth: authorization,\n payload,\n postConditions: lpPostConditions,\n postConditionMode: options.postConditionMode,\n });\n if (txOptions.fee === undefined \|\| txOptions.fee === null) {\n const fee = await fetchFeeEstimate({ transaction, ...options });\n transaction.setFee(fee);\n }\n if (txOptions.nonce === undefined \|\| txOptions.nonce === null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = c32address(addressVersion, transaction.auth.spendingCondition.signer);\n const txNonce = await fetchNonce({ address, ...options });\n transaction.setNonce(txNonce);\n }\n return transaction;\n}\nexport async function makeContractCall(txOptions) {\n if ('senderKey' in txOptions) {\n const publicKey = privateKeyToPublic(txOptions.senderKey);\n const options = omit(txOptions, 'senderKey');\n const transaction = await makeUnsignedContractCall({ publicKey, ...options });\n const privKey = txOptions.senderKey;\n const signer = new TransactionSigner(transaction);\n signer.signOrigin(privKey);\n return transaction;\n }\n else {\n const options = omit(txOptions, 'signerKeys');\n const transaction = await makeUnsignedContractCall(options);\n mutatingSignAppendMultiSig(transaction, txOptions.publicKeys.map(publicKeyToHex).slice(), txOptions.signerKeys.map(privateKeyToHex), txOptions.address);\n return transaction;\n }\n}\nexport async function sponsorTransaction(sponsorOptions) {\n const defaultOptions = {\n fee: 0,\n sponsorNonce: 0,\n sponsorAddressHashmode: AddressHashMode.P2PKH,\n network: deriveNetworkFromTx(sponsorOptions.transaction),\n };\n const options = Object.assign(defaultOptions, sponsorOptions);\n options.network = networkFrom(options.network);\n options.client = Object.assign({}, clientFromNetwork(options.network), options.client);\n const sponsorPubKey = privateKeyToPublic(options.sponsorPrivateKey);\n if (sponsorOptions.fee == null) {\n let txFee = 0;\n switch (options.transaction.payload.payloadType) {\n case PayloadType.TokenTransfer:\n case PayloadType.SmartContract:\n case PayloadType.VersionedSmartContract:\n case PayloadType.ContractCall:\n txFee = BigInt(await fetchFeeEstimate({ ...options }));\n break;\n default:\n throw new Error(`Sponsored transactions not supported for transaction type ${PayloadType[options.transaction.payload.payloadType]}`);\n }\n options.transaction.setFee(txFee);\n options.fee = txFee;\n }\n if (sponsorOptions.sponsorNonce == null) {\n const addressVersion = options.network.addressVersion.singleSig;\n const address = publicKeyToAddress(addressVersion, sponsorPubKey);\n const sponsorNonce = await fetchNonce({ address, ...options });\n options.sponsorNonce = sponsorNonce;\n }\n const sponsorSpendingCondition = createSingleSigSpendingCondition(options.sponsorAddressHashmode, sponsorPubKey, options.sponsorNonce, options.fee);\n options.transaction.setSponsor(sponsorSpendingCondition);\n const privKey = options.sponsorPrivateKey;\n const signer = TransactionSigner.createSponsorSigner(options.transaction, sponsorSpendingCondition);\n signer.signSponsor(privKey);\n return signer.transaction;\n}\nfunction mutatingSignAppendMultiSig(transaction, publicKeys, signerKeys, address) {\n if (isSingleSig(transaction.auth.spendingCondition)) {\n throw new Error('Transaction is not a multi-sig transaction');\n }\n const signer = new TransactionSigner(transaction);\n const pubs = address\n ? sortPublicKeysForAddress(publicKeys, transaction.auth.spendingCondition.signaturesRequired, transaction.auth.spendingCondition.hashMode, createAddress(address).hash160)\n : publicKeys;\n for (const publicKey of pubs) {\n const signerKey = signerKeys.find(key => privateKeyToPublic(key) === publicKey);\n if (signerKey) {\n signer.signOrigin(signerKey);\n }\n else {\n signer.appendOrigin(publicKey);\n }\n }\n}\nfunction sortPublicKeysForAddress(publicKeys, numSigs, hashMode, hash) {\n const hashUnsorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeys.map(createStacksPublicKey)).hash160;\n if (hashUnsorted === hash)\n return publicKeys;\n const publicKeysSorted = publicKeys.slice().sort();\n const hashSorted = addressFromPublicKeys(0, hashMode, numSigs, publicKeysSorted.map(createStacksPublicKey)).hash160;\n if (hashSorted === hash)\n return publicKeysSorted;\n throw new Error('Failed to find matching multi-sig address given public-keys.');\n}\n//# sourceMappingURL=builders.js.map","import { utf8ToBytes } from '@stacks/common';\nimport { hash160 } from '@stacks/transactions';\n\n/** @ignore /\nexport function decodeFQN(fqdn: string): {\n name: string;\n namespace: string;\n subdomain?: string;\n} {\n const nameParts = fqdn.split('.');\n if (nameParts.length > 2) {\n return {\n subdomain: nameParts[0],\n name: nameParts[1],\n namespace: nameParts[2],\n };\n }\n return {\n name: nameParts[0],\n namespace: nameParts[1],\n };\n}\n\n/* @ignore /\nexport const getZonefileHash = (zonefile: string) => hash160(utf8ToBytes(zonefile));\n","import { IntegerType, PublicKey, intToBigInt, utf8ToBytes } from '@stacks/common';\nimport { NetworkClientParam, StacksNetwork } from '@stacks/network';\nimport {\n ClarityType,\n ClarityValue,\n NonFungiblePostCondition,\n PostCondition,\n ResponseErrorCV,\n StacksTransactionWire,\n StxPostCondition,\n UnsignedContractCallOptions,\n bufferCV,\n bufferCVFromString,\n cvToString,\n fetchCallReadOnlyFunction,\n getAddressFromPrivateKey,\n getCVTypeString,\n hash160,\n makeRandomPrivKey,\n makeUnsignedContractCall,\n noneCV,\n publicKeyToAddress,\n someCV,\n standardPrincipalCV,\n tupleCV,\n uintCV,\n} from '@stacks/transactions';\nimport { decodeFQN, getZonefileHash } from './utils';\n\nexport const BNS_CONTRACT_NAME = 'bns';\n\nexport interface PriceFunction {\n base: IntegerType;\n coefficient: IntegerType;\n b1: IntegerType;\n b2: IntegerType;\n b3: IntegerType;\n b4: IntegerType;\n b5: IntegerType;\n b6: IntegerType;\n b7: IntegerType;\n b8: IntegerType;\n b9: IntegerType;\n b10: IntegerType;\n b11: IntegerType;\n b12: IntegerType;\n b13: IntegerType;\n b14: IntegerType;\n b15: IntegerType;\n b16: IntegerType;\n nonAlphaDiscount: IntegerType;\n noVowelDiscount: IntegerType;\n}\n\nexport interface BnsContractCallOptions {\n functionName: string;\n functionArgs: ClarityValue[];\n publicKey: PublicKey;\n network: StacksNetwork;\n postConditions?: PostCondition[];\n}\n\nasync function makeBnsContractCall(\n options: BnsContractCallOptions\n): Promise<StacksTransactionWire> {\n const txOptions: UnsignedContractCallOptions = {\n contractAddress: options.network.bootAddress,\n contractName: BNS_CONTRACT_NAME,\n functionName: options.functionName,\n functionArgs: options.functionArgs,\n publicKey: options.publicKey,\n validateWithAbi: false,\n network: options.network,\n postConditions: options.postConditions,\n };\n\n return makeUnsignedContractCall(txOptions);\n}\n\nexport interface BnsReadOnlyOptions {\n functionName: string;\n functionArgs: ClarityValue[];\n senderAddress: string;\n network: StacksNetwork;\n}\n\nasync function callReadOnlyBnsFunction(\n options: BnsReadOnlyOptions & NetworkClientParam\n): Promise<ClarityValue> {\n return fetchCallReadOnlyFunction({\n ...options,\n contractAddress: options.network.bootAddress,\n contractName: BNS_CONTRACT_NAME,\n });\n}\n\n/\n Can register name options\n \n @param {String} fullyQualifiedName - the fully qualified name (\"name.namespace\") to check\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface CanRegisterNameOptions {\n fullyQualifiedName: string;\n network: StacksNetwork;\n}\n\n/\n Check if name can be registered\n \n @param {string} fullyQualifiedName - the fully qualified name to check\n * @param {StacksNetwork} network - the Stacks network to broadcast transaction to\n \n @returns {Promise} that resolves to true if the operation succeeds\n /\nexport async function canRegisterName({\n fullyQualifiedName,\n network,\n}: CanRegisterNameOptions): Promise<boolean> {\n const bnsFunctionName = 'can-name-be-registered';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot register a subdomain using registerName');\n }\n\n // Create a random address as input to read-only function call\n // Not used by BNS contract function but required by core node API\n // https://github.com/blockstack/stacks-blockchain/blob/master/src/net/http.rs#L1796\n const randomPrivateKey = makeRandomPrivKey();\n const randomAddress = getAddressFromPrivateKey(randomPrivateKey);\n\n return callReadOnlyBnsFunction({\n functionName: bnsFunctionName,\n senderAddress: randomAddress,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name)],\n network,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n return responseCV.value.type === ClarityType.BoolTrue;\n } else {\n return false;\n }\n });\n}\n\n/\n Get namespace price options\n \n @param {String} namespace - the namespace to get the price of\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface GetNamespacePriceOptions {\n namespace: string;\n network: StacksNetwork;\n}\n\n/\n Get price of namespace registration in microstacks\n \n @param {string} namespace - the namespace\n * @param {StacksNetwork} network - the Stacks network to use\n \n @returns {Promise} that resolves to a BN object number of microstacks if the operation succeeds\n /\nexport async function getNamespacePrice({\n namespace,\n network,\n}: GetNamespacePriceOptions): Promise<bigint> {\n const bnsFunctionName = 'get-namespace-price';\n\n // Create a random address as input to read-only function call\n // Not used by BNS contract function but required by core node API\n // https://github.com/blockstack/stacks-blockchain/blob/master/src/net/http.rs#L1796\n const randomPrivateKey = makeRandomPrivKey();\n const randomAddress = getAddressFromPrivateKey(randomPrivateKey);\n\n return callReadOnlyBnsFunction({\n functionName: bnsFunctionName,\n senderAddress: randomAddress,\n functionArgs: [bufferCVFromString(namespace)],\n network,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n if (responseCV.value.type === ClarityType.Int \|\| responseCV.value.type === ClarityType.UInt) {\n return BigInt(responseCV.value.value);\n } else {\n throw new Error('Response did not contain a number');\n }\n } else if (responseCV.type === ClarityType.ResponseErr) {\n throw new Error(cvToString(responseCV.value));\n } else {\n throw new Error(`Unexpected Clarity Value type: ${getCVTypeString(responseCV)}`);\n }\n });\n}\n\n/\n Get name price options\n \n @param {String} fullyQualifiedName - the fully qualified name (\"name.namespace\") to get the price of\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface GetNamePriceOptions {\n fullyQualifiedName: string;\n network: StacksNetwork;\n}\n\n/\n Get price of name registration in microstacks\n \n @param {string} fullyQualifiedName - the fully qualified name\n * @param {StacksNetwork} network - the Stacks network to use\n \n @returns {Promise} that resolves to a BN object number of microstacks if the operation succeeds\n /\nexport async function getNamePrice({\n fullyQualifiedName,\n network,\n}: GetNamePriceOptions): Promise<bigint> {\n const bnsFunctionName = 'get-name-price';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot get subdomain name price');\n }\n\n // Create a random address as input to read-only function call\n // Not used by BNS contract function but required by core node API\n // https://github.com/blockstack/stacks-blockchain/blob/master/src/net/http.rs#L1796\n const randomPrivateKey = makeRandomPrivKey();\n const randomAddress = getAddressFromPrivateKey(randomPrivateKey);\n\n return callReadOnlyBnsFunction({\n functionName: bnsFunctionName,\n senderAddress: randomAddress,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name)],\n network,\n }).then((responseCV: ClarityValue) => {\n if (responseCV.type === ClarityType.ResponseOk) {\n if (responseCV.value.type === ClarityType.Int \|\| responseCV.value.type === ClarityType.UInt) {\n return BigInt(responseCV.value.value);\n } else {\n throw new Error('Response did not contain a number');\n }\n } else {\n const errorResponse = responseCV as ResponseErrorCV;\n throw new Error(cvToString(errorResponse.value));\n }\n });\n}\n\n/\n Preorder namespace options\n /\nexport interface PreorderNamespaceOptions {\n /* the namespace to preorder /\n namespace: string;\n /* salt used to generate the preorder namespace hash /\n salt: string;\n /* amount of STX to burn for the registration /\n stxToBurn: IntegerType;\n /* the private key to sign the transaction /\n publicKey: string;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n}\n\n/\n Generates a namespace preorder transaction.\n * First step in registering a namespace. This transaction does not reveal the namespace that is\n * about to be registered. And it sets the amount of STX to be burned for the registration.\n \n Resolves to the generated StacksTransaction\n \n @param {PreorderNamespaceOptions} options - an options object for the preorder\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildPreorderNamespaceTx({\n namespace,\n salt,\n stxToBurn,\n publicKey,\n network,\n}: PreorderNamespaceOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'namespace-preorder';\n const saltedNamespaceBytes = utf8ToBytes(`${namespace}${salt}`);\n const hashedSaltedNamespace = hash160(saltedNamespaceBytes);\n\n const burnSTXPostCondition: StxPostCondition = {\n type: 'stx-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'eq',\n amount: intToBigInt(stxToBurn),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCV(hashedSaltedNamespace), uintCV(stxToBurn)],\n publicKey,\n network,\n postConditions: [burnSTXPostCondition],\n });\n}\n\n/\n Reveal namespace options\n /\nexport interface RevealNamespaceOptions {\n /* the namespace to reveal /\n namespace: string;\n /* salt used to generate the preorder namespace hash /\n salt: string;\n /* an object containing the price function for the namespace /\n priceFunction: PriceFunction;\n /* the number of blocks name registrations are valid for in the namespace /\n lifetime: IntegerType;\n /* the STX address used for name imports /\n namespaceImportAddress: string;\n /* the key to sign the transaction /\n publicKey: string;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n}\n\n/\n Generates a namespace reveal transaction.\n * Second step in registering a namespace.\n \n Resolves to the generated StacksTransaction\n \n @param {RevealNamespaceOptions} options - an options object for the reveal\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildRevealNamespaceTx({\n namespace,\n salt,\n priceFunction,\n lifetime,\n namespaceImportAddress,\n publicKey,\n network,\n}: RevealNamespaceOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'namespace-reveal';\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [\n bufferCVFromString(namespace),\n bufferCVFromString(salt),\n uintCV(priceFunction.base),\n uintCV(priceFunction.coefficient),\n uintCV(priceFunction.b1),\n uintCV(priceFunction.b2),\n uintCV(priceFunction.b3),\n uintCV(priceFunction.b4),\n uintCV(priceFunction.b5),\n uintCV(priceFunction.b6),\n uintCV(priceFunction.b7),\n uintCV(priceFunction.b8),\n uintCV(priceFunction.b9),\n uintCV(priceFunction.b10),\n uintCV(priceFunction.b11),\n uintCV(priceFunction.b12),\n uintCV(priceFunction.b13),\n uintCV(priceFunction.b14),\n uintCV(priceFunction.b15),\n uintCV(priceFunction.b16),\n uintCV(priceFunction.nonAlphaDiscount),\n uintCV(priceFunction.noVowelDiscount),\n uintCV(lifetime),\n standardPrincipalCV(namespaceImportAddress),\n ],\n publicKey,\n network,\n });\n}\n\n/\n Namespace name import options\n \n @param {String} namespace - the namespace to import name into\n * @param {String} name - the name to import\n * @param {String} beneficiary - the address to register the name to\n * @param {String} zonefileHash - the zonefile hash to register\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface ImportNameOptions {\n namespace: string;\n name: string;\n beneficiary: string;\n zonefile: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a namespace name import transaction.\n * An optional step in namespace registration.\n \n Resolves to the generated StacksTransaction\n \n @param {ImportNameOptions} options - an options object for the name import\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildImportNameTx({\n namespace,\n name,\n beneficiary,\n zonefile,\n publicKey,\n network,\n}: ImportNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-import';\n const zonefileHash = getZonefileHash(zonefile);\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n standardPrincipalCV(beneficiary),\n bufferCV(zonefileHash),\n ],\n publicKey,\n network,\n });\n}\n\n/\n Ready namespace options\n \n @param {String} namespace - the namespace to ready\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface ReadyNamespaceOptions {\n namespace: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a ready namespace transaction.\n * Final step in namespace registration. This completes the namespace registration and\n * makes the namespace available for name registrations.\n \n Resolves to the generated StacksTransaction\n \n @param {ReadyNamespaceOptions} options - an options object for the namespace ready transaction\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildReadyNamespaceTx({\n namespace,\n publicKey,\n network,\n}: ReadyNamespaceOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'namespace-ready';\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCVFromString(namespace)],\n publicKey,\n network,\n });\n}\n\n/\n Preorder name options\n /\nexport interface PreorderNameOptions {\n /* the fully qualified name to preorder including the namespace (myName.id) /\n fullyQualifiedName: string;\n /* salt used to generate the preorder name hash /\n salt: string;\n /* amount of STX to burn for the registration /\n stxToBurn: IntegerType;\n /* the private key to sign the transaction /\n publicKey: PublicKey;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n}\n\n/\n Generates a name preorder transaction.\n * First step in registering a name. This transaction does not reveal the name that is\n * about to be registered. And it sets the amount of STX to be burned for the registration.\n \n Resolves to the generated StacksTransaction\n \n @param {PreorderNameOptions} options - an options object for the preorder\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildPreorderNameTx({\n fullyQualifiedName,\n salt,\n stxToBurn,\n publicKey,\n network,\n}: PreorderNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-preorder';\n const { subdomain } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot preorder a subdomain using preorderName()');\n }\n const saltedNamesBytes = utf8ToBytes(`${fullyQualifiedName}${salt}`);\n const hashedSaltedName = hash160(saltedNamesBytes);\n\n const burnSTXPostCondition: StxPostCondition = {\n type: 'stx-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'eq',\n amount: intToBigInt(stxToBurn),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCV(hashedSaltedName), uintCV(stxToBurn)],\n publicKey,\n network,\n postConditions: [burnSTXPostCondition],\n });\n}\n\n/\n Register name options\n \n @param {String} fullyQualifiedName - the fully qualified name to preorder including the\n * namespace (myName.id)\n * @param {String} salt - salt used to generate the preorder name hash\n * @param {String} zonefile - the zonefile to register with the name\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface RegisterNameOptions {\n fullyQualifiedName: string;\n salt: string;\n zonefile: string;\n publicKey: PublicKey;\n network: StacksNetwork;\n}\n\n/\n Generates a name registration transaction.\n * Second and final step in registering a name.\n \n Resolves to the generated StacksTransaction\n \n @param {RegisterNameOptions} options - an options object for the registration\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildRegisterNameTx({\n fullyQualifiedName,\n salt,\n zonefile,\n publicKey,\n network,\n}: RegisterNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-register';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot register a subdomain using registerName()');\n }\n\n const zonefileHash = getZonefileHash(zonefile);\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n bufferCVFromString(salt),\n bufferCV(zonefileHash),\n ],\n network,\n publicKey,\n });\n}\n\n/\n Update name options\n \n @param {String} fullyQualifiedName - the fully qualified name to update including the\n * namespace (myName.id)\n * @param {String} zonefile - the zonefile to register with the name\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface UpdateNameOptions {\n fullyQualifiedName: string;\n zonefile: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a name update transaction.\n * This changes the zonefile for the registered name.\n \n Resolves to the generated StacksTransaction\n \n @param {UpdateNameOptions} options - an options object for the update\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildUpdateNameTx({\n fullyQualifiedName,\n zonefile,\n publicKey,\n network,\n}: UpdateNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-update';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot update a subdomain using updateName()');\n }\n const zonefileHash = getZonefileHash(zonefile);\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name), bufferCV(zonefileHash)],\n publicKey,\n network,\n });\n}\n\n/\n Transfer name options\n \n @param {String} fullyQualifiedName - the fully qualified name to transfer including the\n * namespace (myName.id)\n * @param {String} newOwnerAddress - the recipient address of the name transfer\n * @param {String} zonefile - the optional zonefile to register with the name\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface TransferNameOptions {\n fullyQualifiedName: string;\n newOwnerAddress: string;\n publicKey: string;\n network: StacksNetwork;\n zonefile?: string;\n}\n\n/\n Generates a name transfer transaction.\n * This changes the owner of the registered name.\n \n Since the underlying NFT will be transferred,\n * you will be required to add a post-condition to this\n * transaction before broadcasting it.\n \n Resolves to the generated StacksTransaction\n \n @param {TransferNameOptions} options - an options object for the transfer\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildTransferNameTx({\n fullyQualifiedName,\n newOwnerAddress,\n zonefile,\n publicKey,\n network,\n}: TransferNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-transfer';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot transfer a subdomain using transferName()');\n }\n\n const functionArgs = [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n standardPrincipalCV(newOwnerAddress),\n zonefile ? someCV(bufferCV(getZonefileHash(zonefile))) : noneCV(),\n ];\n const postConditionSender: NonFungiblePostCondition = {\n type: 'nft-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'sent',\n asset: `${network.bootAddress}.bns::names`,\n assetId: tupleCV({\n name: bufferCVFromString(name),\n namespace: bufferCVFromString(namespace),\n }),\n };\n const postConditionReceiver: NonFungiblePostCondition = {\n type: 'nft-postcondition',\n address: newOwnerAddress,\n condition: 'not-sent',\n asset: `${network.bootAddress}.bns::names`,\n assetId: tupleCV({\n name: bufferCVFromString(name),\n namespace: bufferCVFromString(namespace),\n }),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs,\n publicKey,\n network,\n postConditions: [postConditionSender, postConditionReceiver],\n });\n}\n\n/\n Revoke name options\n \n @param {String} fullyQualifiedName - the fully qualified name to revoke including the\n * namespace (myName.id)\n * @param {String} publicKey - the private key to sign the transaction\n * @param {StacksNetwork} network - the Stacks blockchain network to use\n /\nexport interface RevokeNameOptions {\n fullyQualifiedName: string;\n publicKey: string;\n network: StacksNetwork;\n}\n\n/\n Generates a name revoke transaction.\n * This revokes a name registration.\n \n Resolves to the generated StacksTransaction\n \n @param {RevokeNameOptions} options - an options object for the revoke\n \n @return {Promise<StacksTransactionWire>}\n /\nexport async function buildRevokeNameTx({\n fullyQualifiedName,\n publicKey,\n network,\n}: RevokeNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-revoke';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot revoke a subdomain using revokeName()');\n }\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs: [bufferCVFromString(namespace), bufferCVFromString(name)],\n publicKey,\n network,\n });\n}\n\n/\n Renew name options\n /\nexport interface RenewNameOptions {\n /* the fully qualified name to renew including the namespace (myName.id) /\n fullyQualifiedName: string;\n /* amount of STX to burn for the registration /\n stxToBurn: IntegerType;\n /* the private key to sign the transaction /\n publicKey: string;\n /* the Stacks blockchain network to use /\n network: StacksNetwork;\n /* optionally choose a new owner address /\n newOwnerAddress?: string;\n /* optionally update the zonefile hash /\n zonefile?: string;\n}\n\n/\n Generates a name renew transaction.\n * This renews a name registration.\n \n Resolves to the generated StacksTransaction\n \n @param {RenewNameOptions} options - an options object for the renew\n \n @return {Promise<StacksTransactionWire>}\n */\nexport async function buildRenewNameTx({\n fullyQualifiedName,\n stxToBurn,\n newOwnerAddress,\n zonefile,\n publicKey,\n network,\n}: RenewNameOptions): Promise<StacksTransactionWire> {\n const bnsFunctionName = 'name-renewal';\n const { subdomain, namespace, name } = decodeFQN(fullyQualifiedName);\n if (subdomain) {\n throw new Error('Cannot renew a subdomain using renewName()');\n }\n\n const functionArgs = [\n bufferCVFromString(namespace),\n bufferCVFromString(name),\n uintCV(stxToBurn),\n newOwnerAddress ? someCV(standardPrincipalCV(newOwnerAddress)) : noneCV(),\n zonefile ? someCV(bufferCV(getZonefileHash(zonefile))) : noneCV(),\n ];\n const burnSTXPostCondition: StxPostCondition = {\n type: 'stx-postcondition',\n address: publicKeyToAddress(network.addressVersion.singleSig, publicKey),\n condition: 'eq',\n amount: intToBigInt(stxToBurn),\n };\n\n return makeBnsContractCall({\n functionName: bnsFunctionName,\n functionArgs,\n publicKey,\n network,\n postConditions: [burnSTXPostCondition],\n });\n}\n"],"names":["root","factory","exports","module","define","amd","this","leafPrototypes","getProto","number","n","Number","isSafeInteger","Error","bool","b","bytes","lengths","Uint8Array","TypeError","length","includes","hash","create","outputLen","blockLen","exists","instance","checkFinished","destroyed","finished","output","out","min","Object","defineProperty","value","assert","SHA2","_assert_js_1","utils_js_1","Hash","constructor","padOffset","isLE","super","pos","buffer","view","createView","update","data","default","len","toBytes","take","Math","set","subarray","process","dataView","roundClean","digestInto","fill","i","byteOffset","setBigUint64","_32n","BigInt","_u32_max","wh","wl","h","l","setUint32","oview","outLen","state","get","digest","res","slice","destroy","_cloneInto","to","crypto","node","undefined","web","self","sha224","sha256","_sha2_js_1","Maj","a","c","SHA256_K","Uint32Array","IV","SHA256_W","SHA256","A","B","C","D","E","F","G","H","offset","getUint32","W15","W2","s0","rotr","s1","T1","T2","SHA224","wrapConstructor","randomBytes","wrapConstructorWithOpts","checkOpts","concatBytes","utf8ToBytes","asyncLoop","nextTick","hexToBytes","bytesToHex","u32","u8","crypto_1","arr","byteLength","floor","DataView","word","shift","hexes","Array","from","v","toString","padStart","str","TextEncoder","encode","uint8a","hex","array","j","hexByte","byte","parseInt","isNaN","async","iters","tick","cb","ts","Date","now","diff","arrays","every","reduce","result","pad","clone","defaults","opts","obj","prototype","call","assign","hashConstructor","hashC","message","tmp","hashCons","msg","bytesLength","getRandomValues","ALPHABET","BASE_MAP","x","charAt","xc","charCodeAt","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","source","psz","zeroes","size","b256","carry","it3","it4","vch","ArrayBuffer","isView","isArray","pbegin","pend","b58","it1","it2","repeat","decode","string","c32ToB58","b58ToC32","c32addressDecode","c32address","versions","checksum_1","base58check","utils_1","mainnet","p2pkh","p2sh","testnet","ADDR_BITCOIN_TO_STACKS","ADDR_STACKS_TO_BITCOIN","version","hash160hex","match","c32checkEncode","c32addr","c32checkDecode","b58check","addrInfo","hash160String","addrVersion","prefix","stacksVersion","c32string","bitcoinVersion","sha256_1","basex","dataBytes","prefixBytes","checksum","forEach","check","index","encoding_1","c32checksum","dataHex","dataHash","toLowerCase","versionHex","checksumHex","c32str","c32encode","c32","c32data","c32normalize","c32decode","versionChar","indexOf","substring","c32input","toUpperCase","replace","inputHex","minLength","currentCode","nextCode","nextBits","nextLowBits","curC32Digit","unshift","C32leadingZeros","zeroPrefix","TextDecoder","numLeadingZeroBytesInHex","count","join","numLeadingZeroBytes","carryBits","currentValue","currentHexDigit","hexLeadingZeros","hexStr","address_1","enumerable","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","boolTag","dateTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","g","freeSelf","Function","freeExports","nodeType","freeModule","moduleExports","addMapEntry","map","pair","addSetEntry","add","arrayReduce","iteratee","accumulator","initAccum","isHostObject","e","mapToArray","key","overArg","func","transform","arg","setToArray","uid","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","exec","keys","IE_PROTO","funcToString","hasOwnProperty","objectToString","reIsNative","RegExp","Buffer","Symbol","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","splice","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","entries","clear","entry","ListCache","MapCache","Stack","__data__","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","input","initCloneArray","copyArray","tag","getTag","isFunc","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","symbol","Ctor","cloneArrayBuffer","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","initCloneByTag","stacked","props","keysFunc","symbolsFunc","values","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","arrayBuffer","newValue","getMapData","type","getValue","isFunction","test","baseIsNative","has","pop","push","cache","pairs","LARGE_ARRAY_SIZE","isIndex","other","resolve","ctorString","isArrayLike","isLength","inherited","isObjectLike","isArrayLikeObject","isArguments","baseTimes","String","skipIndexes","arrayLikeKeys","baseKeys","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","d","t","mode","then","ns","r","def","current","getOwnPropertyNames","definition","o","globalThis","window","prop","toStringTag","nmd","paths","children","intToBytes","bigIntToBytes","isInteger","RangeError","hexToBigInt","intToHex","integer","bytesToTwosBigInt","width","nthBit","_","u","asciiToBytes","byteArray","bytesToAscii","fromCharCode","apply","isNotOctet","octet","octetsToBytes","numbers","some","elements","clazz","name","PRIVATE_KEY_BYTES_COMPRESSED","defaultFetchOpts","referrerPolicy","headers","fetchWrapper","init","fetchOpts","fetch","args","fetchLib","middlewares","argsForCreateFetchFn","url","fetchParams","middleware","pre","response","post","ChainId","PeerNetworkId","AddressVersion","TransactionVersion","Mainnet","chainId","transactionVersion","peerNetworkId","magicBytes","bootAddress","addressVersion","singleSig","MainnetSingleSig","multiSig","MainnetMultiSig","client","baseUrl","STACKS_TESTNET","Testnet","TestnetSingleSig","TestnetMultiSig","STACKS_DEVNET","STACKS_MOCKNET","network","networkFromName","writeUInt32BE","destination","MAX_STRING_LENGTH_BYTES","CLARITY_INT_SIZE","CLARITY_INT_BYTE_SIZE","AnchorMode","ClarityVersion","PayloadType","FungibleConditionCode","NonFungibleConditionCode","AssetType","TxRejectedReason","AuthFieldType","TenureChangeCause","PostConditionPrincipalId","PubKeyEncoding","AddressHashMode","AuthType","PostConditionType","PostConditionMode","OnChainOnly","OffChainOnly","Any","TransactionError","captureStackTrace","SerializationError","NoEstimateAvailableError","SigningError","HMAC","_key","iHash","oHash","buf","hmac","_0n","_1n","_2n","_3n","_8n","CURVE","freeze","P","Gx","Gy","beta","divNearest","endo","splitScalar","k","a1","b1","a2","b2","POW_2_128","c1","c2","k1","mod","k2","k1neg","k2neg","fieldLen","groupLen","compressedLen","uncompressedLen","weierstrass","x2","x3","USE_ENDOMORPHISM","ShaError","assertJacPoint","JacobianPoint","y","z","fromAffine","p","equals","ZERO","toAffineBatch","points","toInv","nums","scratch","inverted","invert","acc","num","reduceRight","invertBatch","toAffine","normalizeZ","X1","Y1","Z1","X2","Y2","Z2","Z1Z1","Z2Z2","U1","U2","S1","S2","negate","double","x1b","X3","Y3","Z3","HH","HHH","V","subtract","multiplyUnsafe","scalar","P0","normalizeScalar","k1p","k2p","precomputeWindow","W","windows","base","wNAF","affinePoint","_WINDOW_SIZE","precomputes","pointPrecomputes","f","windowSize","mask","maxNumber","shiftBy","wbits","offset1","offset2","abs","cond1","cond2","constTimeNegate","multiply","point","fake","f1p","f2p","invZ","is0","iz1","iz2","iz3","ax","ay","zz","condition","item","neg","_setWindowSize","delete","hasEvenY","fromCompressedHex","isShort","bytesToNumber","isValidFieldElement","_6n","_11n","_22n","_23n","_44n","_88n","b3","b6","pow2","b9","b11","b22","b44","b88","b176","b220","b223","t1","t2","rt","sqrtMod","isYOdd","assertValidity","fromUncompressedHex","fromHex","ensureBytes","header","fromPrivateKey","privateKey","normalizePrivateKey","fromSignature","msgHash","signature","recovery","s","Signature","fromDER","error","fromCompact","normalizeSignature","truncateHash","radj","rinv","u1","u2","R","numTo32bStr","Q","multiplyAndAddUnsafe","toRawBytes","isCompressed","toHex","toHexX","toRawX","left","aP","bQ","sum","sliceDER","parseDERInt","hexToNumber","sBytes","rBytesLeft","parseDERSignature","isWithinCurveOrder","hasHighS","HALF","normalizeS","toDERRawBytes","toDERHex","sHex","numberToHexUnpadded","rHex","sHexL","rHexL","sLen","rLen","toCompactRawBytes","toCompactHex","POW_2_256","numTo32b","power","modulo","q","m","truncateOnly","delta","bits2int_2","_sha256Sync","_hmacSha256Sync","HmacDrbg","hashLen","qByteLen","counter","hmacSha256","hmacSync","checkSync","incr","reseed","seed","reseedSync","generate","sl","generateSync","kmdToSig","kBytes","lowS","kinv","sig","bits2int","bits2octets","z1","z2","int2octets","TAGGED_HASH_PREFIXES","isValidPrivateKey","_bigintTo32Bytes","_normalizePrivateKey","hashToPrivateKey","minLen","randomPrivateKey","precompute","cached","messages","subtle","createHash","ckey","importKey","sign","createHmac","sha256Sync","hmacSha256Sync","taggedHash","tagP","tagH","taggedHashSync","_JacobianPoint","defineProperties","configurable","val","COORDINATE_BYTES","privateKeyToBytes","privateKeyBuffer","Rho","Id","Pi","idxL","idxR","shifts","shiftsL","idx","shiftsR","Kl","Kr","rotl","group","BUF","RIPEMD160","h0","h1","h2","h3","h4","al","ar","bl","br","cl","cr","dl","dr","el","er","rGroup","hbl","hbr","rl","rr","sr","tl","tr","ripemd160","U32_MASK64","fromBig","le","lst","Ah","Al","Bh","Bl","Cl","low","Ch","Dl","Dh","Eh","El","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","SHA512_224","SHA512_256","SHA384","sha512_256","enumCheckFunctions","isEnum","enumVariable","checker","newChecker","enumValues","filter","enumValueSet","createEnumChecker","consumed","readBytes","readUInt32BE","readUInt8","readUInt16BE","readBigUIntLE","reverse","readBigUIntBE","readOffset","internalBytes","readUInt8Enum","invalidEnumErrorFormatter","ClarityWireType","ClarityType","clarityTypeToByte","MAX_U128","MIN_U128","MAX_I128","MIN_I128","startsWith","bigInt","Int","UInt","BoolTrue","BoolFalse","StacksWireType","lengthPrefixBytes","LengthPrefixedList","MessageSignature","content","maxLengthBytes","prefixLength","maxLength","LengthPrefixedString","c32AddressString","addressData","Address","hash160","pubKeyEncoding","contents","TransactionAuthField","addressFromPublicKeys","hashMode","numSigs","publicKeys","P2PKH","P2WPKH","P2WSH","P2WSHNonSequential","addressFromVersionHash","hashP2PKH","hashP2WPKH","P2SH","P2SHNonSequential","hashP2SH","serializePublicKeyBytes","hashP2WSH","address","parseAssetString","assetAddress","assetContractName","assetTokenName","split","addressString","contractName","assetName","Asset","parsePrincipalString","principalString","addr","Principal","Contract","createContractPrincipal","Standard","createStandardPrincipal","PrincipalStandard","OptionalNone","OptionalSome","tupleCV","Tuple","StringASCII","StringUTF8","serializedClarityValue","bytesReader","hasHexPrefix","int","uint","bufferLength","true","false","deserializeAddress","contract","PrincipalContract","contractPrincipalCVFromAddress","deserializeLPString","ok","ResponseOk","err","ResponseErr","responseErrorCV","none","list","listLength","listContents","List","tuple","tupleLength","tupleContents","clarityName","ascii","asciiStrLen","asciiStr","utf8","utf8StrLen","utf8Str","serializeStacksWireBytes","wire","serializeAddressBytes","serializePrincipalBytes","serializeLPStringBytes","MemoString","memoString","bytesArray","contentBytes","paddedContent","rightPadHexToLength","serializeMemoStringBytes","serializeAssetBytes","PostCondition","postCondition","conditionType","principal","Fungible","NonFungible","asset","serializeCVBytes","conditionCode","STX","amount","serializePostConditionWireBytes","PublicKey","serializeLPListBytes","Payload","serializePayloadBytes","field","Compressed","PublicKeyCompressed","PublicKeyUncompressed","publicKey","SignatureCompressed","SignatureUncompressed","serializeMessageSignatureBytes","serializeTransactionAuthFieldBytes","serialized","lps","info","deserializeAsset","lpList","postConditionType","Origin","deserializePrincipal","payload","payloadType","TokenTransfer","recipient","memo","ContractCall","contractAddress","functionName","numArgs","functionArgs","SmartContract","codeBody","VersionedSmartContract","clarityVersion","PoisonMicroblock","Coinbase","coinbaseBytes","CoinbaseToAltRecipient","NakamotoCoinbase","vrfProof","TenureChange","tenureHash","previousTenureHash","burnViewHash","previousTenureEnd","previousTenureBlocks","writeUInt8","cause","publicKeyHash","messageSignature","bytesWithTypeID","typeId","serializeStringCV","cv","encoding","serializeBoolCV","ceil","serializeBufferCV","serializeUIntCV","toTwos","serializeIntCV","serializeStandardPrincipalCV","contractId","parseContractId","serializeContractPrincipalCV","serializeResponseCV","serializedValue","serializeListCV","lexicographicOrder","sort","localeCompare","nameWithLength","serializeTupleCV","serializeStringAsciiCV","serializeStringUtf8CV","leftPadHex","hexString","padEnd","cloneDeep","txidFromData","keyHash","redeemScript","pubKeys","pubKey","scriptArray","script","parseReadOnlyResponse","okay","getAddressFromPrivateKey","addrVer","addressHashModeToVersion","getAddressFromPublicKey","msgs","privateKeyIsCompressed","makeRandomPrivKey","signWithKey","messageHash","rawSignature","recoveryId","privKey","extraEntropy","seedArgs","initSigArgs","drbg","canonical","recSig","der","recovered","hashed","finalizeSig","signSync","_publicKeyToAddress","publicKeyToAddressSingleSig","emptyMessageSignature","nonce","fee","signer","keyEncoding","Uncompressed","isSequentialMultiSig","clearCondition","cloned","fields","serializeSpendingConditionBytes","serializeSingleSigSpendingConditionBytes","writeUInt16BE","signaturesRequired","serializeMultiSigSpendingConditionBytes","sigHashPreSign","curSigHash","authType","sigHash","sigHashPostSign","hashLength","sigHashBytes","nextVerification","initialSigHash","sigHashPre","parsedSignature","recoveryIdHex","parseRecoverableSignatureVrs","compressed","publicKeyFromSignatureVrs","nextSigHash","spendingCondition","sponsorSpendingCondition","Sponsored","intoInitialSighashAuth","auth","newInitialSigHash","cvToString","JSON","stringify","getCVTypeString","ClarityAbiTypeId","isClarityAbiPrimitive","isClarityAbiBuffer","isClarityAbiStringAscii","isClarityAbiStringUtf8","isClarityAbiResponse","isClarityAbiOptional","optional","isClarityAbiTuple","isClarityAbiList","getTypeString","matchType","abiType","union","ClarityAbiTypeUInt128","ClarityAbiTypeInt128","ClarityAbiTypeBool","ClarityAbiTypePrincipal","ClarityAbiTypeTraitReference","ClarityAbiTypeNone","ClarityAbiTypeBuffer","ClarityAbiTypeResponse","ClarityAbiTypeOptional","ClarityAbiTypeTuple","ClarityAbiTypeList","ClarityAbiTypeStringAscii","ClarityAbiTypeStringUtf8","getTypeUnion","abiTupleEntry","postConditions","postConditionMode","Deny","anchorMode","signBegin","tx","txid","verifyBegin","verifyOrigin","addrBytes","verifySingleSig","haveUncompressed","verifyMultiSig","signNextOrigin","signAndAppend","signNextSponsor","appendPubkey","cond","nextSig","nextSignature","serializeBytes","setSponsor","setFee","setNonce","setSponsorNonce","serialize","chainIdBytes","serializeAuthorizationBytes","transaction","TRANSFER_FEE_ESTIMATE_PATH","TRANSACTION_FEE_ESTIMATE_PATH","ACCOUNT_PATH","CONTRACT_ABI_PATH","READONLY_FUNCTION_CALL_PATH","PostConditionCodeWireType","conditionTypeToByte","makeUnsignedContractCall","txOptions","defaultOptions","sponsored","options","Allow","validateWithAbi","abi","_client","text","catch","status","statusText","parse","fetchAbi","filtered","functions","fn","abiArgs","payloadArg","abiArg","argNum","validateContractCall","useNonSequentialMultiSig","publicKeysSorted","sortPublicKeysForAddress","numSignatures","authorization","lpPostConditions","pc","postcondition","assetId","txOpt","_network","estimatedLength","multiSigSpendingCondition","existingSignatures","totalSignatureLength","estimateTransactionByteLength","json","transaction_payload","estimated_len","method","body","reason_data","estimations","fetchFeeEstimateTransaction","Accept","feeRateResult","txBytes","fetchFeeEstimateTransfer","txNonce","possible_next_nonce","_getNonceApi","decodeFQN","fqdn","nameParts","subdomain","namespace","getZonefileHash","zonefile","BNS_CONTRACT_NAME","makeBnsContractCall","callReadOnlyBnsFunction","senderAddress","sender","arguments","encodeURIComponent","fetchCallReadOnlyFunction","canRegisterName","fullyQualifiedName","responseCV","getNamespacePrice","getNamePrice","buildPreorderNamespaceTx","salt","stxToBurn","saltedNamespaceBytes","hashedSaltedNamespace","burnSTXPostCondition","buildRevealNamespaceTx","priceFunction","lifetime","namespaceImportAddress","coefficient","b4","b5","b7","b8","b10","b12","b13","b14","b15","b16","nonAlphaDiscount","noVowelDiscount","buildImportNameTx","beneficiary","zonefileHash","buildReadyNamespaceTx","buildPreorderNameTx","saltedNamesBytes","hashedSaltedName","buildRegisterNameTx","buildUpdateNameTx","buildTransferNameTx","newOwnerAddress","buildRevokeNameTx","buildRenewNameTx"],"sourceRoot":""}