@bonfida/spl-name-service 3.0.13 → 3.0.15

package/dist/cjs/node_modules/@scure/base/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@scure/base/lib/esm/index.js"],"sourcesContent":["/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nfunction isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is Uint8Array. */\nfunction abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\nfunction isArrayOf(isString, arr) {\n    if (!Array.isArray(arr))\n        return false;\n    if (arr.length === 0)\n        return true;\n    if (isString) {\n        return arr.every((item) => typeof item === 'string');\n    }\n    else {\n        return arr.every((item) => Number.isSafeInteger(item));\n    }\n}\n// no abytes: seems to have 10% slowdown. Why?!\nfunction afn(input) {\n    if (typeof input !== 'function')\n        throw new Error('function expected');\n    return true;\n}\nfunction astr(label, input) {\n    if (typeof input !== 'string')\n        throw new Error(`${label}: string expected`);\n    return true;\n}\nfunction anumber(n) {\n    if (!Number.isSafeInteger(n))\n        throw new Error(`invalid integer: ${n}`);\n}\nfunction aArr(input) {\n    if (!Array.isArray(input))\n        throw new Error('array expected');\n}\nfunction astrArr(label, input) {\n    if (!isArrayOf(true, input))\n        throw new Error(`${label}: array of strings expected`);\n}\nfunction anumArr(label, input) {\n    if (!isArrayOf(false, input))\n        throw new Error(`${label}: array of numbers expected`);\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction chain(...args) {\n    const id = (a) => a;\n    // Wrap call in closure so JIT can inline calls\n    const wrap = (a, b) => (c) => a(b(c));\n    // Construct chain of args[-1].encode(args[-2].encode([...]))\n    const encode = args.map((x) => x.encode).reduceRight(wrap, id);\n    // Construct chain of args[0].decode(args[1].decode(...))\n    const decode = args.map((x) => x.decode).reduce(wrap, id);\n    return { encode, decode };\n}\n/**\n * Encodes integer radix representation to array of strings using alphabet and back.\n * Could also be array of strings.\n * @__NO_SIDE_EFFECTS__\n */\nfunction alphabet(letters) {\n    // mapping 1 to \"b\"\n    const lettersA = typeof letters === 'string' ? letters.split('') : letters;\n    const len = lettersA.length;\n    astrArr('alphabet', lettersA);\n    // mapping \"b\" to 1\n    const indexes = new Map(lettersA.map((l, i) => [l, i]));\n    return {\n        encode: (digits) => {\n            aArr(digits);\n            return digits.map((i) => {\n                if (!Number.isSafeInteger(i) || i < 0 || i >= len)\n                    throw new Error(`alphabet.encode: digit index outside alphabet \"${i}\". Allowed: ${letters}`);\n                return lettersA[i];\n            });\n        },\n        decode: (input) => {\n            aArr(input);\n            return input.map((letter) => {\n                astr('alphabet.decode', letter);\n                const i = indexes.get(letter);\n                if (i === undefined)\n                    throw new Error(`Unknown letter: \"${letter}\". Allowed: ${letters}`);\n                return i;\n            });\n        },\n    };\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction join(separator = '') {\n    astr('join', separator);\n    return {\n        encode: (from) => {\n            astrArr('join.decode', from);\n            return from.join(separator);\n        },\n        decode: (to) => {\n            astr('join.decode', to);\n            return to.split(separator);\n        },\n    };\n}\n/**\n * Pad strings array so it has integer number of bits\n * @__NO_SIDE_EFFECTS__\n */\nfunction padding(bits, chr = '=') {\n    anumber(bits);\n    astr('padding', chr);\n    return {\n        encode(data) {\n            astrArr('padding.encode', data);\n            while ((data.length * bits) % 8)\n                data.push(chr);\n            return data;\n        },\n        decode(input) {\n            astrArr('padding.decode', input);\n            let end = input.length;\n            if ((end * bits) % 8)\n                throw new Error('padding: invalid, string should have whole number of bytes');\n            for (; end > 0 && input[end - 1] === chr; end--) {\n                const last = end - 1;\n                const byte = last * bits;\n                if (byte % 8 === 0)\n                    throw new Error('padding: invalid, string has too much padding');\n            }\n            return input.slice(0, end);\n        },\n    };\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction normalize(fn) {\n    afn(fn);\n    return { encode: (from) => from, decode: (to) => fn(to) };\n}\n/**\n * Slow: O(n^2) time complexity\n */\nfunction convertRadix(data, from, to) {\n    // base 1 is impossible\n    if (from < 2)\n        throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);\n    if (to < 2)\n        throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);\n    aArr(data);\n    if (!data.length)\n        return [];\n    let pos = 0;\n    const res = [];\n    const digits = Array.from(data, (d) => {\n        anumber(d);\n        if (d < 0 || d >= from)\n            throw new Error(`invalid integer: ${d}`);\n        return d;\n    });\n    const dlen = digits.length;\n    while (true) {\n        let carry = 0;\n        let done = true;\n        for (let i = pos; i < dlen; i++) {\n            const digit = digits[i];\n            const fromCarry = from * carry;\n            const digitBase = fromCarry + digit;\n            if (!Number.isSafeInteger(digitBase) ||\n                fromCarry / from !== carry ||\n                digitBase - digit !== fromCarry) {\n                throw new Error('convertRadix: carry overflow');\n            }\n            const div = digitBase / to;\n            carry = digitBase % to;\n            const rounded = Math.floor(div);\n            digits[i] = rounded;\n            if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)\n                throw new Error('convertRadix: carry overflow');\n            if (!done)\n                continue;\n            else if (!rounded)\n                pos = i;\n            else\n                done = false;\n        }\n        res.push(carry);\n        if (done)\n            break;\n    }\n    for (let i = 0; i < data.length - 1 && data[i] === 0; i++)\n        res.push(0);\n    return res.reverse();\n}\nconst gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));\nconst radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));\nconst powers = /* @__PURE__ */ (() => {\n    let res = [];\n    for (let i = 0; i < 40; i++)\n        res.push(2 ** i);\n    return res;\n})();\n/**\n * Implemented with numbers, because BigInt is 5x slower\n */\nfunction convertRadix2(data, from, to, padding) {\n    aArr(data);\n    if (from <= 0 || from > 32)\n        throw new Error(`convertRadix2: wrong from=${from}`);\n    if (to <= 0 || to > 32)\n        throw new Error(`convertRadix2: wrong to=${to}`);\n    if (radix2carry(from, to) > 32) {\n        throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);\n    }\n    let carry = 0;\n    let pos = 0; // bitwise position in current element\n    const max = powers[from];\n    const mask = powers[to] - 1;\n    const res = [];\n    for (const n of data) {\n        anumber(n);\n        if (n >= max)\n            throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);\n        carry = (carry << from) | n;\n        if (pos + from > 32)\n            throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);\n        pos += from;\n        for (; pos >= to; pos -= to)\n            res.push(((carry >> (pos - to)) & mask) >>> 0);\n        const pow = powers[pos];\n        if (pow === undefined)\n            throw new Error('invalid carry');\n        carry &= pow - 1; // clean carry, otherwise it will cause overflow\n    }\n    carry = (carry << (to - pos)) & mask;\n    if (!padding && pos >= from)\n        throw new Error('Excess padding');\n    if (!padding && carry > 0)\n        throw new Error(`Non-zero padding: ${carry}`);\n    if (padding && pos > 0)\n        res.push(carry >>> 0);\n    return res;\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix(num) {\n    anumber(num);\n    const _256 = 2 ** 8;\n    return {\n        encode: (bytes) => {\n            if (!isBytes(bytes))\n                throw new Error('radix.encode input should be Uint8Array');\n            return convertRadix(Array.from(bytes), _256, num);\n        },\n        decode: (digits) => {\n            anumArr('radix.decode', digits);\n            return Uint8Array.from(convertRadix(digits, num, _256));\n        },\n    };\n}\n/**\n * If both bases are power of same number (like `2**8 <-> 2**64`),\n * there is a linear algorithm. For now we have implementation for power-of-two bases only.\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix2(bits, revPadding = false) {\n    anumber(bits);\n    if (bits <= 0 || bits > 32)\n        throw new Error('radix2: bits should be in (0..32]');\n    if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)\n        throw new Error('radix2: carry overflow');\n    return {\n        encode: (bytes) => {\n            if (!isBytes(bytes))\n                throw new Error('radix2.encode input should be Uint8Array');\n            return convertRadix2(Array.from(bytes), 8, bits, !revPadding);\n        },\n        decode: (digits) => {\n            anumArr('radix2.decode', digits);\n            return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));\n        },\n    };\n}\nfunction unsafeWrapper(fn) {\n    afn(fn);\n    return function (...args) {\n        try {\n            return fn.apply(null, args);\n        }\n        catch (e) { }\n    };\n}\nfunction checksum(len, fn) {\n    anumber(len);\n    afn(fn);\n    return {\n        encode(data) {\n            if (!isBytes(data))\n                throw new Error('checksum.encode: input should be Uint8Array');\n            const sum = fn(data).slice(0, len);\n            const res = new Uint8Array(data.length + len);\n            res.set(data);\n            res.set(sum, data.length);\n            return res;\n        },\n        decode(data) {\n            if (!isBytes(data))\n                throw new Error('checksum.decode: input should be Uint8Array');\n            const payload = data.slice(0, -len);\n            const oldChecksum = data.slice(-len);\n            const newChecksum = fn(payload).slice(0, len);\n            for (let i = 0; i < len; i++)\n                if (newChecksum[i] !== oldChecksum[i])\n                    throw new Error('Invalid checksum');\n            return payload;\n        },\n    };\n}\n// prettier-ignore\nexport const utils = {\n    alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,\n};\n// RFC 4648 aka RFC 3548\n// ---------------------\n/**\n * base16 encoding from RFC 4648.\n * @example\n * ```js\n * base16.encode(Uint8Array.from([0x12, 0xab]));\n * // => '12AB'\n * ```\n */\nexport const base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\n/**\n * base32 encoding from RFC 4648. Has padding.\n * Use `base32nopad` for unpadded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ===='\n * base32.decode('CKVQ====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\n/**\n * base32 encoding from RFC 4648. No padding.\n * Use `base32` for padded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ'\n * base32nopad.decode('CKVQ');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32nopad = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));\n/**\n * base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hexnopad` for unpadded version.\n * @example\n * ```js\n * base32hex.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG===='\n * base32hex.decode('2ALG====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\n/**\n * base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hex` for padded version.\n * @example\n * ```js\n * base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG'\n * base32hexnopad.decode('2ALG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hexnopad = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));\n/**\n * base32 encoding from RFC 4648. Doug Crockford's version.\n * https://www.crockford.com/base32.html\n * @example\n * ```js\n * base32crockford.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ANG'\n * base32crockford.decode('2ANG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\n// Built-in base64 conversion https://caniuse.com/mdn-javascript_builtins_uint8array_frombase64\n// TODO: temporarily set to false, trying to understand bugs\n// prettier-ignore\nconst hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === 'function' &&\n    typeof Uint8Array.fromBase64 === 'function')();\n/**\n * base64 from RFC 4648. Padded.\n * Use `base64nopad` for unpadded version.\n * Also check out `base64url`, `base64urlnopad`.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64 = hasBase64Builtin ? {\n    encode(b) { abytes(b); return b.toBase64(); },\n    decode(s) {\n        astr('base64', s);\n        return Uint8Array.fromBase64(s, { lastChunkHandling: 'strict' });\n    },\n} : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\n/**\n * base64 from RFC 4648. No padding.\n * Use `base64` for padded version.\n * @example\n * ```js\n * base64nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64nopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64nopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));\n/**\n * base64 from RFC 4648, using URL-safe alphabet. Padded.\n * Use `base64urlnopad` for unpadded version.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64url.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64url.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64url = hasBase64Builtin ? {\n    encode(b) { abytes(b); return b.toBase64({ alphabet: 'base64url' }); },\n    decode(s) { astr('base64', s); return Uint8Array.fromBase64(s, { alphabet: 'base64url' }); },\n} : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\n/**\n * base64 from RFC 4648, using URL-safe alphabet. No padding.\n * Use `base64url` for padded version.\n * @example\n * ```js\n * base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64urlnopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64urlnopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), join(''));\n// base58 code\n// -----------\nconst genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(abc), join(''));\n/**\n * base58: base64 without ambigous characters +, /, 0, O, I, l.\n * Quadratic (O(n^2)) - so, can't be used on large inputs.\n * @example\n * ```js\n * base58.decode('01abcdef');\n * // => '3UhJW'\n * ```\n */\nexport const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\n/**\n * base58: flickr version. Check out `base58`.\n */\nexport const base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\n/**\n * base58: XRP version. Check out `base58`.\n */\nexport const base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');\n// Data len (index) -> encoded block len\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\n/**\n * base58: XMR version. Check out `base58`.\n * Done in 8-byte blocks (which equals 11 chars in decoding). Last (non-full) block padded with '1' to size in XMR_BLOCK_LEN.\n * Block encoding significantly reduces quadratic complexity of base58.\n */\nexport const base58xmr = {\n    encode(data) {\n        let res = '';\n        for (let i = 0; i < data.length; i += 8) {\n            const block = data.subarray(i, i + 8);\n            res += base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1');\n        }\n        return res;\n    },\n    decode(str) {\n        let res = [];\n        for (let i = 0; i < str.length; i += 11) {\n            const slice = str.slice(i, i + 11);\n            const blockLen = XMR_BLOCK_LEN.indexOf(slice.length);\n            const block = base58.decode(slice);\n            for (let j = 0; j < block.length - blockLen; j++) {\n                if (block[j] !== 0)\n                    throw new Error('base58xmr: wrong padding');\n            }\n            res = res.concat(Array.from(block.slice(block.length - blockLen)));\n        }\n        return Uint8Array.from(res);\n    },\n};\n/**\n * Method, which creates base58check encoder.\n * Requires function, calculating sha256.\n */\nexport const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);\n/**\n * Use `createBase58check` instead.\n * @deprecated\n */\nexport const base58check = createBase58check;\nconst BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));\nconst POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];\nfunction bech32Polymod(pre) {\n    const b = pre >> 25;\n    let chk = (pre & 0x1ffffff) << 5;\n    for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {\n        if (((b >> i) & 1) === 1)\n            chk ^= POLYMOD_GENERATORS[i];\n    }\n    return chk;\n}\nfunction bechChecksum(prefix, words, encodingConst = 1) {\n    const len = prefix.length;\n    let chk = 1;\n    for (let i = 0; i < len; i++) {\n        const c = prefix.charCodeAt(i);\n        if (c < 33 || c > 126)\n            throw new Error(`Invalid prefix (${prefix})`);\n        chk = bech32Polymod(chk) ^ (c >> 5);\n    }\n    chk = bech32Polymod(chk);\n    for (let i = 0; i < len; i++)\n        chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);\n    for (let v of words)\n        chk = bech32Polymod(chk) ^ v;\n    for (let i = 0; i < 6; i++)\n        chk = bech32Polymod(chk);\n    chk ^= encodingConst;\n    return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction genBech32(encoding) {\n    const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;\n    const _words = radix2(5);\n    const fromWords = _words.decode;\n    const toWords = _words.encode;\n    const fromWordsUnsafe = unsafeWrapper(fromWords);\n    function encode(prefix, words, limit = 90) {\n        astr('bech32.encode prefix', prefix);\n        if (isBytes(words))\n            words = Array.from(words);\n        anumArr('bech32.encode', words);\n        const plen = prefix.length;\n        if (plen === 0)\n            throw new TypeError(`Invalid prefix length ${plen}`);\n        const actualLength = plen + 7 + words.length;\n        if (limit !== false && actualLength > limit)\n            throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);\n        const lowered = prefix.toLowerCase();\n        const sum = bechChecksum(lowered, words, ENCODING_CONST);\n        return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;\n    }\n    function decode(str, limit = 90) {\n        astr('bech32.decode input', str);\n        const slen = str.length;\n        if (slen < 8 || (limit !== false && slen > limit))\n            throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);\n        // don't allow mixed case\n        const lowered = str.toLowerCase();\n        if (str !== lowered && str !== str.toUpperCase())\n            throw new Error(`String must be lowercase or uppercase`);\n        const sepIndex = lowered.lastIndexOf('1');\n        if (sepIndex === 0 || sepIndex === -1)\n            throw new Error(`Letter \"1\" must be present between prefix and data only`);\n        const prefix = lowered.slice(0, sepIndex);\n        const data = lowered.slice(sepIndex + 1);\n        if (data.length < 6)\n            throw new Error('Data must be at least 6 characters long');\n        const words = BECH_ALPHABET.decode(data).slice(0, -6);\n        const sum = bechChecksum(prefix, words, ENCODING_CONST);\n        if (!data.endsWith(sum))\n            throw new Error(`Invalid checksum in ${str}: expected \"${sum}\"`);\n        return { prefix, words };\n    }\n    const decodeUnsafe = unsafeWrapper(decode);\n    function decodeToBytes(str) {\n        const { prefix, words } = decode(str, false);\n        return { prefix, words, bytes: fromWords(words) };\n    }\n    function encodeFromBytes(prefix, bytes) {\n        return encode(prefix, toWords(bytes));\n    }\n    return {\n        encode,\n        decode,\n        encodeFromBytes,\n        decodeToBytes,\n        decodeUnsafe,\n        fromWords,\n        fromWordsUnsafe,\n        toWords,\n    };\n}\n/**\n * bech32 from BIP 173. Operates on words.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32 = genBech32('bech32');\n/**\n * bech32m from BIP 350. Operates on words.\n * It was to mitigate `bech32` weaknesses.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32m = genBech32('bech32m');\n/**\n * UTF-8-to-byte decoder. Uses built-in TextDecoder / TextEncoder.\n * @example\n * ```js\n * const b = utf8.decode(\"hey\"); // => new Uint8Array([ 104, 101, 121 ])\n * const str = utf8.encode(b); // \"hey\"\n * ```\n */\nexport const utf8 = {\n    encode: (data) => new TextDecoder().decode(data),\n    decode: (str) => new TextEncoder().encode(str),\n};\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\n// prettier-ignore\nconst hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === 'function' &&\n    typeof Uint8Array.fromHex === 'function')();\n// prettier-ignore\nconst hexBuiltin = {\n    encode(data) { abytes(data); return data.toHex(); },\n    decode(s) { astr('hex', s); return Uint8Array.fromHex(s); },\n};\n/**\n * hex string decoder. Uses built-in function, when available.\n * @example\n * ```js\n * const b = hex.decode(\"0102ff\"); // => new Uint8Array([ 1, 2, 255 ])\n * const str = hex.encode(b); // \"0102ff\"\n * ```\n */\nexport const hex = hasHexBuiltin\n    ? hexBuiltin\n    : chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => {\n        if (typeof s !== 'string' || s.length % 2 !== 0)\n            throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);\n        return s.toLowerCase();\n    }));\n// prettier-ignore\nconst CODERS = {\n    utf8, hex, base16, base32, base64, base64url, base58, base58xmr\n};\nconst coderTypeError = 'Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr';\n/** @deprecated */\nexport const bytesToString = (type, bytes) => {\n    if (typeof type !== 'string' || !CODERS.hasOwnProperty(type))\n        throw new TypeError(coderTypeError);\n    if (!isBytes(bytes))\n        throw new TypeError('bytesToString() expects Uint8Array');\n    return CODERS[type].encode(bytes);\n};\n/** @deprecated */\nexport const str = bytesToString; // as in python, but for bytes only\n/** @deprecated */\nexport const stringToBytes = (type, str) => {\n    if (!CODERS.hasOwnProperty(type))\n        throw new TypeError(coderTypeError);\n    if (typeof str !== 'string')\n        throw new TypeError('stringToBytes() expects string');\n    return CODERS[type].decode(str);\n};\n/** @deprecated */\nexport const bytes = stringToBytes;\n//# sourceMappingURL=index.js.map"],"names":["isBytes","a","Uint8Array","ArrayBuffer","isView","constructor","name","isArrayOf","isString","arr","Array","isArray","length","every","item","Number","isSafeInteger","astr","label","input","Error","anumber","n","aArr","astrArr","anumArr","gcd","b","radix2carry","from","to","powers","res","i","push","convertRadix2","data","padding","carry","pos","max","mask","pow","undefined","unsafeWrapper","fn","afn","args","apply","e","BECH_ALPHABET","id","wrap","c","encode","map","x","reduceRight","decode","reduce","chain","letters","lettersA","split","len","indexes","Map","l","digits","letter","get","alphabet","separator","join","POLYMOD_GENERATORS","bech32Polymod","pre","chk","bechChecksum","prefix","words","encodingConst","charCodeAt","v","encoding","ENCODING_CONST","_words","bits","revPadding","bytes","radix2","fromWords","toWords","fromWordsUnsafe","limit","plen","TypeError","actualLength","lowered","toLowerCase"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/constants.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("@solana/web3.js");const n=new e.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");new e.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");const b=new e.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");new e.PublicKey("So11111111111111111111111111111111111111112"),new e.PublicKey("9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP"),exports.ASSOCIATED_TOKEN_PROGRAM_ID=b,exports.TOKEN_PROGRAM_ID=n;
+//# sourceMappingURL=constants.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../../node_modules/@solana/spl-token/lib/esm/constants.js"],"sourcesContent":["import { PublicKey } from '@solana/web3.js';\n/** Address of the SPL Token program */\nexport const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');\n/** Address of the SPL Token 2022 program */\nexport const TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');\n/** Address of the SPL Associated Token Account program */\nexport const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');\n/** Address of the special mint for wrapped native SOL in spl-token */\nexport const NATIVE_MINT = new PublicKey('So11111111111111111111111111111111111111112');\n/** Address of the special mint for wrapped native SOL in spl-token-2022 */\nexport const NATIVE_MINT_2022 = new PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');\n/** Check that the token program provided is not `Tokenkeg...`, useful when using extensions */\nexport function programSupportsExtensions(programId) {\n    if (programId.equals(TOKEN_PROGRAM_ID)) {\n        return false;\n    }\n    else {\n        return true;\n    }\n}\n//# sourceMappingURL=constants.js.map"],"names":["TOKEN_PROGRAM_ID","PublicKey","ASSOCIATED_TOKEN_PROGRAM_ID"],"mappings":"oDAGaA,EAAmB,IAAIC,EAAAA,UAAU,+CAGT,IAAIA,EAAAA,UAAU,qDAGtCC,EAA8B,IAAID,EAAAA,UAAU,gDAG9B,IAAIA,EAAAA,UAAU,+CAGT,IAAIA,EAAAA,UAAU","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/errors.js

