{"version":3,"file":"index.cjs","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}\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}\nexport const assertNumber = anumber;\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.\n */\nexport const base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\nexport const base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));\nexport const base32nopad = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));\nexport const base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));\nexport const base32hexnopad = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));\nexport const base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));\n/**\n * base64 with padding. For no padding, use `base64nopad`.\n * @example\n * const b = base64.decode('A951'); // Uint8Array.from([ 3, 222, 117 ])\n * base64.encode(b); // 'A951'\n */\nexport const base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));\n/**\n * base64 without padding.\n */\nexport const base64nopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));\nexport const base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));\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 characters +, /, 0, O, I, l.\n * Quadratic (O(n^2)) - so, can't be used on large inputs.\n */\nexport const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');\nexport const base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');\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 * XMR version of 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};\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 * Low-level bech32 operations. Operates on words.\n */\nexport const bech32 = genBech32('bech32');\nexport const bech32m = genBech32('bech32m');\n/**\n * UTF-8-to-byte decoder. Uses built-in TextDecoder / TextEncoder.\n * @example\n * const b = utf8.decode(\"hey\"); // => new Uint8Array([ 104, 101, 121 ])\n * const str = utf8.encode(b); // \"hey\"\n */\nexport const utf8 = {\n    encode: (data) => new TextDecoder().decode(data),\n    decode: (str) => new TextEncoder().encode(str),\n};\n/**\n * hex string decoder.\n * @example\n * const b = hex.decode(\"0102ff\"); // => new Uint8Array([ 1, 2, 255 ])\n * const str = hex.encode(b); // \"0102ff\"\n */\nexport const hex = 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';\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};\nexport const str = bytesToString; // as in python, but for bytes only\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};\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","bech32","encoding","ENCODING_CONST","_words","bits","revPadding","bytes","radix2","fromWords","toWords","fromWordsUnsafe","limit","plen","TypeError","actualLength","lowered","toLowerCase","sum","str","slen","toUpperCase","sepIndex","lastIndexOf","slice","endsWith","encodeFromBytes","decodeToBytes","decodeUnsafe","genBech32"],"mappings":"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","x_google_ignoreList":[0]}