@@ -0,0 +1,2 @@
+"use strict";class r extends Error{constructor(r){super(r)}}exports.TokenAccountNotFoundError=class extends r{constructor(){super(...arguments),this.name="TokenAccountNotFoundError"}},exports.TokenError=r,exports.TokenInvalidAccountOwnerError=class extends r{constructor(){super(...arguments),this.name="TokenInvalidAccountOwnerError"}},exports.TokenInvalidAccountSizeError=class extends r{constructor(){super(...arguments),this.name="TokenInvalidAccountSizeError"}},exports.TokenInvalidMintError=class extends r{constructor(){super(...arguments),this.name="TokenInvalidMintError"}},exports.TokenOwnerOffCurveError=class extends r{constructor(){super(...arguments),this.name="TokenOwnerOffCurveError"}};
+//# sourceMappingURL=errors.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../node_modules/@solana/spl-token/lib/esm/errors.js"],"sourcesContent":["/** Base class for errors */\nexport class TokenError extends Error {\n    constructor(message) {\n        super(message);\n    }\n}\n/** Thrown if an account is not found at the expected address */\nexport class TokenAccountNotFoundError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenAccountNotFoundError';\n    }\n}\n/** Thrown if a program state account is not a valid Account */\nexport class TokenInvalidAccountError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountError';\n    }\n}\n/** Thrown if a program state account does not contain valid data */\nexport class TokenInvalidAccountDataError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountDataError';\n    }\n}\n/** Thrown if a program state account is not owned by the expected token program */\nexport class TokenInvalidAccountOwnerError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountOwnerError';\n    }\n}\n/** Thrown if the byte length of an program state account doesn't match the expected size */\nexport class TokenInvalidAccountSizeError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidAccountSizeError';\n    }\n}\n/** Thrown if the mint of a token account doesn't match the expected mint */\nexport class TokenInvalidMintError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidMintError';\n    }\n}\n/** Thrown if the owner of a token account doesn't match the expected owner */\nexport class TokenInvalidOwnerError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidOwnerError';\n    }\n}\n/** Thrown if the owner of a token account is a PDA (Program Derived Address) */\nexport class TokenOwnerOffCurveError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenOwnerOffCurveError';\n    }\n}\n/** Thrown if an instruction's program is invalid */\nexport class TokenInvalidInstructionProgramError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionProgramError';\n    }\n}\n/** Thrown if an instruction's keys are invalid */\nexport class TokenInvalidInstructionKeysError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionKeysError';\n    }\n}\n/** Thrown if an instruction's data is invalid */\nexport class TokenInvalidInstructionDataError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionDataError';\n    }\n}\n/** Thrown if an instruction's type is invalid */\nexport class TokenInvalidInstructionTypeError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenInvalidInstructionTypeError';\n    }\n}\n/** Thrown if the program does not support the desired instruction */\nexport class TokenUnsupportedInstructionError extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenUnsupportedInstructionError';\n    }\n}\n/** Thrown if the transfer hook extra accounts contains an invalid account index */\nexport class TokenTransferHookAccountNotFound extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenTransferHookAccountNotFound';\n    }\n}\n/** Thrown if the transfer hook extra accounts contains an invalid seed */\nexport class TokenTransferHookInvalidSeed extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenTransferHookInvalidSeed';\n    }\n}\n/** Thrown if account data required by an extra account meta seed config could not be fetched */\nexport class TokenTransferHookAccountDataNotFound extends TokenError {\n    constructor() {\n        super(...arguments);\n        this.name = 'TokenTransferHookAccountDataNotFound';\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":["TokenError","Error","constructor","message","super","this","name"],"mappings":"aACM,MAAgBA,UAAmBC,MACrCC,WAAAA,CAAYC,GACRC,MAAMD,EACV,oCAIE,cAAyCH,EAA/CE,WAAAA,uBACIG,KAAAC,KAAO,2BACX,8DAaM,cAA6CN,EAAnDE,WAAAA,uBACIG,KAAAC,KAAO,+BACX,wCAGM,cAA4CN,EAAlDE,WAAAA,uBACIG,KAAAC,KAAO,8BACX,iCAGM,cAAqCN,EAA3CE,WAAAA,uBACIG,KAAAC,KAAO,uBACX,mCAQM,cAAuCN,EAA7CE,WAAAA,uBACIG,KAAAC,KAAO,yBACX","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/extensions/accountType.js

@@ -0,0 +1,2 @@
+"use strict";var t;exports.AccountType=void 0,(t=exports.AccountType||(exports.AccountType={}))[t.Uninitialized=0]="Uninitialized",t[t.Mint=1]="Mint",t[t.Account=2]="Account";exports.ACCOUNT_TYPE_SIZE=1;
+//# sourceMappingURL=accountType.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/extensions/accountType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountType.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/extensions/accountType.js"],"sourcesContent":["export var AccountType;\n(function (AccountType) {\n    AccountType[AccountType[\"Uninitialized\"] = 0] = \"Uninitialized\";\n    AccountType[AccountType[\"Mint\"] = 1] = \"Mint\";\n    AccountType[AccountType[\"Account\"] = 2] = \"Account\";\n})(AccountType || (AccountType = {}));\nexport const ACCOUNT_TYPE_SIZE = 1;\n//# sourceMappingURL=accountType.js.map"],"names":["AccountType"],"mappings":"aAAA,IAAYA,EAAAA,QAAAA,iBAAAA,GAAAA,EAAAA,QAAWA,cAAXA,oBAAW,CAAA,IACnBA,EAAa,cAAA,GAAA,gBACbA,EAAAA,EAAI,KAAA,GAAA,OACJA,EAAAA,EAAO,QAAA,GAAA,oCAEsB","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/instructions/associatedTokenAccount.js

@@ -0,0 +1,2 @@
+"use strict";require("../../../../../buffer/index.js");var e=require("@solana/web3.js"),r=require("../constants.js"),i=require("../../../../../../_virtual/index.js");exports.createAssociatedTokenAccountIdempotentInstruction=function(s,t,n,u,a=r.TOKEN_PROGRAM_ID,o=r.ASSOCIATED_TOKEN_PROGRAM_ID){return function(i,s,t,n,u,a=r.TOKEN_PROGRAM_ID,o=r.ASSOCIATED_TOKEN_PROGRAM_ID){const b=[{pubkey:i,isSigner:!0,isWritable:!0},{pubkey:s,isSigner:!1,isWritable:!0},{pubkey:t,isSigner:!1,isWritable:!1},{pubkey:n,isSigner:!1,isWritable:!1},{pubkey:e.SystemProgram.programId,isSigner:!1,isWritable:!1},{pubkey:a,isSigner:!1,isWritable:!1}];return new e.TransactionInstruction({keys:b,programId:o,data:u})}(s,t,n,u,i.__exports.Buffer.from([1]),a,o)};
+//# sourceMappingURL=associatedTokenAccount.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/instructions/associatedTokenAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"associatedTokenAccount.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/instructions/associatedTokenAccount.js"],"sourcesContent":["import { SystemProgram, TransactionInstruction } from '@solana/web3.js';\nimport { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';\n/**\n * Construct a CreateAssociatedTokenAccount instruction\n *\n * @param payer                    Payer of the initialization fees\n * @param associatedToken          New associated token account\n * @param owner                    Owner of the new account\n * @param mint                     Token mint account\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Instruction to add to a transaction\n */\nexport function createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.alloc(0), programId, associatedTokenProgramId);\n}\n/**\n * Construct a CreateAssociatedTokenAccountIdempotent instruction\n *\n * @param payer                    Payer of the initialization fees\n * @param associatedToken          New associated token account\n * @param owner                    Owner of the new account\n * @param mint                     Token mint account\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Instruction to add to a transaction\n */\nexport function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.from([1]), programId, associatedTokenProgramId);\n}\nfunction buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, instructionData, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    const keys = [\n        { pubkey: payer, isSigner: true, isWritable: true },\n        { pubkey: associatedToken, isSigner: false, isWritable: true },\n        { pubkey: owner, isSigner: false, isWritable: false },\n        { pubkey: mint, isSigner: false, isWritable: false },\n        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },\n        { pubkey: programId, isSigner: false, isWritable: false },\n    ];\n    return new TransactionInstruction({\n        keys,\n        programId: associatedTokenProgramId,\n        data: instructionData,\n    });\n}\n/**\n * Construct a RecoverNested instruction\n *\n * @param nestedAssociatedToken             Nested associated token account (must be owned by `ownerAssociatedToken`)\n * @param nestedMint                        Token mint for the nested associated token account\n * @param destinationAssociatedToken        Wallet's associated token account\n * @param ownerAssociatedToken              Owner associated token account address (must be owned by `owner`)\n * @param ownerMint                         Token mint for the owner associated token account\n * @param owner                             Wallet address for the owner associated token account\n * @param programId                         SPL Token program account\n * @param associatedTokenProgramId          SPL Associated Token program account\n *\n * @return Instruction to add to a transaction\n */\nexport function createRecoverNestedInstruction(nestedAssociatedToken, nestedMint, destinationAssociatedToken, ownerAssociatedToken, ownerMint, owner, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    const keys = [\n        { pubkey: nestedAssociatedToken, isSigner: false, isWritable: true },\n        { pubkey: nestedMint, isSigner: false, isWritable: false },\n        { pubkey: destinationAssociatedToken, isSigner: false, isWritable: true },\n        { pubkey: ownerAssociatedToken, isSigner: false, isWritable: true },\n        { pubkey: ownerMint, isSigner: false, isWritable: false },\n        { pubkey: owner, isSigner: true, isWritable: true },\n        { pubkey: programId, isSigner: false, isWritable: false },\n    ];\n    return new TransactionInstruction({\n        keys,\n        programId: associatedTokenProgramId,\n        data: Buffer.from([2]),\n    });\n}\n//# sourceMappingURL=associatedTokenAccount.js.map"],"names":["payer","associatedToken","owner","mint","programId","TOKEN_PROGRAM_ID","associatedTokenProgramId","ASSOCIATED_TOKEN_PROGRAM_ID","buildAssociatedTokenAccountInstruction","instructionData","keys","pubkey","isSigner","isWritable","Buffer","from"],"mappings":"gOA8DC,SAAAA,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAA,iBAAAC,EAAAC,+BAED,OAUQC,SAAsBR,EAAAC,EAAAC,EAAAC,EAAAM,EAAAL,EAAAC,EAAAA,iBAAAC,EAAAC,+BACxBG,MAAAA,EAAA,CACN,CAAAC,OAAAX,EAAAY,UAAA,EAAAC,YAAA,GACQ,CAAEF,OAAQV,EAAgBW,UAAO,EAAQC,YAAA,iPAbxCL,CACLR,EACAC,EACAC,EACAC,EACAW,mBAAAC,KAAA,CAAuB,IACvBX,EAACE","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/state/account.js

@@ -0,0 +1,2 @@
+"use strict";var t,e=require("@solana/buffer-layout"),i=require("@solana/buffer-layout-utils");exports.AccountState=void 0,(t=exports.AccountState||(exports.AccountState={}))[t.Uninitialized=0]="Uninitialized",t[t.Initialized=1]="Initialized",t[t.Frozen=2]="Frozen";const u=e.struct([i.publicKey("mint"),i.publicKey("owner"),i.u64("amount"),e.u32("delegateOption"),i.publicKey("delegate"),e.u8("state"),e.u32("isNativeOption"),i.u64("isNative"),i.u64("delegatedAmount"),e.u32("closeAuthorityOption"),i.publicKey("closeAuthority")]),o=u.span;exports.ACCOUNT_SIZE=o,exports.AccountLayout=u;
+//# sourceMappingURL=account.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/state/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/state/account.js"],"sourcesContent":["import { struct, u32, u8 } from '@solana/buffer-layout';\nimport { publicKey, u64 } from '@solana/buffer-layout-utils';\nimport { TOKEN_PROGRAM_ID } from '../constants.js';\nimport { TokenAccountNotFoundError, TokenInvalidAccountError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, } from '../errors.js';\nimport { ACCOUNT_TYPE_SIZE, AccountType } from '../extensions/accountType.js';\nimport { getAccountLen } from '../extensions/extensionType.js';\nimport { MULTISIG_SIZE } from './multisig.js';\n/** Token account state as stored by the program */\nexport var AccountState;\n(function (AccountState) {\n    AccountState[AccountState[\"Uninitialized\"] = 0] = \"Uninitialized\";\n    AccountState[AccountState[\"Initialized\"] = 1] = \"Initialized\";\n    AccountState[AccountState[\"Frozen\"] = 2] = \"Frozen\";\n})(AccountState || (AccountState = {}));\n/** Buffer layout for de/serializing a token account */\nexport const AccountLayout = struct([\n    publicKey('mint'),\n    publicKey('owner'),\n    u64('amount'),\n    u32('delegateOption'),\n    publicKey('delegate'),\n    u8('state'),\n    u32('isNativeOption'),\n    u64('isNative'),\n    u64('delegatedAmount'),\n    u32('closeAuthorityOption'),\n    publicKey('closeAuthority'),\n]);\n/** Byte length of a token account */\nexport const ACCOUNT_SIZE = AccountLayout.span;\n/**\n * Retrieve information about a token account\n *\n * @param connection Connection to use\n * @param address    Token account\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Token account information\n */\nexport async function getAccount(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {\n    const info = await connection.getAccountInfo(address, commitment);\n    return unpackAccount(address, info, programId);\n}\n/**\n * Retrieve information about multiple token accounts in a single RPC call\n *\n * @param connection Connection to use\n * @param addresses  Token accounts\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Token account information\n */\nexport async function getMultipleAccounts(connection, addresses, commitment, programId = TOKEN_PROGRAM_ID) {\n    const infos = await connection.getMultipleAccountsInfo(addresses, commitment);\n    return addresses.map((address, i) => unpackAccount(address, infos[i], programId));\n}\n/** Get the minimum lamport balance for a base token account to be rent exempt\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptAccount(connection, commitment) {\n    return await getMinimumBalanceForRentExemptAccountWithExtensions(connection, [], commitment);\n}\n/** Get the minimum lamport balance for a rent-exempt token account with extensions\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptAccountWithExtensions(connection, extensions, commitment) {\n    const accountLen = getAccountLen(extensions);\n    return await connection.getMinimumBalanceForRentExemption(accountLen, commitment);\n}\n/**\n * Unpack a token account\n *\n * @param address   Token account\n * @param info      Token account data\n * @param programId SPL Token program account\n *\n * @return Unpacked token account\n */\nexport function unpackAccount(address, info, programId = TOKEN_PROGRAM_ID) {\n    if (!info)\n        throw new TokenAccountNotFoundError();\n    if (!info.owner.equals(programId))\n        throw new TokenInvalidAccountOwnerError();\n    if (info.data.length < ACCOUNT_SIZE)\n        throw new TokenInvalidAccountSizeError();\n    const rawAccount = AccountLayout.decode(info.data.slice(0, ACCOUNT_SIZE));\n    let tlvData = Buffer.alloc(0);\n    if (info.data.length > ACCOUNT_SIZE) {\n        if (info.data.length === MULTISIG_SIZE)\n            throw new TokenInvalidAccountSizeError();\n        if (info.data[ACCOUNT_SIZE] != AccountType.Account)\n            throw new TokenInvalidAccountError();\n        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);\n    }\n    return {\n        address,\n        mint: rawAccount.mint,\n        owner: rawAccount.owner,\n        amount: rawAccount.amount,\n        delegate: rawAccount.delegateOption ? rawAccount.delegate : null,\n        delegatedAmount: rawAccount.delegatedAmount,\n        isInitialized: rawAccount.state !== AccountState.Uninitialized,\n        isFrozen: rawAccount.state === AccountState.Frozen,\n        isNative: !!rawAccount.isNativeOption,\n        rentExemptReserve: rawAccount.isNativeOption ? rawAccount.isNative : null,\n        closeAuthority: rawAccount.closeAuthorityOption ? rawAccount.closeAuthority : null,\n        tlvData,\n    };\n}\n//# sourceMappingURL=account.js.map"],"names":["AccountState","AccountLayout","struct","publicKey","u64","u32","u8"],"mappings":"iBA8CCA,8EADGA,QAAAA,kBAAAA,GACHA,EAoBDA,QAAaA,eAAAA,qBAAsB,CAAA,IAnB/BA,EAAU,cAAA,GAAA,gBAHZA,EAAAA,EAID,YAAA,GAAA,cAiBDA,EAAAA,EAAuD,OAAA,GAAA,SAGnD,MAASC,EAASC,EAAAA,OACrBC,CAAAA,EAAAA,kBACGA,EAAAA,UACAC,SAAAA,EAAAA,cACHC,EAAAA,IAAA,kBACGF,EAAIA,UAAgB,YACtBG,EAAAA,GAAA,SACED,EAAGA,IAAC,kBACJD,EAAAA,IAAI,YACJA,EAAAA,IAAU,mBACdC,EAAAA,IAAA,wBAEAF,EAAAA,UACA","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/state/mint.js

@@ -0,0 +1,2 @@
+"use strict";require("../../../../../buffer/index.js");var e=require("@solana/buffer-layout"),t=require("@solana/buffer-layout-utils"),r=require("@solana/web3.js"),i=require("../constants.js"),n=require("../errors.js"),o=require("../extensions/accountType.js"),u=require("./account.js"),s=require("./multisig.js"),a=require("../../../../../../_virtual/index.js");const c=e.struct([e.u32("mintAuthorityOption"),t.publicKey("mintAuthority"),t.u64("supply"),e.u8("decimals"),t.bool("isInitialized"),e.u32("freezeAuthorityOption"),t.publicKey("freezeAuthority")]),l=c.span;function f(e,t,r=i.TOKEN_PROGRAM_ID){if(!t)throw new n.TokenAccountNotFoundError;if(!t.owner.equals(r))throw new n.TokenInvalidAccountOwnerError;if(t.data.length<l)throw new n.TokenInvalidAccountSizeError;const f=c.decode(t.data.slice(0,l));let d=a.__exports.Buffer.alloc(0);if(t.data.length>l){if(t.data.length<=u.ACCOUNT_SIZE)throw new n.TokenInvalidAccountSizeError;if(t.data.length===s.MULTISIG_SIZE)throw new n.TokenInvalidAccountSizeError;if(t.data[u.ACCOUNT_SIZE]!=o.AccountType.Mint)throw new n.TokenInvalidMintError;d=t.data.slice(u.ACCOUNT_SIZE+o.ACCOUNT_TYPE_SIZE)}return{address:e,mintAuthority:f.mintAuthorityOption?f.mintAuthority:null,supply:f.supply,decimals:f.decimals,isInitialized:f.isInitialized,freezeAuthority:f.freezeAuthorityOption?f.freezeAuthority:null,tlvData:d}}exports.MINT_SIZE=l,exports.MintLayout=c,exports.getAssociatedTokenAddressSync=function(e,t,o=!1,u=i.TOKEN_PROGRAM_ID,s=i.ASSOCIATED_TOKEN_PROGRAM_ID){if(!o&&!r.PublicKey.isOnCurve(t.toBuffer()))throw new n.TokenOwnerOffCurveError;const[a]=r.PublicKey.findProgramAddressSync([t.toBuffer(),u.toBuffer(),e.toBuffer()],s);return a},exports.getMint=async function(e,t,r,n=i.TOKEN_PROGRAM_ID){return f(t,await e.getAccountInfo(t,r),n)},exports.unpackMint=f;
+//# sourceMappingURL=mint.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/state/mint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mint.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/state/mint.js"],"sourcesContent":["import { struct, u32, u8 } from '@solana/buffer-layout';\nimport { bool, publicKey, u64 } from '@solana/buffer-layout-utils';\nimport { PublicKey } from '@solana/web3.js';\nimport { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';\nimport { TokenAccountNotFoundError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, TokenInvalidMintError, TokenOwnerOffCurveError, } from '../errors.js';\nimport { ACCOUNT_TYPE_SIZE, AccountType } from '../extensions/accountType.js';\nimport { getMintLen } from '../extensions/extensionType.js';\nimport { ACCOUNT_SIZE } from './account.js';\nimport { MULTISIG_SIZE } from './multisig.js';\n/** Buffer layout for de/serializing a mint */\nexport const MintLayout = struct([\n    u32('mintAuthorityOption'),\n    publicKey('mintAuthority'),\n    u64('supply'),\n    u8('decimals'),\n    bool('isInitialized'),\n    u32('freezeAuthorityOption'),\n    publicKey('freezeAuthority'),\n]);\n/** Byte length of a mint */\nexport const MINT_SIZE = MintLayout.span;\n/**\n * Retrieve information about a mint\n *\n * @param connection Connection to use\n * @param address    Mint account\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Mint information\n */\nexport async function getMint(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {\n    const info = await connection.getAccountInfo(address, commitment);\n    return unpackMint(address, info, programId);\n}\n/**\n * Unpack a mint\n *\n * @param address   Mint account\n * @param info      Mint account data\n * @param programId SPL Token program account\n *\n * @return Unpacked mint\n */\nexport function unpackMint(address, info, programId = TOKEN_PROGRAM_ID) {\n    if (!info)\n        throw new TokenAccountNotFoundError();\n    if (!info.owner.equals(programId))\n        throw new TokenInvalidAccountOwnerError();\n    if (info.data.length < MINT_SIZE)\n        throw new TokenInvalidAccountSizeError();\n    const rawMint = MintLayout.decode(info.data.slice(0, MINT_SIZE));\n    let tlvData = Buffer.alloc(0);\n    if (info.data.length > MINT_SIZE) {\n        if (info.data.length <= ACCOUNT_SIZE)\n            throw new TokenInvalidAccountSizeError();\n        if (info.data.length === MULTISIG_SIZE)\n            throw new TokenInvalidAccountSizeError();\n        if (info.data[ACCOUNT_SIZE] != AccountType.Mint)\n            throw new TokenInvalidMintError();\n        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);\n    }\n    return {\n        address,\n        mintAuthority: rawMint.mintAuthorityOption ? rawMint.mintAuthority : null,\n        supply: rawMint.supply,\n        decimals: rawMint.decimals,\n        isInitialized: rawMint.isInitialized,\n        freezeAuthority: rawMint.freezeAuthorityOption ? rawMint.freezeAuthority : null,\n        tlvData,\n    };\n}\n/** Get the minimum lamport balance for a mint to be rent exempt\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptMint(connection, commitment) {\n    return await getMinimumBalanceForRentExemptMintWithExtensions(connection, [], commitment);\n}\n/** Get the minimum lamport balance for a rent-exempt mint with extensions\n *\n * @param connection Connection to use\n * @param extensions Extension types included in the mint\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptMintWithExtensions(connection, extensions, commitment) {\n    const mintLen = getMintLen(extensions);\n    return await connection.getMinimumBalanceForRentExemption(mintLen, commitment);\n}\n/**\n * Async version of getAssociatedTokenAddressSync\n * For backwards compatibility\n *\n * @param mint                     Token mint account\n * @param owner                    Owner of the new account\n * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Promise containing the address of the associated token account\n */\nexport async function getAssociatedTokenAddress(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer()))\n        throw new TokenOwnerOffCurveError();\n    const [address] = await PublicKey.findProgramAddress([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);\n    return address;\n}\n/**\n * Get the address of the associated token account for a given mint and owner\n *\n * @param mint                     Token mint account\n * @param owner                    Owner of the new account\n * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)\n * @param programId                SPL Token program account\n * @param associatedTokenProgramId SPL Associated Token program account\n *\n * @return Address of the associated token account\n */\nexport function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {\n    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer()))\n        throw new TokenOwnerOffCurveError();\n    const [address] = PublicKey.findProgramAddressSync([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);\n    return address;\n}\n//# sourceMappingURL=mint.js.map"],"names":["MintLayout","struct","u32","publicKey","u64","u8","bool","unpackMint","address","info","programId","TOKEN_PROGRAM_ID","TokenAccountNotFoundError","owner","equals","TokenInvalidAccountOwnerError","data","length","MINT_SIZE","TokenInvalidAccountSizeError","rawMint","decode","slice","tlvData","Buffer","alloc","ACCOUNT_SIZE","MULTISIG_SIZE","AccountType","Mint","TokenInvalidMintError","ACCOUNT_TYPE_SIZE","mintAuthority","mintAuthorityOption","supply","decimals","isInitialized","freezeAuthority","freezeAuthorityOption","async","connection","commitment","getAccountInfo"],"mappings":"2WAmDaA,MAAAA,EAACC,EAAAA,OACVC,CAAAA,MAAI,uBACJC,YAAc,iBACdC,EAAAA,IAAI,UACJC,EAAAA,GAAG,YACHC,EAAAA,KAAU,iBACXJ,EAAAA,IAAA,yBAEHC,YAAA,8BAiCqBI,SAAAA,EAAIC,EAAAC,EAAAC,EAA4BC,EAAAA,kBACrD,IAAAF,EAAA,MAAA,IAAAG,4BACE,IAAAH,EAAAI,MAAAC,OAAAJ,GAAA,MAAA,IAAAK,gCAEE,GAAAN,EAAMO,KAAOC,OAAGC,EACnB,MAAA,IAAAC,EAAAA,6BACG,MAAIC,EAAUpB,EAASqB,OAAWZ,EAACO,KAAAM,MAAA,EAAAJ,IAC/BK,IAAAA,EAASC,EAAAA,UAAAA,OAAKC,MAAU,GAAc,GAAAhB,EAAAO,KAAMC,OAAIC,EAAA,CAChD,GAAIT,EAAKO,KAAKC,QAAMS,EAAAA,aAAoB,MAAM,IAAIP,EAAAA,6BAClD,GAAIV,EAAKO,KAAKC,SAAAU,EAAAA,cAAmC,MAAE,IAAAR,EAAAA,6BACnD,GAAAV,EAAOO,KAAOU,EAAYA,eAAAE,EAAAA,YAAeC,KAChD,MAAA,IAAAC,wBAECP,EAAAd,EAAAO,KAAAM,MAAAI,EAAAA,aAAAK,EAAAA,mBAEM,MAAA,CACAvB,UACAwB,cAAUZ,EAAQa,oBAAQb,EAAAY,cAAA,KAC1BE,OAAAd,EAAUc,OAClBC,SAAAf,EAAAe,SACEC,cAAAhB,EAAAgB,cACIC,gBAAAjB,EAAAkB,sBAAAlB,EAAAiB,gBAAA,KACLd,oWAnCGgB,eAAyBC,EAAQhC,EAAWiC,EAAA/B,EAAAC,EAAAA,kBAGhD,OAAAJ,EAAAC,QAFCgC,EAAAE,eAAAlC,EAAAiC,GAED/B","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/state/multisig.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("@solana/buffer-layout"),i=require("@solana/buffer-layout-utils");const u=e.struct([e.u8("m"),e.u8("n"),i.bool("isInitialized"),i.publicKey("signer1"),i.publicKey("signer2"),i.publicKey("signer3"),i.publicKey("signer4"),i.publicKey("signer5"),i.publicKey("signer6"),i.publicKey("signer7"),i.publicKey("signer8"),i.publicKey("signer9"),i.publicKey("signer10"),i.publicKey("signer11")]),s=u.span;exports.MULTISIG_SIZE=s,exports.MultisigLayout=u;
+//# sourceMappingURL=multisig.js.map

package/dist/cjs/node_modules/@solana/spl-token/lib/esm/state/multisig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multisig.js","sources":["../../../../../../../../node_modules/@solana/spl-token/lib/esm/state/multisig.js"],"sourcesContent":["import { struct, u8 } from '@solana/buffer-layout';\nimport { bool, publicKey } from '@solana/buffer-layout-utils';\nimport { TOKEN_PROGRAM_ID } from '../constants.js';\nimport { TokenAccountNotFoundError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError } from '../errors.js';\n/** Buffer layout for de/serializing a multisig */\nexport const MultisigLayout = struct([\n    u8('m'),\n    u8('n'),\n    bool('isInitialized'),\n    publicKey('signer1'),\n    publicKey('signer2'),\n    publicKey('signer3'),\n    publicKey('signer4'),\n    publicKey('signer5'),\n    publicKey('signer6'),\n    publicKey('signer7'),\n    publicKey('signer8'),\n    publicKey('signer9'),\n    publicKey('signer10'),\n    publicKey('signer11'),\n]);\n/** Byte length of a multisig */\nexport const MULTISIG_SIZE = MultisigLayout.span;\n/**\n * Retrieve information about a multisig\n *\n * @param connection Connection to use\n * @param address    Multisig account\n * @param commitment Desired level of commitment for querying the state\n * @param programId  SPL Token program account\n *\n * @return Multisig information\n */\nexport async function getMultisig(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {\n    const info = await connection.getAccountInfo(address, commitment);\n    return unpackMultisig(address, info, programId);\n}\n/**\n * Unpack a multisig\n *\n * @param address   Multisig account\n * @param info      Multisig account data\n * @param programId SPL Token program account\n *\n * @return Unpacked multisig\n */\nexport function unpackMultisig(address, info, programId = TOKEN_PROGRAM_ID) {\n    if (!info)\n        throw new TokenAccountNotFoundError();\n    if (!info.owner.equals(programId))\n        throw new TokenInvalidAccountOwnerError();\n    if (info.data.length != MULTISIG_SIZE)\n        throw new TokenInvalidAccountSizeError();\n    const multisig = MultisigLayout.decode(info.data);\n    return { address, ...multisig };\n}\n/** Get the minimum lamport balance for a multisig to be rent exempt\n *\n * @param connection Connection to use\n * @param commitment Desired level of commitment for querying the state\n *\n * @return Amount of lamports required\n */\nexport async function getMinimumBalanceForRentExemptMultisig(connection, commitment) {\n    return await connection.getMinimumBalanceForRentExemption(MULTISIG_SIZE, commitment);\n}\n//# sourceMappingURL=multisig.js.map"],"names":["MultisigLayout","struct","u8","bool","publicKey","MULTISIG_SIZE","span"],"mappings":"mGAkCaA,EAAiBC,EAAMA,OAAc,CAC9CC,EAAEA,GAAC,KACPA,EAAAA,GAAA,KACEC,EAAAA,KAAA,iBACEC,EAASA,UAAC,WACbA,EAAAA,UAAA,WACGA,EAASA,UAAC,WACVA,EAASA,UAAC,WACVA,EAAAA,UAAU,WACbA,EAAAA,UAAA,WACGA,EAAAA,UAAU,WACZA,EAAAA,UAAA,WACEA,EAAAA,UAAU,WACVA,EAAAA,UAAS,YACTA,EAAAA,UAAU,cAIDC,EAAgBL,EAAeM","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/base64-js/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("../../_virtual/index3.js");r.__exports.byteLength=function(r){var e=u(r),t=e[0],o=e[1];return 3*(t+o)/4-o},r.__exports.toByteArray=function(r){var e,n,a=u(r),h=a[0],i=a[1],c=new o(function(r,e,t){return 3*(e+t)/4-t}(0,h,i)),d=0,f=i>0?h-4:h;for(n=0;n<f;n+=4)e=t[r.charCodeAt(n)]<<18|t[r.charCodeAt(n+1)]<<12|t[r.charCodeAt(n+2)]<<6|t[r.charCodeAt(n+3)],c[d++]=e>>16&255,c[d++]=e>>8&255,c[d++]=255&e;2===i&&(e=t[r.charCodeAt(n)]<<2|t[r.charCodeAt(n+1)]>>4,c[d++]=255&e);1===i&&(e=t[r.charCodeAt(n)]<<10|t[r.charCodeAt(n+1)]<<4|t[r.charCodeAt(n+2)]>>2,c[d++]=e>>8&255,c[d++]=255&e);return c},r.__exports.fromByteArray=function(r){for(var t,o=r.length,n=o%3,a=[],u=16383,i=0,c=o-n;i<c;i+=u)a.push(h(r,i,i+u>c?c:i+u));1===n?(t=r[o-1],a.push(e[t>>2]+e[t<<4&63]+"==")):2===n&&(t=(r[o-2]<<8)+r[o-1],a.push(e[t>>10]+e[t>>4&63]+e[t<<2&63]+"="));return a.join("")};for(var e=[],t=[],o="undefined"!=typeof Uint8Array?Uint8Array:Array,n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",a=0;a<64;++a)e[a]=n[a],t[n.charCodeAt(a)]=a;function u(r){var e=r.length;if(e%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var t=r.indexOf("=");return-1===t&&(t=e),[t,t===e?0:4-t%4]}function h(r,t,o){for(var n,a,u=[],h=t;h<o;h+=3)n=(r[h]<<16&16711680)+(r[h+1]<<8&65280)+(255&r[h+2]),u.push(e[(a=n)>>18&63]+e[a>>12&63]+e[a>>6&63]+e[63&a]);return u.join("")}t["-".charCodeAt(0)]=62,t["_".charCodeAt(0)]=63,exports.default=r.__exports;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/base64-js/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/base64-js/index.js"],"sourcesContent":["'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n"],"names":["base64Js","__exports","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","i","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/borsh/lib/esm/buffer.js

@@ -0,0 +1,2 @@
+"use strict";var e=function(){function e(){this.offset=0,this.buffer_size=256,this.buffer=new ArrayBuffer(this.buffer_size),this.view=new DataView(this.buffer)}return e.prototype.resize_if_necessary=function(e){if(this.buffer_size-this.offset<e){this.buffer_size=Math.max(2*this.buffer_size,this.buffer_size+e);var t=new ArrayBuffer(this.buffer_size);new Uint8Array(t).set(new Uint8Array(this.buffer)),this.buffer=t,this.view=new DataView(t)}},e.prototype.get_used_buffer=function(){return new Uint8Array(this.buffer).slice(0,this.offset)},e.prototype.store_value=function(e,t){var s=t.substring(1),f=parseInt(s)/8;this.resize_if_necessary(f);var r="f"===t[0]?"setFloat".concat(s):"i"===t[0]?"setInt".concat(s):"setUint".concat(s);this.view[r](this.offset,e,!0),this.offset+=f},e.prototype.store_bytes=function(e){this.resize_if_necessary(e.length),new Uint8Array(this.buffer).set(new Uint8Array(e),this.offset),this.offset+=e.length},e}(),t=function(){function e(e){this.offset=0,this.buffer_size=e.length,this.buffer=new ArrayBuffer(e.length),new Uint8Array(this.buffer).set(e),this.view=new DataView(this.buffer)}return e.prototype.assert_enough_buffer=function(e){if(this.offset+e>this.buffer.byteLength)throw new Error("Error in schema, the buffer is smaller than expected")},e.prototype.consume_value=function(e){var t=e.substring(1),s=parseInt(t)/8;this.assert_enough_buffer(s);var f="f"===e[0]?"getFloat".concat(t):"i"===e[0]?"getInt".concat(t):"getUint".concat(t),r=this.view[f](this.offset,!0);return this.offset+=s,r},e.prototype.consume_bytes=function(e){this.assert_enough_buffer(e);var t=this.buffer.slice(this.offset,this.offset+e);return this.offset+=e,t},e}();exports.DecodeBuffer=t,exports.EncodeBuffer=e;
+//# sourceMappingURL=buffer.js.map

package/dist/cjs/node_modules/borsh/lib/esm/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","sources":["../../../../../../node_modules/borsh/lib/esm/buffer.js"],"sourcesContent":["var EncodeBuffer = /** @class */ (function () {\n    function EncodeBuffer() {\n        this.offset = 0;\n        this.buffer_size = 256;\n        this.buffer = new ArrayBuffer(this.buffer_size);\n        this.view = new DataView(this.buffer);\n    }\n    EncodeBuffer.prototype.resize_if_necessary = function (needed_space) {\n        if (this.buffer_size - this.offset < needed_space) {\n            this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);\n            var new_buffer = new ArrayBuffer(this.buffer_size);\n            new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));\n            this.buffer = new_buffer;\n            this.view = new DataView(new_buffer);\n        }\n    };\n    EncodeBuffer.prototype.get_used_buffer = function () {\n        return new Uint8Array(this.buffer).slice(0, this.offset);\n    };\n    EncodeBuffer.prototype.store_value = function (value, type) {\n        var bSize = type.substring(1);\n        var size = parseInt(bSize) / 8;\n        this.resize_if_necessary(size);\n        var toCall = type[0] === 'f' ? \"setFloat\".concat(bSize) : type[0] === 'i' ? \"setInt\".concat(bSize) : \"setUint\".concat(bSize);\n        this.view[toCall](this.offset, value, true);\n        this.offset += size;\n    };\n    EncodeBuffer.prototype.store_bytes = function (from) {\n        this.resize_if_necessary(from.length);\n        new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);\n        this.offset += from.length;\n    };\n    return EncodeBuffer;\n}());\nexport { EncodeBuffer };\nvar DecodeBuffer = /** @class */ (function () {\n    function DecodeBuffer(buf) {\n        this.offset = 0;\n        this.buffer_size = buf.length;\n        this.buffer = new ArrayBuffer(buf.length);\n        new Uint8Array(this.buffer).set(buf);\n        this.view = new DataView(this.buffer);\n    }\n    DecodeBuffer.prototype.assert_enough_buffer = function (size) {\n        if (this.offset + size > this.buffer.byteLength) {\n            throw new Error('Error in schema, the buffer is smaller than expected');\n        }\n    };\n    DecodeBuffer.prototype.consume_value = function (type) {\n        var bSize = type.substring(1);\n        var size = parseInt(bSize) / 8;\n        this.assert_enough_buffer(size);\n        var toCall = type[0] === 'f' ? \"getFloat\".concat(bSize) : type[0] === 'i' ? \"getInt\".concat(bSize) : \"getUint\".concat(bSize);\n        var ret = this.view[toCall](this.offset, true);\n        this.offset += size;\n        return ret;\n    };\n    DecodeBuffer.prototype.consume_bytes = function (size) {\n        this.assert_enough_buffer(size);\n        var ret = this.buffer.slice(this.offset, this.offset + size);\n        this.offset += size;\n        return ret;\n    };\n    return DecodeBuffer;\n}());\nexport { DecodeBuffer };\n"],"names":["EncodeBuffer","this","offset","buffer_size","buffer","ArrayBuffer","view","DataView","prototype","resize_if_necessary","needed_space","Math","max","new_buffer","Uint8Array","set","get_used_buffer","slice","store_value","value","type","bSize","substring","size","parseInt","toCall","concat","store_bytes","from","length","DecodeBuffer","buf","assert_enough_buffer","byteLength","Error","consume_value","ret","consume_bytes"],"mappings":"aAAIA,IAAAA,EAA8B,WAC9B,SAASA,IACLC,KAAKC,OAAS,EACdD,KAAKE,YAAc,IACnBF,KAAKG,OAAS,IAAIC,YAAYJ,KAAKE,aACnCF,KAAKK,KAAO,IAAIC,SAASN,KAAKG,OAClC,CA0BA,OAzBAJ,EAAaQ,UAAUC,oBAAsB,SAAUC,GACnD,GAAIT,KAAKE,YAAcF,KAAKC,OAASQ,EAAc,CAC/CT,KAAKE,YAAcQ,KAAKC,IAAuB,EAAnBX,KAAKE,YAAiBF,KAAKE,YAAcO,GACrE,IAAIG,EAAa,IAAIR,YAAYJ,KAAKE,aACtC,IAAIW,WAAWD,GAAYE,IAAI,IAAID,WAAWb,KAAKG,SACnDH,KAAKG,OAASS,EACdZ,KAAKK,KAAO,IAAIC,SAASM,EAC7B,CACH,EACDb,EAAaQ,UAAUQ,gBAAkB,WACrC,OAAO,IAAIF,WAAWb,KAAKG,QAAQa,MAAM,EAAGhB,KAAKC,OACpD,EACDF,EAAaQ,UAAUU,YAAc,SAAUC,EAAOC,GAClD,IAAIC,EAAQD,EAAKE,UAAU,GACvBC,EAAOC,SAASH,GAAS,EAC7BpB,KAAKQ,oBAAoBc,GACzB,IAAIE,EAAqB,MAAZL,EAAK,GAAa,WAAWM,OAAOL,GAAqB,MAAZD,EAAK,GAAa,SAASM,OAAOL,GAAS,UAAUK,OAAOL,GACtHpB,KAAKK,KAAKmB,GAAQxB,KAAKC,OAAQiB,GAAO,GACtClB,KAAKC,QAAUqB,CAClB,EACDvB,EAAaQ,UAAUmB,YAAc,SAAUC,GAC3C3B,KAAKQ,oBAAoBmB,EAAKC,QAC9B,IAAIf,WAAWb,KAAKG,QAAQW,IAAI,IAAID,WAAWc,GAAO3B,KAAKC,QAC3DD,KAAKC,QAAU0B,EAAKC,MACvB,EACM7B,CACX,CAjCkC,GAmC9B8B,EAA8B,WAC9B,SAASA,EAAaC,GAClB9B,KAAKC,OAAS,EACdD,KAAKE,YAAc4B,EAAIF,OACvB5B,KAAKG,OAAS,IAAIC,YAAY0B,EAAIF,QAClC,IAAIf,WAAWb,KAAKG,QAAQW,IAAIgB,GAChC9B,KAAKK,KAAO,IAAIC,SAASN,KAAKG,OAClC,CAqBA,OApBA0B,EAAatB,UAAUwB,qBAAuB,SAAUT,GACpD,GAAItB,KAAKC,OAASqB,EAAOtB,KAAKG,OAAO6B,WACjC,MAAM,IAAIC,MAAM,uDAEvB,EACDJ,EAAatB,UAAU2B,cAAgB,SAAUf,GAC7C,IAAIC,EAAQD,EAAKE,UAAU,GACvBC,EAAOC,SAASH,GAAS,EAC7BpB,KAAK+B,qBAAqBT,GAC1B,IAAIE,EAAqB,MAAZL,EAAK,GAAa,WAAWM,OAAOL,GAAqB,MAAZD,EAAK,GAAa,SAASM,OAAOL,GAAS,UAAUK,OAAOL,GAClHe,EAAMnC,KAAKK,KAAKmB,GAAQxB,KAAKC,QAAQ,GAEzC,OADAD,KAAKC,QAAUqB,EACRa,CACV,EACDN,EAAatB,UAAU6B,cAAgB,SAAUd,GAC7CtB,KAAK+B,qBAAqBT,GAC1B,IAAIa,EAAMnC,KAAKG,OAAOa,MAAMhB,KAAKC,OAAQD,KAAKC,OAASqB,GAEvD,OADAtB,KAAKC,QAAUqB,EACRa,CACV,EACMN,CACX,CA7BkC","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/borsh/lib/esm/deserialize.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("./types.js"),t=require("./buffer.js"),r=function(){function r(e){this.buffer=new t.DecodeBuffer(e)}return r.prototype.decode=function(e){return this.decode_value(e)},r.prototype.decode_value=function(t){if("string"==typeof t){if(e.integers.includes(t))return this.decode_integer(t);if("string"===t)return this.decode_string();if("bool"===t)return this.decode_boolean()}if("object"==typeof t){if("option"in t)return this.decode_option(t);if("enum"in t)return this.decode_enum(t);if("array"in t)return this.decode_array(t);if("set"in t)return this.decode_set(t);if("map"in t)return this.decode_map(t);if("struct"in t)return this.decode_struct(t)}throw new Error("Unsupported type: ".concat(t))},r.prototype.decode_integer=function(e){var t=parseInt(e.substring(1));return t<=32||"f64"==e?this.buffer.consume_value(e):this.decode_bigint(t,e.startsWith("i"))},r.prototype.decode_bigint=function(e,t){void 0===t&&(t=!1);var r=e/8,n=new Uint8Array(this.buffer.consume_bytes(r)),o=n.reduceRight((function(e,t){return e+t.toString(16).padStart(2,"0")}),"");return t&&n[r-1]?BigInt.asIntN(e,BigInt("0x".concat(o))):BigInt("0x".concat(o))},r.prototype.decode_string=function(){for(var e=this.decode_integer("u32"),t=new Uint8Array(this.buffer.consume_bytes(e)),r=[],n=0;n<e;++n){var o=t[n];if(o<128)r.push(o);else if(o<224)r.push((31&o)<<6|63&t[++n]);else if(o<240)r.push((15&o)<<12|(63&t[++n])<<6|63&t[++n]);else{var i=(7&o)<<18|(63&t[++n])<<12|(63&t[++n])<<6|63&t[++n];r.push(i)}}return String.fromCodePoint.apply(String,r)},r.prototype.decode_boolean=function(){return this.buffer.consume_value("u8")>0},r.prototype.decode_option=function(e){var t=this.buffer.consume_value("u8");if(1===t)return this.decode_value(e.option);if(0!==t)throw new Error("Invalid option ".concat(t));return null},r.prototype.decode_enum=function(e){var t,r=this.buffer.consume_value("u8");if(r>e.enum.length)throw new Error("Enum option ".concat(r," is not available"));var n=e.enum[r].struct,o=Object.keys(n)[0];return(t={})[o]=this.decode_value(n[o]),t},r.prototype.decode_array=function(e){for(var t=[],r=e.array.len?e.array.len:this.decode_integer("u32"),n=0;n<r;++n)t.push(this.decode_value(e.array.type));return t},r.prototype.decode_set=function(e){for(var t=this.decode_integer("u32"),r=new Set,n=0;n<t;++n)r.add(this.decode_value(e.set));return r},r.prototype.decode_map=function(e){for(var t=this.decode_integer("u32"),r=new Map,n=0;n<t;++n){var o=this.decode_value(e.map.key),i=this.decode_value(e.map.value);r.set(o,i)}return r},r.prototype.decode_struct=function(e){var t={};for(var r in e.struct)t[r]=this.decode_value(e.struct[r]);return t},r}();exports.BorshDeserializer=r;
+//# sourceMappingURL=deserialize.js.map

package/dist/cjs/node_modules/borsh/lib/esm/deserialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialize.js","sources":["../../../../../../node_modules/borsh/lib/esm/deserialize.js"],"sourcesContent":["import { integers } from './types.js';\nimport { DecodeBuffer } from './buffer.js';\nvar BorshDeserializer = /** @class */ (function () {\n    function BorshDeserializer(bufferArray) {\n        this.buffer = new DecodeBuffer(bufferArray);\n    }\n    BorshDeserializer.prototype.decode = function (schema) {\n        return this.decode_value(schema);\n    };\n    BorshDeserializer.prototype.decode_value = function (schema) {\n        if (typeof schema === 'string') {\n            if (integers.includes(schema))\n                return this.decode_integer(schema);\n            if (schema === 'string')\n                return this.decode_string();\n            if (schema === 'bool')\n                return this.decode_boolean();\n        }\n        if (typeof schema === 'object') {\n            if ('option' in schema)\n                return this.decode_option(schema);\n            if ('enum' in schema)\n                return this.decode_enum(schema);\n            if ('array' in schema)\n                return this.decode_array(schema);\n            if ('set' in schema)\n                return this.decode_set(schema);\n            if ('map' in schema)\n                return this.decode_map(schema);\n            if ('struct' in schema)\n                return this.decode_struct(schema);\n        }\n        throw new Error(\"Unsupported type: \".concat(schema));\n    };\n    BorshDeserializer.prototype.decode_integer = function (schema) {\n        var size = parseInt(schema.substring(1));\n        if (size <= 32 || schema == 'f64') {\n            return this.buffer.consume_value(schema);\n        }\n        return this.decode_bigint(size, schema.startsWith('i'));\n    };\n    BorshDeserializer.prototype.decode_bigint = function (size, signed) {\n        if (signed === void 0) { signed = false; }\n        var buffer_len = size / 8;\n        var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));\n        var bits = buffer.reduceRight(function (r, x) { return r + x.toString(16).padStart(2, '0'); }, '');\n        if (signed && buffer[buffer_len - 1]) {\n            return BigInt.asIntN(size, BigInt(\"0x\".concat(bits)));\n        }\n        return BigInt(\"0x\".concat(bits));\n    };\n    BorshDeserializer.prototype.decode_string = function () {\n        var len = this.decode_integer('u32');\n        var buffer = new Uint8Array(this.buffer.consume_bytes(len));\n        // decode utf-8 string without using TextDecoder\n        // first get all bytes to single byte code points\n        var codePoints = [];\n        for (var i = 0; i < len; ++i) {\n            var byte = buffer[i];\n            if (byte < 0x80) {\n                codePoints.push(byte);\n            }\n            else if (byte < 0xE0) {\n                codePoints.push(((byte & 0x1F) << 6) | (buffer[++i] & 0x3F));\n            }\n            else if (byte < 0xF0) {\n                codePoints.push(((byte & 0x0F) << 12) | ((buffer[++i] & 0x3F) << 6) | (buffer[++i] & 0x3F));\n            }\n            else {\n                var codePoint = ((byte & 0x07) << 18) | ((buffer[++i] & 0x3F) << 12) | ((buffer[++i] & 0x3F) << 6) | (buffer[++i] & 0x3F);\n                codePoints.push(codePoint);\n            }\n        }\n        // then decode code points to utf-8\n        return String.fromCodePoint.apply(String, codePoints);\n    };\n    BorshDeserializer.prototype.decode_boolean = function () {\n        return this.buffer.consume_value('u8') > 0;\n    };\n    BorshDeserializer.prototype.decode_option = function (schema) {\n        var option = this.buffer.consume_value('u8');\n        if (option === 1) {\n            return this.decode_value(schema.option);\n        }\n        if (option !== 0) {\n            throw new Error(\"Invalid option \".concat(option));\n        }\n        return null;\n    };\n    BorshDeserializer.prototype.decode_enum = function (schema) {\n        var _a;\n        var valueIndex = this.buffer.consume_value('u8');\n        if (valueIndex > schema[\"enum\"].length) {\n            throw new Error(\"Enum option \".concat(valueIndex, \" is not available\"));\n        }\n        var struct = schema[\"enum\"][valueIndex].struct;\n        var key = Object.keys(struct)[0];\n        return _a = {}, _a[key] = this.decode_value(struct[key]), _a;\n    };\n    BorshDeserializer.prototype.decode_array = function (schema) {\n        var result = [];\n        var len = schema.array.len ? schema.array.len : this.decode_integer('u32');\n        for (var i = 0; i < len; ++i) {\n            result.push(this.decode_value(schema.array.type));\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_set = function (schema) {\n        var len = this.decode_integer('u32');\n        var result = new Set();\n        for (var i = 0; i < len; ++i) {\n            result.add(this.decode_value(schema.set));\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_map = function (schema) {\n        var len = this.decode_integer('u32');\n        var result = new Map();\n        for (var i = 0; i < len; ++i) {\n            var key = this.decode_value(schema.map.key);\n            var value = this.decode_value(schema.map.value);\n            result.set(key, value);\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_struct = function (schema) {\n        var result = {};\n        for (var key in schema.struct) {\n            result[key] = this.decode_value(schema.struct[key]);\n        }\n        return result;\n    };\n    return BorshDeserializer;\n}());\nexport { BorshDeserializer };\n"],"names":["BorshDeserializer","bufferArray","this","buffer","DecodeBuffer","prototype","decode","schema","decode_value","integers","includes","decode_integer","decode_string","decode_boolean","decode_option","decode_enum","decode_array","decode_set","decode_map","decode_struct","Error","concat","size","parseInt","substring","consume_value","decode_bigint","startsWith","signed","buffer_len","Uint8Array","consume_bytes","bits","reduceRight","r","x","toString","padStart","BigInt","asIntN","len","codePoints","i","byte","push","codePoint","String","fromCodePoint","apply","option","_a","valueIndex","length","struct","key","Object","keys","result","array","type","Set","add","set","Map","map","value"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/borsh/lib/esm/index.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("./serialize.js"),r=require("./deserialize.js"),i=require("./utils.js");exports.deserialize=function(e,s,a){return void 0===a&&(a=!0),a&&i.validate_schema(e),new r.BorshDeserializer(s).decode(e)},exports.serialize=function(r,s,a){return void 0===a&&(a=!0),a&&i.validate_schema(r),new e.BorshSerializer(a).encode(s,r)};
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/borsh/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/borsh/lib/esm/index.js"],"sourcesContent":["import { BorshSerializer } from './serialize.js';\nimport { BorshDeserializer } from './deserialize.js';\nimport * as utils from './utils.js';\nexport function serialize(schema, value, validate) {\n    if (validate === void 0) { validate = true; }\n    if (validate)\n        utils.validate_schema(schema);\n    var serializer = new BorshSerializer(validate);\n    return serializer.encode(value, schema);\n}\nexport function deserialize(schema, buffer, validate) {\n    if (validate === void 0) { validate = true; }\n    if (validate)\n        utils.validate_schema(schema);\n    var deserializer = new BorshDeserializer(buffer);\n    return deserializer.decode(schema);\n}\n"],"names":["schema","buffer","validate","utils","validate_schema","BorshDeserializer","decode","value","BorshSerializer","encode"],"mappings":"uHAUO,SAAqBA,EAAQC,EAAQC,GAKxC,YAJiB,IAAbA,IAAuBA,GAAW,GAClCA,GACAC,EAAqBC,gBAACJ,GACP,IAAIK,EAAiBA,kBAACJ,GACrBK,OAAON,EAC/B,oBAbO,SAAmBA,EAAQO,EAAOL,GAKrC,YAJiB,IAAbA,IAAuBA,GAAW,GAClCA,GACAC,EAAqBC,gBAACJ,GACT,IAAIQ,EAAeA,gBAACN,GACnBO,OAAOF,EAAOP,EACpC","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/borsh/lib/esm/serialize.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("./types.js"),t=require("./buffer.js"),n=require("./utils.js"),r=function(){function r(e){this.encoded=new t.EncodeBuffer,this.fieldPath=["value"],this.checkTypes=e}return r.prototype.encode=function(e,t){return this.encode_value(e,t),this.encoded.get_used_buffer()},r.prototype.encode_value=function(t,n){if("string"==typeof n){if(e.integers.includes(n))return this.encode_integer(t,n);if("string"===n)return this.encode_string(t);if("bool"===n)return this.encode_boolean(t)}if("object"==typeof n){if("option"in n)return this.encode_option(t,n);if("enum"in n)return this.encode_enum(t,n);if("array"in n)return this.encode_array(t,n);if("set"in n)return this.encode_set(t,n);if("map"in n)return this.encode_map(t,n);if("struct"in n)return this.encode_struct(t,n)}},r.prototype.encode_integer=function(e,t){var r=parseInt(t.substring(1));r<=32||"f64"==t?(this.checkTypes&&n.expect_type(e,"number",this.fieldPath),this.encoded.store_value(e,t)):(this.checkTypes&&n.expect_bigint(e,this.fieldPath),this.encode_bigint(BigInt(e),r))},r.prototype.encode_bigint=function(e,t){for(var n=t/8,r=new Uint8Array(n),o=0;o<n;o++)r[o]=Number(e&BigInt(255)),e>>=BigInt(8);this.encoded.store_bytes(new Uint8Array(r))},r.prototype.encode_string=function(e){this.checkTypes&&n.expect_type(e,"string",this.fieldPath);for(var t=e,r=[],o=0;o<t.length;o++){var i=t.charCodeAt(o);i<128?r.push(i):i<2048?r.push(192|i>>6,128|63&i):i<55296||i>=57344?r.push(224|i>>12,128|i>>6&63,128|63&i):(o++,i=65536+((1023&i)<<10|1023&t.charCodeAt(o)),r.push(240|i>>18,128|i>>12&63,128|i>>6&63,128|63&i))}this.encoded.store_value(r.length,"u32"),this.encoded.store_bytes(new Uint8Array(r))},r.prototype.encode_boolean=function(e){this.checkTypes&&n.expect_type(e,"boolean",this.fieldPath),this.encoded.store_value(e?1:0,"u8")},r.prototype.encode_option=function(e,t){null==e?this.encoded.store_value(0,"u8"):(this.encoded.store_value(1,"u8"),this.encode_value(e,t.option))},r.prototype.encode_enum=function(e,t){this.checkTypes&&n.expect_enum(e,this.fieldPath);for(var r=Object.keys(e)[0],o=0;o<t.enum.length;o++){var i=t.enum[o];if(r===Object.keys(i.struct)[0])return this.encoded.store_value(o,"u8"),this.encode_struct(e,i)}throw new Error("Enum key (".concat(r,") not found in enum schema: ").concat(JSON.stringify(t)," at ").concat(this.fieldPath.join(".")))},r.prototype.encode_array=function(e,t){if(n.isArrayLike(e))return this.encode_arraylike(e,t);if(e instanceof ArrayBuffer)return this.encode_buffer(e,t);throw new Error("Expected Array-like not ".concat(typeof e,"(").concat(e,") at ").concat(this.fieldPath.join(".")))},r.prototype.encode_arraylike=function(e,t){t.array.len?n.expect_same_size(e.length,t.array.len,this.fieldPath):this.encoded.store_value(e.length,"u32");for(var r=0;r<e.length;r++)this.encode_value(e[r],t.array.type)},r.prototype.encode_buffer=function(e,t){t.array.len?n.expect_same_size(e.byteLength,t.array.len,this.fieldPath):this.encoded.store_value(e.byteLength,"u32"),this.encoded.store_bytes(new Uint8Array(e))},r.prototype.encode_set=function(e,t){this.checkTypes&&n.expect_type(e,"object",this.fieldPath);var r=e instanceof Set?Array.from(e.values()):Object.values(e);this.encoded.store_value(r.length,"u32");for(var o=0,i=r;o<i.length;o++){var s=i[o];this.encode_value(s,t.set)}},r.prototype.encode_map=function(e,t){this.checkTypes&&n.expect_type(e,"object",this.fieldPath);var r=e instanceof Map,o=r?Array.from(e.keys()):Object.keys(e);this.encoded.store_value(o.length,"u32");for(var i=0,s=o;i<s.length;i++){var c=s[i];this.encode_value(c,t.map.key),this.encode_value(r?e.get(c):e[c],t.map.value)}},r.prototype.encode_struct=function(e,t){this.checkTypes&&n.expect_type(e,"object",this.fieldPath);for(var r=0,o=Object.keys(t.struct);r<o.length;r++){var i=o[r];this.fieldPath.push(i),this.encode_value(e[i],t.struct[i]),this.fieldPath.pop()}},r}();exports.BorshSerializer=r;
+//# sourceMappingURL=serialize.js.map

package/dist/cjs/node_modules/borsh/lib/esm/serialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.js","sources":["../../../../../../node_modules/borsh/lib/esm/serialize.js"],"sourcesContent":["import { integers } from './types.js';\nimport { EncodeBuffer } from './buffer.js';\nimport * as utils from './utils.js';\nvar BorshSerializer = /** @class */ (function () {\n    function BorshSerializer(checkTypes) {\n        this.encoded = new EncodeBuffer();\n        this.fieldPath = ['value'];\n        this.checkTypes = checkTypes;\n    }\n    BorshSerializer.prototype.encode = function (value, schema) {\n        this.encode_value(value, schema);\n        return this.encoded.get_used_buffer();\n    };\n    BorshSerializer.prototype.encode_value = function (value, schema) {\n        if (typeof schema === 'string') {\n            if (integers.includes(schema))\n                return this.encode_integer(value, schema);\n            if (schema === 'string')\n                return this.encode_string(value);\n            if (schema === 'bool')\n                return this.encode_boolean(value);\n        }\n        if (typeof schema === 'object') {\n            if ('option' in schema)\n                return this.encode_option(value, schema);\n            if ('enum' in schema)\n                return this.encode_enum(value, schema);\n            if ('array' in schema)\n                return this.encode_array(value, schema);\n            if ('set' in schema)\n                return this.encode_set(value, schema);\n            if ('map' in schema)\n                return this.encode_map(value, schema);\n            if ('struct' in schema)\n                return this.encode_struct(value, schema);\n        }\n    };\n    BorshSerializer.prototype.encode_integer = function (value, schema) {\n        var size = parseInt(schema.substring(1));\n        if (size <= 32 || schema == 'f64') {\n            this.checkTypes && utils.expect_type(value, 'number', this.fieldPath);\n            this.encoded.store_value(value, schema);\n        }\n        else {\n            this.checkTypes && utils.expect_bigint(value, this.fieldPath);\n            this.encode_bigint(BigInt(value), size);\n        }\n    };\n    BorshSerializer.prototype.encode_bigint = function (value, size) {\n        var buffer_len = size / 8;\n        var buffer = new Uint8Array(buffer_len);\n        for (var i = 0; i < buffer_len; i++) {\n            buffer[i] = Number(value & BigInt(0xff));\n            value = value >> BigInt(8);\n        }\n        this.encoded.store_bytes(new Uint8Array(buffer));\n    };\n    BorshSerializer.prototype.encode_string = function (value) {\n        this.checkTypes && utils.expect_type(value, 'string', this.fieldPath);\n        var _value = value;\n        // encode to utf8 bytes without using TextEncoder\n        var utf8Bytes = [];\n        for (var i = 0; i < _value.length; i++) {\n            var charCode = _value.charCodeAt(i);\n            if (charCode < 0x80) {\n                utf8Bytes.push(charCode);\n            }\n            else if (charCode < 0x800) {\n                utf8Bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));\n            }\n            else if (charCode < 0xd800 || charCode >= 0xe000) {\n                utf8Bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));\n            }\n            else {\n                i++;\n                charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (_value.charCodeAt(i) & 0x3ff));\n                utf8Bytes.push(0xf0 | (charCode >> 18), 0x80 | ((charCode >> 12) & 0x3f), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));\n            }\n        }\n        // 4 bytes for length + string bytes\n        this.encoded.store_value(utf8Bytes.length, 'u32');\n        this.encoded.store_bytes(new Uint8Array(utf8Bytes));\n    };\n    BorshSerializer.prototype.encode_boolean = function (value) {\n        this.checkTypes && utils.expect_type(value, 'boolean', this.fieldPath);\n        this.encoded.store_value(value ? 1 : 0, 'u8');\n    };\n    BorshSerializer.prototype.encode_option = function (value, schema) {\n        if (value === null || value === undefined) {\n            this.encoded.store_value(0, 'u8');\n        }\n        else {\n            this.encoded.store_value(1, 'u8');\n            this.encode_value(value, schema.option);\n        }\n    };\n    BorshSerializer.prototype.encode_enum = function (value, schema) {\n        this.checkTypes && utils.expect_enum(value, this.fieldPath);\n        var valueKey = Object.keys(value)[0];\n        for (var i = 0; i < schema[\"enum\"].length; i++) {\n            var valueSchema = schema[\"enum\"][i];\n            if (valueKey === Object.keys(valueSchema.struct)[0]) {\n                this.encoded.store_value(i, 'u8');\n                return this.encode_struct(value, valueSchema);\n            }\n        }\n        throw new Error(\"Enum key (\".concat(valueKey, \") not found in enum schema: \").concat(JSON.stringify(schema), \" at \").concat(this.fieldPath.join('.')));\n    };\n    BorshSerializer.prototype.encode_array = function (value, schema) {\n        if (utils.isArrayLike(value))\n            return this.encode_arraylike(value, schema);\n        if (value instanceof ArrayBuffer)\n            return this.encode_buffer(value, schema);\n        throw new Error(\"Expected Array-like not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(this.fieldPath.join('.')));\n    };\n    BorshSerializer.prototype.encode_arraylike = function (value, schema) {\n        if (schema.array.len) {\n            utils.expect_same_size(value.length, schema.array.len, this.fieldPath);\n        }\n        else {\n            // 4 bytes for length\n            this.encoded.store_value(value.length, 'u32');\n        }\n        // array values\n        for (var i = 0; i < value.length; i++) {\n            this.encode_value(value[i], schema.array.type);\n        }\n    };\n    BorshSerializer.prototype.encode_buffer = function (value, schema) {\n        if (schema.array.len) {\n            utils.expect_same_size(value.byteLength, schema.array.len, this.fieldPath);\n        }\n        else {\n            // 4 bytes for length\n            this.encoded.store_value(value.byteLength, 'u32');\n        }\n        // array values\n        this.encoded.store_bytes(new Uint8Array(value));\n    };\n    BorshSerializer.prototype.encode_set = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        var isSet = value instanceof Set;\n        var values = isSet ? Array.from(value.values()) : Object.values(value);\n        // 4 bytes for length\n        this.encoded.store_value(values.length, 'u32');\n        // set values\n        for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {\n            var value_1 = values_1[_i];\n            this.encode_value(value_1, schema.set);\n        }\n    };\n    BorshSerializer.prototype.encode_map = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        var isMap = value instanceof Map;\n        var keys = isMap ? Array.from(value.keys()) : Object.keys(value);\n        // 4 bytes for length\n        this.encoded.store_value(keys.length, 'u32');\n        // store key/values\n        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n            var key = keys_1[_i];\n            this.encode_value(key, schema.map.key);\n            this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);\n        }\n    };\n    BorshSerializer.prototype.encode_struct = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        for (var _i = 0, _a = Object.keys(schema.struct); _i < _a.length; _i++) {\n            var key = _a[_i];\n            this.fieldPath.push(key);\n            this.encode_value(value[key], schema.struct[key]);\n            this.fieldPath.pop();\n        }\n    };\n    return BorshSerializer;\n}());\nexport { BorshSerializer };\n"],"names":["BorshSerializer","checkTypes","this","encoded","EncodeBuffer","fieldPath","prototype","encode","value","schema","encode_value","get_used_buffer","integers","includes","encode_integer","encode_string","encode_boolean","encode_option","encode_enum","encode_array","encode_set","encode_map","encode_struct","size","parseInt","substring","utils","expect_type","store_value","encode_bigint","BigInt","buffer_len","buffer","Uint8Array","i","Number","store_bytes","_value","utf8Bytes","length","charCode","charCodeAt","push","option","valueKey","Object","keys","valueSchema","struct","Error","concat","JSON","stringify","join","encode_arraylike","ArrayBuffer","encode_buffer","array","len","expect_same_size","type","byteLength","values","Set","Array","from","_i","values_1","value_1","set","isMap","Map","keys_1","key","map","get","_a","pop"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/borsh/lib/esm/types.js

@@ -0,0 +1,2 @@
+"use strict";exports.integers=["u8","u16","u32","u64","u128","i8","i16","i32","i64","i128","f32","f64"];
+//# sourceMappingURL=types.js.map

package/dist/cjs/node_modules/borsh/lib/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../../../../node_modules/borsh/lib/esm/types.js"],"sourcesContent":["export var integers = ['u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16', 'i32', 'i64', 'i128', 'f32', 'f64'];\n"],"names":[],"mappings":"8BAAsB,CAAC,KAAM,MAAO,MAAO,MAAO,OAAQ,KAAM,MAAO,MAAO,MAAO,OAAQ,MAAO","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/borsh/lib/esm/utils.js

@@ -0,0 +1,2 @@
+"use strict";var t,e=require("./types.js"),n=(t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n])},t(e,n)},function(e,n){if("function"!=typeof n&&null!==n)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");function r(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)});var r=e.integers.concat(["bool","string"]),o=["option","enum","array","set","map","struct"],c=function(t){function e(e,n){var r="Invalid schema: ".concat(JSON.stringify(e)," expected ").concat(n);return t.call(this,r)||this}return n(e,t),e}(Error);function i(t){if("string"!=typeof t||!r.includes(t)){if(t&&"object"==typeof t){var e=Object.keys(t);if(1===e.length&&o.includes(e[0])){var n=e[0];if("option"===n)return i(t[n]);if("enum"===n)return function(t){if(!Array.isArray(t))throw new c(t,"Array");for(var e=0,n=t;e<n.length;e++){var r=n[e];if("object"!=typeof r||!("struct"in r))throw new Error('Missing "struct" key in enum schema');if("object"!=typeof r.struct||1!==Object.keys(r.struct).length)throw new Error('The "struct" in each enum must have a single key');i({struct:r.struct})}}(t[n]);if("array"===n)return function(t){if("object"!=typeof t)throw new c(t,"{ type, len? }");if(t.len&&"number"!=typeof t.len)throw new Error("Invalid schema: ".concat(t));if("type"in t)return i(t.type);throw new c(t,"{ type, len? }")}(t[n]);if("set"===n)return i(t[n]);if("map"===n)return function(t){if("object"!=typeof t||!("key"in t)||!("value"in t))throw new c(t,"{ key, value }");i(t.key),i(t.value)}(t[n]);if("struct"===n)return function(t){if("object"!=typeof t)throw new c(t,"object");for(var e in t)i(t[e])}(t[n])}}throw new c(t,o.join(", ")+" or "+r.join(", "))}}exports.ErrorSchema=c,exports.expect_bigint=function(t,e){if(!["number","string","bigint","boolean"].includes(typeof t)&&!("object"==typeof t&&null!==t&&"toString"in t))throw new Error("Expected bigint, number, boolean or string not ".concat(typeof t,"(").concat(t,") at ").concat(e.join(".")))},exports.expect_enum=function(t,e){if("object"!=typeof t||null===t)throw new Error("Expected object not ".concat(typeof t,"(").concat(t,") at ").concat(e.join(".")))},exports.expect_same_size=function(t,e,n){if(t!==e)throw new Error("Array length ".concat(t," does not match schema length ").concat(e," at ").concat(n.join(".")))},exports.expect_type=function(t,e,n){if(typeof t!==e)throw new Error("Expected ".concat(e," not ").concat(typeof t,"(").concat(t,") at ").concat(n.join(".")))},exports.isArrayLike=function(t){return Array.isArray(t)||!!t&&"object"==typeof t&&"length"in t&&"number"==typeof t.length&&(0===t.length||t.length>0&&t.length-1 in t)},exports.validate_schema=i;
+//# sourceMappingURL=utils.js.map

package/dist/cjs/node_modules/borsh/lib/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../node_modules/borsh/lib/esm/utils.js"],"sourcesContent":["var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { integers } from './types.js';\nexport function isArrayLike(value) {\n    // source: https://stackoverflow.com/questions/24048547/checking-if-an-object-is-array-like\n    return (Array.isArray(value) ||\n        (!!value &&\n            typeof value === 'object' &&\n            'length' in value &&\n            typeof (value.length) === 'number' &&\n            (value.length === 0 ||\n                (value.length > 0 &&\n                    (value.length - 1) in value))));\n}\nexport function expect_type(value, type, fieldPath) {\n    if (typeof (value) !== type) {\n        throw new Error(\"Expected \".concat(type, \" not \").concat(typeof (value), \"(\").concat(value, \") at \").concat(fieldPath.join('.')));\n    }\n}\nexport function expect_bigint(value, fieldPath) {\n    var basicType = ['number', 'string', 'bigint', 'boolean'].includes(typeof (value));\n    var strObject = typeof (value) === 'object' && value !== null && 'toString' in value;\n    if (!basicType && !strObject) {\n        throw new Error(\"Expected bigint, number, boolean or string not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(fieldPath.join('.')));\n    }\n}\nexport function expect_same_size(length, expected, fieldPath) {\n    if (length !== expected) {\n        throw new Error(\"Array length \".concat(length, \" does not match schema length \").concat(expected, \" at \").concat(fieldPath.join('.')));\n    }\n}\nexport function expect_enum(value, fieldPath) {\n    if (typeof (value) !== 'object' || value === null) {\n        throw new Error(\"Expected object not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(fieldPath.join('.')));\n    }\n}\n// Validate Schema\nvar VALID_STRING_TYPES = integers.concat(['bool', 'string']);\nvar VALID_OBJECT_KEYS = ['option', 'enum', 'array', 'set', 'map', 'struct'];\nvar ErrorSchema = /** @class */ (function (_super) {\n    __extends(ErrorSchema, _super);\n    function ErrorSchema(schema, expected) {\n        var message = \"Invalid schema: \".concat(JSON.stringify(schema), \" expected \").concat(expected);\n        return _super.call(this, message) || this;\n    }\n    return ErrorSchema;\n}(Error));\nexport { ErrorSchema };\nexport function validate_schema(schema) {\n    if (typeof (schema) === 'string' && VALID_STRING_TYPES.includes(schema)) {\n        return;\n    }\n    if (schema && typeof (schema) === 'object') {\n        var keys = Object.keys(schema);\n        if (keys.length === 1 && VALID_OBJECT_KEYS.includes(keys[0])) {\n            var key = keys[0];\n            if (key === 'option')\n                return validate_schema(schema[key]);\n            if (key === 'enum')\n                return validate_enum_schema(schema[key]);\n            if (key === 'array')\n                return validate_array_schema(schema[key]);\n            if (key === 'set')\n                return validate_schema(schema[key]);\n            if (key === 'map')\n                return validate_map_schema(schema[key]);\n            if (key === 'struct')\n                return validate_struct_schema(schema[key]);\n        }\n    }\n    throw new ErrorSchema(schema, VALID_OBJECT_KEYS.join(', ') + ' or ' + VALID_STRING_TYPES.join(', '));\n}\nfunction validate_enum_schema(schema) {\n    if (!Array.isArray(schema))\n        throw new ErrorSchema(schema, 'Array');\n    for (var _i = 0, schema_1 = schema; _i < schema_1.length; _i++) {\n        var sch = schema_1[_i];\n        if (typeof sch !== 'object' || !('struct' in sch)) {\n            throw new Error('Missing \"struct\" key in enum schema');\n        }\n        if (typeof sch.struct !== 'object' || Object.keys(sch.struct).length !== 1) {\n            throw new Error('The \"struct\" in each enum must have a single key');\n        }\n        validate_schema({ struct: sch.struct });\n    }\n}\nfunction validate_array_schema(schema) {\n    if (typeof schema !== 'object')\n        throw new ErrorSchema(schema, '{ type, len? }');\n    if (schema.len && typeof schema.len !== 'number') {\n        throw new Error(\"Invalid schema: \".concat(schema));\n    }\n    if ('type' in schema)\n        return validate_schema(schema.type);\n    throw new ErrorSchema(schema, '{ type, len? }');\n}\nfunction validate_map_schema(schema) {\n    if (typeof schema === 'object' && 'key' in schema && 'value' in schema) {\n        validate_schema(schema.key);\n        validate_schema(schema.value);\n    }\n    else {\n        throw new ErrorSchema(schema, '{ key, value }');\n    }\n}\nfunction validate_struct_schema(schema) {\n    if (typeof schema !== 'object')\n        throw new ErrorSchema(schema, 'object');\n    for (var key in schema) {\n        validate_schema(schema[key]);\n    }\n}\n"],"names":["extendStatics","__extends","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","this","constructor","create","VALID_STRING_TYPES","integers","concat","VALID_OBJECT_KEYS","ErrorSchema","_super","schema","expected","message","JSON","stringify","Error","validate_schema","includes","keys","length","key","isArray","_i","schema_1","sch","struct","validate_enum_schema","len","type","validate_array_schema","value","validate_map_schema","validate_struct_schema","join","fieldPath"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/bs58/index.js

@@ -0,0 +1,2 @@
+"use strict";var s=(0,require("./node_modules/base-x/src/index.js").src)("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");exports.bs58=s;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/bs58/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/bs58/index.js"],"sourcesContent":["const basex = require('base-x')\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n"],"names":["bs58","basex","src"],"mappings":"iBAGAA,GAAiBC,gDAHHC,KACG","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/bs58/node_modules/base-x/src/index.js

@@ -0,0 +1,2 @@
+"use strict";var r=function(r){if(r.length>=255)throw new TypeError("Alphabet too long");for(var e=new Uint8Array(256),t=0;t<e.length;t++)e[t]=255;for(var n=0;n<r.length;n++){var o=r.charAt(n),a=o.charCodeAt(0);if(255!==e[a])throw new TypeError(o+" is ambiguous");e[a]=n}var f=r.length,i=r.charAt(0),h=Math.log(f)/Math.log(256),c=Math.log(256)/Math.log(f);function y(r){if("string"!=typeof r)throw new TypeError("Expected String");if(0===r.length)return new Uint8Array;for(var t=0,n=0,o=0;r[t]===i;)n++,t++;for(var a=(r.length-t)*h+1>>>0,c=new Uint8Array(a);r[t];){var y=r.charCodeAt(t);if(y>255)return;var w=e[y];if(255===w)return;for(var A=0,v=a-1;(0!==w||A<o)&&-1!==v;v--,A++)w+=f*c[v]>>>0,c[v]=w%256>>>0,w=w/256>>>0;if(0!==w)throw new Error("Non-zero carry");o=A,t++}for(var g=a-o;g!==a&&0===c[g];)g++;for(var u=new Uint8Array(n+(a-g)),l=n;g!==a;)u[l++]=c[g++];return u}return{encode:function(e){if(e instanceof Uint8Array||(ArrayBuffer.isView(e)?e=new Uint8Array(e.buffer,e.byteOffset,e.byteLength):Array.isArray(e)&&(e=Uint8Array.from(e))),!(e instanceof Uint8Array))throw new TypeError("Expected Uint8Array");if(0===e.length)return"";for(var t=0,n=0,o=0,a=e.length;o!==a&&0===e[o];)o++,t++;for(var h=(a-o)*c+1>>>0,y=new Uint8Array(h);o!==a;){for(var w=e[o],A=0,v=h-1;(0!==w||A<n)&&-1!==v;v--,A++)w+=256*y[v]>>>0,y[v]=w%f>>>0,w=w/f>>>0;if(0!==w)throw new Error("Non-zero carry");n=A,o++}for(var g=h-n;g!==h&&0===y[g];)g++;for(var u=i.repeat(t);g<h;++g)u+=r.charAt(y[g]);return u},decodeUnsafe:y,decode:function(r){var e=y(r);if(e)return e;throw new Error("Non-base"+f+" character")}}};exports.src=r;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/bs58/node_modules/base-x/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/bs58/node_modules/base-x/src/index.js"],"sourcesContent":["'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            // Find code of next character\n      var charCode = source.charCodeAt(psz)\n            // Base map can not be indexed using char code\n      if (charCode > 255) { return }\n            // Decode character\n      var carry = BASE_MAP[charCode]\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"],"names":["src","ALPHABET","length","TypeError","BASE_MAP","Uint8Array","j","i","x","charAt","xc","charCodeAt","BASE","LEADER","FACTOR","Math","log","iFACTOR","decodeUnsafe","source","psz","zeroes","size","b256","charCode","carry","it3","Error","it4","vch","encode","ArrayBuffer","isView","buffer","byteOffset","byteLength","Array","isArray","from","pbegin","pend","b58","it1","it2","str","repeat","decode","string"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/buffer/index.js

@@ -0,0 +1,9 @@
+"use strict";var t=require("../../_virtual/index.js"),e=require("../../_virtual/index2.js");require("../ieee754/index.js");var r=require("../../_virtual/index3.js");require("../base64-js/index.js"),
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+function(t){const n=r.__exports,i=e.__exports,o="function"==typeof Symbol&&"function"==typeof Symbol.for?Symbol.for("nodejs.util.inspect.custom"):null;t.Buffer=u,t.SlowBuffer=function(t){+t!=t&&(t=0);return u.alloc(+t)},t.INSPECT_MAX_BYTES=50;const f=2147483647;function s(t){if(t>f)throw new RangeError('The value "'+t+'" is invalid for option "size"');const e=new Uint8Array(t);return Object.setPrototypeOf(e,u.prototype),e}function u(t,e,r){if("number"==typeof t){if("string"==typeof e)throw new TypeError('The "string" argument must be of type string. Received type number');return a(t)}return h(t,e,r)}function h(t,e,r){if("string"==typeof t)return function(t,e){"string"==typeof e&&""!==e||(e="utf8");if(!u.isEncoding(e))throw new TypeError("Unknown encoding: "+e);const r=0|y(t,e);let n=s(r);const i=n.write(t,e);i!==r&&(n=n.slice(0,i));return n}(t,e);if(ArrayBuffer.isView(t))return function(t){if(J(t,Uint8Array)){const e=new Uint8Array(t);return p(e.buffer,e.byteOffset,e.byteLength)}return l(t)}(t);if(null==t)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof t);if(J(t,ArrayBuffer)||t&&J(t.buffer,ArrayBuffer))return p(t,e,r);if("undefined"!=typeof SharedArrayBuffer&&(J(t,SharedArrayBuffer)||t&&J(t.buffer,SharedArrayBuffer)))return p(t,e,r);if("number"==typeof t)throw new TypeError('The "value" argument must not be of type number. Received type number');const n=t.valueOf&&t.valueOf();if(null!=n&&n!==t)return u.from(n,e,r);const i=function(t){if(u.isBuffer(t)){const e=0|g(t.length),r=s(e);return 0===r.length||t.copy(r,0,0,e),r}if(void 0!==t.length)return"number"!=typeof t.length||Z(t.length)?s(0):l(t);if("Buffer"===t.type&&Array.isArray(t.data))return l(t.data)}(t);if(i)return i;if("undefined"!=typeof Symbol&&null!=Symbol.toPrimitive&&"function"==typeof t[Symbol.toPrimitive])return u.from(t[Symbol.toPrimitive]("string"),e,r);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof t)}function c(t){if("number"!=typeof t)throw new TypeError('"size" argument must be of type number');if(t<0)throw new RangeError('The value "'+t+'" is invalid for option "size"')}function a(t){return c(t),s(t<0?0:0|g(t))}function l(t){const e=t.length<0?0:0|g(t.length),r=s(e);for(let n=0;n<e;n+=1)r[n]=255&t[n];return r}function p(t,e,r){if(e<0||t.byteLength<e)throw new RangeError('"offset" is outside of buffer bounds');if(t.byteLength<e+(r||0))throw new RangeError('"length" is outside of buffer bounds');let n;return n=void 0===e&&void 0===r?new Uint8Array(t):void 0===r?new Uint8Array(t,e):new Uint8Array(t,e,r),Object.setPrototypeOf(n,u.prototype),n}function g(t){if(t>=f)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+f.toString(16)+" bytes");return 0|t}function y(t,e){if(u.isBuffer(t))return t.length;if(ArrayBuffer.isView(t)||J(t,ArrayBuffer))return t.byteLength;if("string"!=typeof t)throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof t);const r=t.length,n=arguments.length>2&&!0===arguments[2];if(!n&&0===r)return 0;let i=!1;for(;;)switch(e){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":return V(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return W(t).length;default:if(i)return n?-1:V(t).length;e=(""+e).toLowerCase(),i=!0}}function w(t,e,r){let n=!1;if((void 0===e||e<0)&&(e=0),e>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(e>>>=0))return"";for(t||(t="utf8");;)switch(t){case"hex":return L(this,e,r);case"utf8":case"utf-8":return R(this,e,r);case"ascii":return O(this,e,r);case"latin1":case"binary":return _(this,e,r);case"base64":return v(this,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return S(this,e,r);default:if(n)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),n=!0}}function d(t,e,r){const n=t[e];t[e]=t[r],t[r]=n}function b(t,e,r,n,i){if(0===t.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),Z(r=+r)&&(r=i?0:t.length-1),r<0&&(r=t.length+r),r>=t.length){if(i)return-1;r=t.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof e&&(e=u.from(e,n)),u.isBuffer(e))return 0===e.length?-1:B(t,e,r,n,i);if("number"==typeof e)return e&=255,"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(t,e,r):Uint8Array.prototype.lastIndexOf.call(t,e,r):B(t,[e],r,n,i);throw new TypeError("val must be string, number or Buffer")}function B(t,e,r,n,i){let o,f=1,s=t.length,u=e.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(t.length<2||e.length<2)return-1;f=2,s/=2,u/=2,r/=2}function h(t,e){return 1===f?t[e]:t.readUInt16BE(e*f)}if(i){let n=-1;for(o=r;o<s;o++)if(h(t,o)===h(e,-1===n?0:o-n)){if(-1===n&&(n=o),o-n+1===u)return n*f}else-1!==n&&(o-=o-n),n=-1}else for(r+u>s&&(r=s-u),o=r;o>=0;o--){let r=!0;for(let n=0;n<u;n++)if(h(t,o+n)!==h(e,n)){r=!1;break}if(r)return o}return-1}function E(t,e,r,n){r=Number(r)||0;const i=t.length-r;n?(n=Number(n))>i&&(n=i):n=i;const o=e.length;let f;for(n>o/2&&(n=o/2),f=0;f<n;++f){const n=parseInt(e.substr(2*f,2),16);if(Z(n))return f;t[r+f]=n}return f}function m(t,e,r,n){return X(V(e,t.length-r),t,r,n)}function I(t,e,r,n){return X(function(t){const e=[];for(let r=0;r<t.length;++r)e.push(255&t.charCodeAt(r));return e}(e),t,r,n)}function U(t,e,r,n){return X(W(e),t,r,n)}function A(t,e,r,n){return X(function(t,e){let r,n,i;const o=[];for(let f=0;f<t.length&&!((e-=2)<0);++f)r=t.charCodeAt(f),n=r>>8,i=r%256,o.push(i),o.push(n);return o}(e,t.length-r),t,r,n)}function v(t,e,r){return 0===e&&r===t.length?n.fromByteArray(t):n.fromByteArray(t.slice(e,r))}function R(t,e,r){r=Math.min(t.length,r);const n=[];let i=e;for(;i<r;){const e=t[i];let o=null,f=e>239?4:e>223?3:e>191?2:1;if(i+f<=r){let r,n,s,u;switch(f){case 1:e<128&&(o=e);break;case 2:r=t[i+1],128==(192&r)&&(u=(31&e)<<6|63&r,u>127&&(o=u));break;case 3:r=t[i+1],n=t[i+2],128==(192&r)&&128==(192&n)&&(u=(15&e)<<12|(63&r)<<6|63&n,u>2047&&(u<55296||u>57343)&&(o=u));break;case 4:r=t[i+1],n=t[i+2],s=t[i+3],128==(192&r)&&128==(192&n)&&128==(192&s)&&(u=(15&e)<<18|(63&r)<<12|(63&n)<<6|63&s,u>65535&&u<1114112&&(o=u))}}null===o?(o=65533,f=1):o>65535&&(o-=65536,n.push(o>>>10&1023|55296),o=56320|1023&o),n.push(o),i+=f}return function(t){const e=t.length;if(e<=T)return String.fromCharCode.apply(String,t);let r="",n=0;for(;n<e;)r+=String.fromCharCode.apply(String,t.slice(n,n+=T));return r}(n)}t.kMaxLength=f,u.TYPED_ARRAY_SUPPORT=function(){try{const t=new Uint8Array(1),e={foo:function(){return 42}};return Object.setPrototypeOf(e,Uint8Array.prototype),Object.setPrototypeOf(t,e),42===t.foo()}catch(t){return!1}}(),u.TYPED_ARRAY_SUPPORT||"undefined"==typeof console||"function"!=typeof console.error||console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."),Object.defineProperty(u.prototype,"parent",{enumerable:!0,get:function(){if(u.isBuffer(this))return this.buffer}}),Object.defineProperty(u.prototype,"offset",{enumerable:!0,get:function(){if(u.isBuffer(this))return this.byteOffset}}),u.poolSize=8192,u.from=function(t,e,r){return h(t,e,r)},Object.setPrototypeOf(u.prototype,Uint8Array.prototype),Object.setPrototypeOf(u,Uint8Array),u.alloc=function(t,e,r){return function(t,e,r){return c(t),t<=0?s(t):void 0!==e?"string"==typeof r?s(t).fill(e,r):s(t).fill(e):s(t)}(t,e,r)},u.allocUnsafe=function(t){return a(t)},u.allocUnsafeSlow=function(t){return a(t)},u.isBuffer=function(t){return null!=t&&!0===t._isBuffer&&t!==u.prototype},u.compare=function(t,e){if(J(t,Uint8Array)&&(t=u.from(t,t.offset,t.byteLength)),J(e,Uint8Array)&&(e=u.from(e,e.offset,e.byteLength)),!u.isBuffer(t)||!u.isBuffer(e))throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');if(t===e)return 0;let r=t.length,n=e.length;for(let i=0,o=Math.min(r,n);i<o;++i)if(t[i]!==e[i]){r=t[i],n=e[i];break}return r<n?-1:n<r?1:0},u.isEncoding=function(t){switch(String(t).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},u.concat=function(t,e){if(!Array.isArray(t))throw new TypeError('"list" argument must be an Array of Buffers');if(0===t.length)return u.alloc(0);let r;if(void 0===e)for(e=0,r=0;r<t.length;++r)e+=t[r].length;const n=u.allocUnsafe(e);let i=0;for(r=0;r<t.length;++r){let e=t[r];if(J(e,Uint8Array))i+e.length>n.length?(u.isBuffer(e)||(e=u.from(e)),e.copy(n,i)):Uint8Array.prototype.set.call(n,e,i);else{if(!u.isBuffer(e))throw new TypeError('"list" argument must be an Array of Buffers');e.copy(n,i)}i+=e.length}return n},u.byteLength=y,u.prototype._isBuffer=!0,u.prototype.swap16=function(){const t=this.length;if(t%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let e=0;e<t;e+=2)d(this,e,e+1);return this},u.prototype.swap32=function(){const t=this.length;if(t%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(let e=0;e<t;e+=4)d(this,e,e+3),d(this,e+1,e+2);return this},u.prototype.swap64=function(){const t=this.length;if(t%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(let e=0;e<t;e+=8)d(this,e,e+7),d(this,e+1,e+6),d(this,e+2,e+5),d(this,e+3,e+4);return this},u.prototype.toString=function(){const t=this.length;return 0===t?"":0===arguments.length?R(this,0,t):w.apply(this,arguments)},u.prototype.toLocaleString=u.prototype.toString,u.prototype.equals=function(t){if(!u.isBuffer(t))throw new TypeError("Argument must be a Buffer");return this===t||0===u.compare(this,t)},u.prototype.inspect=function(){let e="";const r=t.INSPECT_MAX_BYTES;return e=this.toString("hex",0,r).replace(/(.{2})/g,"$1 ").trim(),this.length>r&&(e+=" ... "),"<Buffer "+e+">"},o&&(u.prototype[o]=u.prototype.inspect),u.prototype.compare=function(t,e,r,n,i){if(J(t,Uint8Array)&&(t=u.from(t,t.offset,t.byteLength)),!u.isBuffer(t))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof t);if(void 0===e&&(e=0),void 0===r&&(r=t?t.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),e<0||r>t.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&e>=r)return 0;if(n>=i)return-1;if(e>=r)return 1;if(this===t)return 0;let o=(i>>>=0)-(n>>>=0),f=(r>>>=0)-(e>>>=0);const s=Math.min(o,f),h=this.slice(n,i),c=t.slice(e,r);for(let t=0;t<s;++t)if(h[t]!==c[t]){o=h[t],f=c[t];break}return o<f?-1:f<o?1:0},u.prototype.includes=function(t,e,r){return-1!==this.indexOf(t,e,r)},u.prototype.indexOf=function(t,e,r){return b(this,t,e,r,!0)},u.prototype.lastIndexOf=function(t,e,r){return b(this,t,e,r,!1)},u.prototype.write=function(t,e,r,n){if(void 0===e)n="utf8",r=this.length,e=0;else if(void 0===r&&"string"==typeof e)n=e,r=this.length,e=0;else{if(!isFinite(e))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");e>>>=0,isFinite(r)?(r>>>=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}const i=this.length-e;if((void 0===r||r>i)&&(r=i),t.length>0&&(r<0||e<0)||e>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");let o=!1;for(;;)switch(n){case"hex":return E(this,t,e,r);case"utf8":case"utf-8":return m(this,t,e,r);case"ascii":case"latin1":case"binary":return I(this,t,e,r);case"base64":return U(this,t,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return A(this,t,e,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}},u.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};const T=4096;function O(t,e,r){let n="";r=Math.min(t.length,r);for(let i=e;i<r;++i)n+=String.fromCharCode(127&t[i]);return n}function _(t,e,r){let n="";r=Math.min(t.length,r);for(let i=e;i<r;++i)n+=String.fromCharCode(t[i]);return n}function L(t,e,r){const n=t.length;(!e||e<0)&&(e=0),(!r||r<0||r>n)&&(r=n);let i="";for(let n=e;n<r;++n)i+=H[t[n]];return i}function S(t,e,r){const n=t.slice(e,r);let i="";for(let t=0;t<n.length-1;t+=2)i+=String.fromCharCode(n[t]+256*n[t+1]);return i}function x(t,e,r){if(t%1!=0||t<0)throw new RangeError("offset is not uint");if(t+e>r)throw new RangeError("Trying to access beyond buffer length")}function $(t,e,r,n,i,o){if(!u.isBuffer(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>i||e<o)throw new RangeError('"value" argument is out of bounds');if(r+n>t.length)throw new RangeError("Index out of range")}function P(t,e,r,n,i){z(e,n,i,t,r,7);let o=Number(e&BigInt(4294967295));t[r++]=o,o>>=8,t[r++]=o,o>>=8,t[r++]=o,o>>=8,t[r++]=o;let f=Number(e>>BigInt(32)&BigInt(4294967295));return t[r++]=f,f>>=8,t[r++]=f,f>>=8,t[r++]=f,f>>=8,t[r++]=f,r}function C(t,e,r,n,i){z(e,n,i,t,r,7);let o=Number(e&BigInt(4294967295));t[r+7]=o,o>>=8,t[r+6]=o,o>>=8,t[r+5]=o,o>>=8,t[r+4]=o;let f=Number(e>>BigInt(32)&BigInt(4294967295));return t[r+3]=f,f>>=8,t[r+2]=f,f>>=8,t[r+1]=f,f>>=8,t[r]=f,r+8}function j(t,e,r,n,i,o){if(r+n>t.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function N(t,e,r,n,o){return e=+e,r>>>=0,o||j(t,0,r,4),i.write(t,e,r,n,23,4),r+4}function k(t,e,r,n,o){return e=+e,r>>>=0,o||j(t,0,r,8),i.write(t,e,r,n,52,8),r+8}u.prototype.slice=function(t,e){const r=this.length;(t=~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),(e=void 0===e?r:~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),e<t&&(e=t);const n=this.subarray(t,e);return Object.setPrototypeOf(n,u.prototype),n},u.prototype.readUintLE=u.prototype.readUIntLE=function(t,e,r){t>>>=0,e>>>=0,r||x(t,e,this.length);let n=this[t],i=1,o=0;for(;++o<e&&(i*=256);)n+=this[t+o]*i;return n},u.prototype.readUintBE=u.prototype.readUIntBE=function(t,e,r){t>>>=0,e>>>=0,r||x(t,e,this.length);let n=this[t+--e],i=1;for(;e>0&&(i*=256);)n+=this[t+--e]*i;return n},u.prototype.readUint8=u.prototype.readUInt8=function(t,e){return t>>>=0,e||x(t,1,this.length),this[t]},u.prototype.readUint16LE=u.prototype.readUInt16LE=function(t,e){return t>>>=0,e||x(t,2,this.length),this[t]|this[t+1]<<8},u.prototype.readUint16BE=u.prototype.readUInt16BE=function(t,e){return t>>>=0,e||x(t,2,this.length),this[t]<<8|this[t+1]},u.prototype.readUint32LE=u.prototype.readUInt32LE=function(t,e){return t>>>=0,e||x(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},u.prototype.readUint32BE=u.prototype.readUInt32BE=function(t,e){return t>>>=0,e||x(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},u.prototype.readBigUInt64LE=K((function(t){q(t>>>=0,"offset");const e=this[t],r=this[t+7];void 0!==e&&void 0!==r||Y(t,this.length-8);const n=e+256*this[++t]+65536*this[++t]+this[++t]*2**24,i=this[++t]+256*this[++t]+65536*this[++t]+r*2**24;return BigInt(n)+(BigInt(i)<<BigInt(32))})),u.prototype.readBigUInt64BE=K((function(t){q(t>>>=0,"offset");const e=this[t],r=this[t+7];void 0!==e&&void 0!==r||Y(t,this.length-8);const n=e*2**24+65536*this[++t]+256*this[++t]+this[++t],i=this[++t]*2**24+65536*this[++t]+256*this[++t]+r;return(BigInt(n)<<BigInt(32))+BigInt(i)})),u.prototype.readIntLE=function(t,e,r){t>>>=0,e>>>=0,r||x(t,e,this.length);let n=this[t],i=1,o=0;for(;++o<e&&(i*=256);)n+=this[t+o]*i;return i*=128,n>=i&&(n-=Math.pow(2,8*e)),n},u.prototype.readIntBE=function(t,e,r){t>>>=0,e>>>=0,r||x(t,e,this.length);let n=e,i=1,o=this[t+--n];for(;n>0&&(i*=256);)o+=this[t+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*e)),o},u.prototype.readInt8=function(t,e){return t>>>=0,e||x(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},u.prototype.readInt16LE=function(t,e){t>>>=0,e||x(t,2,this.length);const r=this[t]|this[t+1]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt16BE=function(t,e){t>>>=0,e||x(t,2,this.length);const r=this[t+1]|this[t]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt32LE=function(t,e){return t>>>=0,e||x(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},u.prototype.readInt32BE=function(t,e){return t>>>=0,e||x(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},u.prototype.readBigInt64LE=K((function(t){q(t>>>=0,"offset");const e=this[t],r=this[t+7];void 0!==e&&void 0!==r||Y(t,this.length-8);const n=this[t+4]+256*this[t+5]+65536*this[t+6]+(r<<24);return(BigInt(n)<<BigInt(32))+BigInt(e+256*this[++t]+65536*this[++t]+this[++t]*2**24)})),u.prototype.readBigInt64BE=K((function(t){q(t>>>=0,"offset");const e=this[t],r=this[t+7];void 0!==e&&void 0!==r||Y(t,this.length-8);const n=(e<<24)+65536*this[++t]+256*this[++t]+this[++t];return(BigInt(n)<<BigInt(32))+BigInt(this[++t]*2**24+65536*this[++t]+256*this[++t]+r)})),u.prototype.readFloatLE=function(t,e){return t>>>=0,e||x(t,4,this.length),i.read(this,t,!0,23,4)},u.prototype.readFloatBE=function(t,e){return t>>>=0,e||x(t,4,this.length),i.read(this,t,!1,23,4)},u.prototype.readDoubleLE=function(t,e){return t>>>=0,e||x(t,8,this.length),i.read(this,t,!0,52,8)},u.prototype.readDoubleBE=function(t,e){return t>>>=0,e||x(t,8,this.length),i.read(this,t,!1,52,8)},u.prototype.writeUintLE=u.prototype.writeUIntLE=function(t,e,r,n){if(t=+t,e>>>=0,r>>>=0,!n){$(this,t,e,r,Math.pow(2,8*r)-1,0)}let i=1,o=0;for(this[e]=255&t;++o<r&&(i*=256);)this[e+o]=t/i&255;return e+r},u.prototype.writeUintBE=u.prototype.writeUIntBE=function(t,e,r,n){if(t=+t,e>>>=0,r>>>=0,!n){$(this,t,e,r,Math.pow(2,8*r)-1,0)}let i=r-1,o=1;for(this[e+i]=255&t;--i>=0&&(o*=256);)this[e+i]=t/o&255;return e+r},u.prototype.writeUint8=u.prototype.writeUInt8=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,1,255,0),this[e]=255&t,e+1},u.prototype.writeUint16LE=u.prototype.writeUInt16LE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,2,65535,0),this[e]=255&t,this[e+1]=t>>>8,e+2},u.prototype.writeUint16BE=u.prototype.writeUInt16BE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,2,65535,0),this[e]=t>>>8,this[e+1]=255&t,e+2},u.prototype.writeUint32LE=u.prototype.writeUInt32LE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,4,4294967295,0),this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t,e+4},u.prototype.writeUint32BE=u.prototype.writeUInt32BE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,4,4294967295,0),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},u.prototype.writeBigUInt64LE=K((function(t,e=0){return P(this,t,e,BigInt(0),BigInt("0xffffffffffffffff"))})),u.prototype.writeBigUInt64BE=K((function(t,e=0){return C(this,t,e,BigInt(0),BigInt("0xffffffffffffffff"))})),u.prototype.writeIntLE=function(t,e,r,n){if(t=+t,e>>>=0,!n){const n=Math.pow(2,8*r-1);$(this,t,e,r,n-1,-n)}let i=0,o=1,f=0;for(this[e]=255&t;++i<r&&(o*=256);)t<0&&0===f&&0!==this[e+i-1]&&(f=1),this[e+i]=(t/o|0)-f&255;return e+r},u.prototype.writeIntBE=function(t,e,r,n){if(t=+t,e>>>=0,!n){const n=Math.pow(2,8*r-1);$(this,t,e,r,n-1,-n)}let i=r-1,o=1,f=0;for(this[e+i]=255&t;--i>=0&&(o*=256);)t<0&&0===f&&0!==this[e+i+1]&&(f=1),this[e+i]=(t/o|0)-f&255;return e+r},u.prototype.writeInt8=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,1,127,-128),t<0&&(t=255+t+1),this[e]=255&t,e+1},u.prototype.writeInt16LE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,2,32767,-32768),this[e]=255&t,this[e+1]=t>>>8,e+2},u.prototype.writeInt16BE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,2,32767,-32768),this[e]=t>>>8,this[e+1]=255&t,e+2},u.prototype.writeInt32LE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,4,2147483647,-2147483648),this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24,e+4},u.prototype.writeInt32BE=function(t,e,r){return t=+t,e>>>=0,r||$(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},u.prototype.writeBigInt64LE=K((function(t,e=0){return P(this,t,e,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))})),u.prototype.writeBigInt64BE=K((function(t,e=0){return C(this,t,e,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))})),u.prototype.writeFloatLE=function(t,e,r){return N(this,t,e,!0,r)},u.prototype.writeFloatBE=function(t,e,r){return N(this,t,e,!1,r)},u.prototype.writeDoubleLE=function(t,e,r){return k(this,t,e,!0,r)},u.prototype.writeDoubleBE=function(t,e,r){return k(this,t,e,!1,r)},u.prototype.copy=function(t,e,r,n){if(!u.isBuffer(t))throw new TypeError("argument should be a Buffer");if(r||(r=0),n||0===n||(n=this.length),e>=t.length&&(e=t.length),e||(e=0),n>0&&n<r&&(n=r),n===r)return 0;if(0===t.length||0===this.length)return 0;if(e<0)throw new RangeError("targetStart out of bounds");if(r<0||r>=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),t.length-e<n-r&&(n=t.length-e+r);const i=n-r;return this===t&&"function"==typeof Uint8Array.prototype.copyWithin?this.copyWithin(e,r,n):Uint8Array.prototype.set.call(t,this.subarray(r,n),e),i},u.prototype.fill=function(t,e,r,n){if("string"==typeof t){if("string"==typeof e?(n=e,e=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!u.isEncoding(n))throw new TypeError("Unknown encoding: "+n);if(1===t.length){const e=t.charCodeAt(0);("utf8"===n&&e<128||"latin1"===n)&&(t=e)}}else"number"==typeof t?t&=255:"boolean"==typeof t&&(t=Number(t));if(e<0||this.length<e||this.length<r)throw new RangeError("Out of range index");if(r<=e)return this;let i;if(e>>>=0,r=void 0===r?this.length:r>>>0,t||(t=0),"number"==typeof t)for(i=e;i<r;++i)this[i]=t;else{const o=u.isBuffer(t)?t:u.from(t,n),f=o.length;if(0===f)throw new TypeError('The value "'+t+'" is invalid for argument "value"');for(i=0;i<r-e;++i)this[i+e]=o[i%f]}return this};const F={};function M(t,e,r){F[t]=class extends r{constructor(){super(),Object.defineProperty(this,"message",{value:e.apply(this,arguments),writable:!0,configurable:!0}),this.name=`${this.name} [${t}]`,delete this.name}get code(){return t}set code(t){Object.defineProperty(this,"code",{configurable:!0,enumerable:!0,value:t,writable:!0})}toString(){return`${this.name} [${t}]: ${this.message}`}}}function D(t){let e="",r=t.length;const n="-"===t[0]?1:0;for(;r>=n+4;r-=3)e=`_${t.slice(r-3,r)}${e}`;return`${t.slice(0,r)}${e}`}function z(t,e,r,n,i,o){if(t>r||t<e){const r="bigint"==typeof e?"n":"";let n;throw n=0===e||e===BigInt(0)?`>= 0${r} and < 2${r} ** ${8*(o+1)}${r}`:`>= -(2${r} ** ${8*(o+1)-1}${r}) and < 2 ** ${8*(o+1)-1}${r}`,new F.ERR_OUT_OF_RANGE("value",n,t)}!function(t,e,r){q(e,"offset"),void 0!==t[e]&&void 0!==t[e+r]||Y(e,t.length-(r+1))}(n,i,o)}function q(t,e){if("number"!=typeof t)throw new F.ERR_INVALID_ARG_TYPE(e,"number",t)}function Y(t,e,r){if(Math.floor(t)!==t)throw q(t,r),new F.ERR_OUT_OF_RANGE("offset","an integer",t);if(e<0)throw new F.ERR_BUFFER_OUT_OF_BOUNDS;throw new F.ERR_OUT_OF_RANGE("offset",`>= 0 and <= ${e}`,t)}M("ERR_BUFFER_OUT_OF_BOUNDS",(function(t){return t?`${t} is outside of buffer bounds`:"Attempt to access memory outside buffer bounds"}),RangeError),M("ERR_INVALID_ARG_TYPE",(function(t,e){return`The "${t}" argument must be of type number. Received type ${typeof e}`}),TypeError),M("ERR_OUT_OF_RANGE",(function(t,e,r){let n=`The value of "${t}" is out of range.`,i=r;return Number.isInteger(r)&&Math.abs(r)>2**32?i=D(String(r)):"bigint"==typeof r&&(i=String(r),(r>BigInt(2)**BigInt(32)||r<-(BigInt(2)**BigInt(32)))&&(i=D(i)),i+="n"),n+=` It must be ${e}. Received ${i}`,n}),RangeError);const G=/[^+/0-9A-Za-z-_]/g;function V(t,e){let r;e=e||1/0;const n=t.length;let i=null;const o=[];for(let f=0;f<n;++f){if(r=t.charCodeAt(f),r>55295&&r<57344){if(!i){if(r>56319){(e-=3)>-1&&o.push(239,191,189);continue}if(f+1===n){(e-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(e-=3)>-1&&o.push(239,191,189),i=r;continue}r=65536+(i-55296<<10|r-56320)}else i&&(e-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((e-=1)<0)break;o.push(r)}else if(r<2048){if((e-=2)<0)break;o.push(r>>6|192,63&r|128)}else if(r<65536){if((e-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((e-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function W(t){return n.toByteArray(function(t){if((t=(t=t.split("=")[0]).trim().replace(G,"")).length<2)return"";for(;t.length%4!=0;)t+="=";return t}(t))}function X(t,e,r,n){let i;for(i=0;i<n&&!(i+r>=e.length||i>=t.length);++i)e[i+r]=t[i];return i}function J(t,e){return t instanceof e||null!=t&&null!=t.constructor&&null!=t.constructor.name&&t.constructor.name===e.name}function Z(t){return t!=t}const H=function(){const t="0123456789abcdef",e=new Array(256);for(let r=0;r<16;++r){const n=16*r;for(let i=0;i<16;++i)e[n+i]=t[r]+t[i]}return e}();function K(t){return"undefined"==typeof BigInt?Q:t}function Q(){throw new Error("BigInt not supported")}}(t.__exports);
+//# sourceMappingURL=index.js.map