@blockend/widget 1.0.30 → 1.0.31

package/dist/secp256k1-CBD0agkt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secp256k1-CBD0agkt.js","sources":["../node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js","../node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js","../node_modules/viem/node_modules/@noble/curves/esm/abstract/curve.js","../node_modules/viem/node_modules/@noble/curves/esm/abstract/weierstrass.js","../node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js","../node_modules/viem/node_modules/@noble/curves/esm/secp256k1.js"],"sourcesContent":["/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\nexport function abytes(item) {\n    if (!isBytes(item))\n        throw new Error('Uint8Array expected');\n}\nexport function abool(title, value) {\n    if (typeof value !== 'boolean')\n        throw new Error(title + ' boolean expected, got ' + value);\n}\n// Used in weierstrass, der\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? '0' + hex : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function';\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    abytes(bytes);\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n        }\n    }\n    else if (isBytes(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(title + ' must be hex string or Uint8Array');\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Is positive bigint\nconst isPosBig = (n) => typeof n === 'bigint' && _0n <= n;\nexport function inRange(n, min, max) {\n    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title, n, min, max) {\n    // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n    // consider P=256n, min=0n, max=P\n    // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n    // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n    // - our way is the cleanest:               `inRange('x', x, 0n, P)\n    if (!inRange(n, min, max))\n        throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n * TODO: merge with nLength in modular\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n, pos, value) {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_1n << BigInt(n)) - _1n;\n// DRBG\nconst u8n = (len) => new Uint8Array(len); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n(0)) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error('invalid validator function');\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n/**\n * throws not implemented error\n */\nexport const notImplemented = () => {\n    throw new Error('not implemented');\n};\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized(fn) {\n    const map = new WeakMap();\n    return (arg, ...args) => {\n        const val = map.get(arg);\n        if (val !== undefined)\n            return val;\n        const computed = fn(arg, ...args);\n        map.set(arg, computed);\n        return computed;\n    };\n}\n//# sourceMappingURL=utils.js.map","/**\n * Utils for modular division and finite fields.\n * A finite field over 11 is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { anumber } from '@noble/hashes/utils';\nimport { bitMask, bytesToNumberBE, bytesToNumberLE, ensureBytes, numberToBytesBE, numberToBytesLE, validateObject, } from \"./utils.js\";\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);\n// prettier-ignore\nconst _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * TODO: remove.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num, power, modulo) {\n    return FpPow(Field(modulo), num, power);\n}\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number, modulo) {\n    if (number === _0n)\n        throw new Error('invert: expected non-zero number');\n    if (modulo <= _0n)\n        throw new Error('invert: expected positive modulus, got ' + modulo);\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n// Not all roots are possible! Example which will throw:\n// const NUM =\n// n = 72057594037927816n;\n// Fp = Field(BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'));\nfunction sqrt3mod4(Fp, n) {\n    const p1div4 = (Fp.ORDER + _1n) / _4n;\n    const root = Fp.pow(n, p1div4);\n    // Throw if root^2 != n\n    if (!Fp.eql(Fp.sqr(root), n))\n        throw new Error('Cannot find square root');\n    return root;\n}\nfunction sqrt5mod8(Fp, n) {\n    const p5div8 = (Fp.ORDER - _5n) / _8n;\n    const n2 = Fp.mul(n, _2n);\n    const v = Fp.pow(n2, p5div8);\n    const nv = Fp.mul(n, v);\n    const i = Fp.mul(Fp.mul(nv, _2n), v);\n    const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n    if (!Fp.eql(Fp.sqr(root), n))\n        throw new Error('Cannot find square root');\n    return root;\n}\n// TODO: Commented-out for now. Provide test vectors.\n// Tonelli is too slow for extension fields Fp2.\n// That means we can't use sqrt (c1, c2...) even for initialization constants.\n// if (P % _16n === _9n) return sqrt9mod16;\n// // prettier-ignore\n// function sqrt9mod16<T>(Fp: IField<T>, n: T, p7div16?: bigint) {\n//   if (p7div16 === undefined) p7div16 = (Fp.ORDER + BigInt(7)) / _16n;\n//   const c1 = Fp.sqrt(Fp.neg(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n//   const c2 = Fp.sqrt(c1);             //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n//   const c3 = Fp.sqrt(Fp.neg(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n//   const c4 = p7div16;                 //  4. c4 = (q + 7) / 16        # Integer arithmetic\n//   let tv1 = Fp.pow(n, c4);            //  1. tv1 = x^c4\n//   let tv2 = Fp.mul(c1, tv1);          //  2. tv2 = c1 * tv1\n//   const tv3 = Fp.mul(c2, tv1);        //  3. tv3 = c2 * tv1\n//   let tv4 = Fp.mul(c3, tv1);          //  4. tv4 = c3 * tv1\n//   const e1 = Fp.eql(Fp.sqr(tv2), n);  //  5.  e1 = (tv2^2) == x\n//   const e2 = Fp.eql(Fp.sqr(tv3), n);  //  6.  e2 = (tv3^2) == x\n//   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n//   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n//   const e3 = Fp.eql(Fp.sqr(tv2), n);  //  9.  e3 = (tv2^2) == x\n//   return Fp.cmov(tv1, tv2, e3); // 10.  z = CMOV(tv1, tv2, e3) # Select the sqrt from tv1 and tv2\n// }\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Initialization (precomputation).\n    if (P < BigInt(3))\n        throw new Error('sqrt is not defined for small field');\n    // Factor P - 1 = Q * 2^S, where Q is odd\n    let Q = P - _1n;\n    let S = 0;\n    while (Q % _2n === _0n) {\n        Q /= _2n;\n        S++;\n    }\n    // Find the first quadratic non-residue Z >= 2\n    let Z = _2n;\n    const _Fp = Field(P);\n    while (FpLegendre(_Fp, Z) === 1) {\n        // Basic primality test for P. After x iterations, chance of\n        // not finding quadratic non-residue is 2^x, so 2^1000.\n        if (Z++ > 1000)\n            throw new Error('Cannot find square root: probably non-prime P');\n    }\n    // Fast-path; usually done before Z, but we do \"primality test\".\n    if (S === 1)\n        return sqrt3mod4;\n    // Slow-path\n    // TODO: test on Fp2 and others\n    let cc = _Fp.pow(Z, Q); // c = z^Q\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        if (Fp.is0(n))\n            return n;\n        // Check if n is a quadratic residue using Legendre symbol\n        if (FpLegendre(Fp, n) !== 1)\n            throw new Error('Cannot find square root');\n        // Initialize variables for the main loop\n        let M = S;\n        let c = Fp.mul(Fp.ONE, cc); // c = z^Q, move cc from field _Fp into field Fp\n        let t = Fp.pow(n, Q); // t = n^Q, first guess at the fudge factor\n        let R = Fp.pow(n, Q1div2); // R = n^((Q+1)/2), first guess at the square root\n        // Main loop\n        // while t != 1\n        while (!Fp.eql(t, Fp.ONE)) {\n            if (Fp.is0(t))\n                return Fp.ZERO; // if t=0 return R=0\n            let i = 1;\n            // Find the smallest i >= 1 such that t^(2^i) ≡ 1 (mod P)\n            let t_tmp = Fp.sqr(t); // t^(2^1)\n            while (!Fp.eql(t_tmp, Fp.ONE)) {\n                i++;\n                t_tmp = Fp.sqr(t_tmp); // t^(2^2)...\n                if (i === M)\n                    throw new Error('Cannot find square root');\n            }\n            // Calculate the exponent for b: 2^(M - i - 1)\n            const exponent = _1n << BigInt(M - i - 1); // bigint is important\n            const b = Fp.pow(c, exponent); // b = 2^(M - i - 1)\n            // Update variables\n            M = i;\n            c = Fp.sqr(b); // c = b^2\n            t = Fp.mul(t, c); // t = (t * b^2)\n            R = Fp.mul(R, b); // R = R*b\n        }\n        return R;\n    };\n}\n/**\n * Square root for a finite field. Will try optimized versions first:\n *\n * 1. P ≡ 3 (mod 4)\n * 2. P ≡ 5 (mod 8)\n * 3. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P) {\n    // P ≡ 3 (mod 4) => √n = n^((P+1)/4)\n    if (P % _4n === _3n)\n        return sqrt3mod4;\n    // P ≡ 5 (mod 8) => Atkin algorithm, page 10 of https://eprint.iacr.org/2012/685.pdf\n    if (P % _8n === _5n)\n        return sqrt5mod8;\n    // P ≡ 9 (mod 16) not implemented, see above\n    // Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(Fp, num, power) {\n    if (power < _0n)\n        throw new Error('invalid exponent, negatives unsupported');\n    if (power === _0n)\n        return Fp.ONE;\n    if (power === _1n)\n        return num;\n    let p = Fp.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = Fp.mul(p, d);\n        d = Fp.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * Exception-free. Will return `undefined` for 0 elements.\n * @param passZero map 0 to 0 (instead of undefined)\n */\nexport function FpInvertBatch(Fp, nums, passZero = false) {\n    const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);\n    // Walk from first to last, multiply them by each other MOD p\n    const multipliedAcc = nums.reduce((acc, num, i) => {\n        if (Fp.is0(num))\n            return acc;\n        inverted[i] = acc;\n        return Fp.mul(acc, num);\n    }, Fp.ONE);\n    // Invert last element\n    const invertedAcc = Fp.inv(multipliedAcc);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (Fp.is0(num))\n            return acc;\n        inverted[i] = Fp.mul(acc, inverted[i]);\n        return Fp.mul(acc, num);\n    }, invertedAcc);\n    return inverted;\n}\n// TODO: remove\nexport function FpDiv(Fp, lhs, rhs) {\n    return Fp.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, Fp.ORDER) : Fp.inv(rhs));\n}\n/**\n * Legendre symbol.\n * Legendre constant is used to calculate Legendre symbol (a | p)\n * which denotes the value of a^((p-1)/2) (mod p).\n *\n * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue\n * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue\n * * (a | p) ≡ 0    if a ≡ 0 (mod p)\n */\nexport function FpLegendre(Fp, n) {\n    // We can use 3rd argument as optional cache of this value\n    // but seems unneeded for now. The operation is very fast.\n    const p1mod2 = (Fp.ORDER - _1n) / _2n;\n    const powered = Fp.pow(n, p1mod2);\n    const yes = Fp.eql(powered, Fp.ONE);\n    const zero = Fp.eql(powered, Fp.ZERO);\n    const no = Fp.eql(powered, Fp.neg(Fp.ONE));\n    if (!yes && !zero && !no)\n        throw new Error('invalid Legendre symbol result');\n    return yes ? 1 : zero ? 0 : -1;\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(Fp, n) {\n    const l = FpLegendre(Fp, n);\n    return l === 1;\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    if (nBitLength !== undefined)\n        anumber(nBitLength);\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n    let sqrtP; // cached sqrtP\n    const f = Object.freeze({\n        ORDER,\n        isLE,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error('invalid field element: expected bigint, got ' + typeof num);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt ||\n            ((n) => {\n                if (!sqrtP)\n                    sqrtP = FpSqrt(ORDER);\n                return sqrtP(f, n);\n            }),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n        // TODO: we don't need it here, move out to separate fn\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // We can't move this out because Fp6, Fp12 implement it\n        // and it's unclear what to return in there.\n        cmov: (a, b, c) => (c ? b : a),\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use `mapKeyToField` instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error('hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n    const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { nLength, validateField } from \"./modular.js\";\nimport { bitLen, bitMask, validateObject } from \"./utils.js\";\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nfunction constTimeNegate(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\n}\nfunction validateW(W, bits) {\n    if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n        throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\nfunction calcWOpts(W, scalarBits) {\n    validateW(W, scalarBits);\n    const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n    const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n    const maxNumber = 2 ** W; // W=8 256\n    const mask = bitMask(W); // W=8 255 == mask 0b11111111\n    const shiftBy = BigInt(W); // W=8 8\n    return { windows, windowSize, mask, maxNumber, shiftBy };\n}\nfunction calcOffsets(n, window, wOpts) {\n    const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n    let wbits = Number(n & mask); // extract W bits.\n    let nextN = n >> shiftBy; // shift number by W bits.\n    // What actually happens here:\n    // const highestBit = Number(mask ^ (mask >> 1n));\n    // let wbits2 = wbits - 1; // skip zero\n    // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n    // split if bits > max: +224 => 256-32\n    if (wbits > windowSize) {\n        // we skip zero, which means instead of `>= size-1`, we do `> size`\n        wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n        nextN += _1n; // +256 (carry)\n    }\n    const offsetStart = window * windowSize;\n    const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n    const isZero = wbits === 0; // is current window slice a 0?\n    const isNeg = wbits < 0; // is current window slice negative?\n    const isNegF = window % 2 !== 0; // fake random statement for noise\n    const offsetF = offsetStart; // fake offset for noise\n    return { nextN, offset, isZero, isNeg, isNegF, offsetF };\n}\nfunction validateMSMPoints(points, c) {\n    if (!Array.isArray(points))\n        throw new Error('array expected');\n    points.forEach((p, i) => {\n        if (!(p instanceof c))\n            throw new Error('invalid point at index ' + i);\n    });\n}\nfunction validateMSMScalars(scalars, field) {\n    if (!Array.isArray(scalars))\n        throw new Error('array of scalars expected');\n    scalars.forEach((s, i) => {\n        if (!field.isValid(s))\n            throw new Error('invalid scalar at index ' + i);\n    });\n}\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap();\nfunction getW(P) {\n    return pointWindowSizes.get(P) || 1;\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport function wNAF(c, bits) {\n    return {\n        constTimeNegate,\n        hasPrecomputes(elm) {\n            return getW(elm) !== 1;\n        },\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n, p = c.ZERO) {\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @param elm Point instance\n         * @param W window size\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = calcWOpts(W, bits);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // i=1, bc we skip 0\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // Smaller version:\n            // https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n            // TODO: check the scalar is less than group order?\n            // wNAF behavior is undefined otherwise. But have to carefully remove\n            // other checks before wNAF. ORDER == bits here.\n            // Accumulators\n            let p = c.ZERO;\n            let f = c.BASE;\n            // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n            // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n            // there is negate now: it is possible that negated element from low value\n            // would be the same as high element, which will create carry into next window.\n            // It's not obvious how this can fail, but still worth investigating later.\n            const wo = calcWOpts(W, bits);\n            for (let window = 0; window < wo.windows; window++) {\n                // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n                const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n                n = nextN;\n                if (isZero) {\n                    // bits are 0: add garbage to fake point\n                    // Important part for const-time getPublicKey: add random \"noise\" point to f.\n                    f = f.add(constTimeNegate(isNegF, precomputes[offsetF]));\n                }\n                else {\n                    // bits are 1: add to result point\n                    p = p.add(constTimeNegate(isNeg, precomputes[offset]));\n                }\n            }\n            // Return both real and fake points: JIT won't eliminate f.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        /**\n         * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @param acc accumulator point to add result of multiplication\n         * @returns point\n         */\n        wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {\n            const wo = calcWOpts(W, bits);\n            for (let window = 0; window < wo.windows; window++) {\n                if (n === _0n)\n                    break; // Early-exit, skip 0 value\n                const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n                n = nextN;\n                if (isZero) {\n                    // Window bits are 0: skip processing.\n                    // Move to next window.\n                    continue;\n                }\n                else {\n                    const item = precomputes[offset];\n                    acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n                }\n            }\n            return acc;\n        },\n        getPrecomputes(W, P, transform) {\n            // Calculate precomputes on a first run, reuse them after\n            let comp = pointPrecomputes.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1)\n                    pointPrecomputes.set(P, transform(comp));\n            }\n            return comp;\n        },\n        wNAFCached(P, n, transform) {\n            const W = getW(P);\n            return this.wNAF(W, this.getPrecomputes(W, P, transform), n);\n        },\n        wNAFCachedUnsafe(P, n, transform, prev) {\n            const W = getW(P);\n            if (W === 1)\n                return this.unsafeLadder(P, n, prev); // For W=1 ladder is ~x2 faster\n            return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);\n        },\n        // We calculate precomputes for elliptic curve point multiplication\n        // using windowed method. This specifies window size and\n        // stores precomputed values. Usually only base point would be precomputed.\n        setWindowSize(P, W) {\n            validateW(W, bits);\n            pointWindowSizes.set(P, W);\n            pointPrecomputes.delete(P);\n        },\n    };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka private keys / bigints)\n */\nexport function pippenger(c, fieldN, points, scalars) {\n    // If we split scalars by some window (let's say 8 bits), every chunk will only\n    // take 256 buckets even if there are 4096 scalars, also re-uses double.\n    // TODO:\n    // - https://eprint.iacr.org/2024/750.pdf\n    // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n    // 0 is accepted in scalars\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    const plength = points.length;\n    const slength = scalars.length;\n    if (plength !== slength)\n        throw new Error('arrays of points and scalars must have equal length');\n    // if (plength === 0) throw new Error('array must be of length >= 2');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(plength));\n    let windowSize = 1; // bits\n    if (wbits > 12)\n        windowSize = wbits - 3;\n    else if (wbits > 4)\n        windowSize = wbits - 2;\n    else if (wbits > 0)\n        windowSize = 2;\n    const MASK = bitMask(windowSize);\n    const buckets = new Array(Number(MASK) + 1).fill(zero); // +1 for zero array\n    const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n    let sum = zero;\n    for (let i = lastBits; i >= 0; i -= windowSize) {\n        buckets.fill(zero);\n        for (let j = 0; j < slength; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & MASK);\n            buckets[wbits] = buckets[wbits].add(points[j]);\n        }\n        let resI = zero; // not using this will do small speed-up, but will lose ct\n        // Skip first bucket, because it is zero\n        for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n            sumI = sumI.add(buckets[j]);\n            resI = resI.add(sumI);\n        }\n        sum = sum.add(resI);\n        if (i !== 0)\n            for (let j = 0; j < windowSize; j++)\n                sum = sum.double();\n    }\n    return sum;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe(c, fieldN, points, windowSize) {\n    /**\n     * Performance Analysis of Window-based Precomputation\n     *\n     * Base Case (256-bit scalar, 8-bit window):\n     * - Standard precomputation requires:\n     *   - 31 additions per scalar × 256 scalars = 7,936 ops\n     *   - Plus 255 summary additions = 8,191 total ops\n     *   Note: Summary additions can be optimized via accumulator\n     *\n     * Chunked Precomputation Analysis:\n     * - Using 32 chunks requires:\n     *   - 255 additions per chunk\n     *   - 256 doublings\n     *   - Total: (255 × 32) + 256 = 8,416 ops\n     *\n     * Memory Usage Comparison:\n     * Window Size | Standard Points | Chunked Points\n     * ------------|-----------------|---------------\n     *     4-bit   |     520         |      15\n     *     8-bit   |    4,224        |     255\n     *    10-bit   |   13,824        |   1,023\n     *    16-bit   |  557,056        |  65,535\n     *\n     * Key Advantages:\n     * 1. Enables larger window sizes due to reduced memory overhead\n     * 2. More efficient for smaller scalar counts:\n     *    - 16 chunks: (16 × 255) + 256 = 4,336 ops\n     *    - ~2x faster than standard 8,191 ops\n     *\n     * Limitations:\n     * - Not suitable for plain precomputes (requires 256 constant doublings)\n     * - Performance degrades with larger scalar counts:\n     *   - Optimal for ~256 scalars\n     *   - Less efficient for 4096+ scalars (Pippenger preferred)\n     */\n    validateW(windowSize, fieldN.BITS);\n    validateMSMPoints(points, c);\n    const zero = c.ZERO;\n    const tableSize = 2 ** windowSize - 1; // table size (without zero)\n    const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n    const MASK = bitMask(windowSize);\n    const tables = points.map((p) => {\n        const res = [];\n        for (let i = 0, acc = p; i < tableSize; i++) {\n            res.push(acc);\n            acc = acc.add(p);\n        }\n        return res;\n    });\n    return (scalars) => {\n        validateMSMScalars(scalars, fieldN);\n        if (scalars.length > points.length)\n            throw new Error('array of scalars must be smaller than array of points');\n        let res = zero;\n        for (let i = 0; i < chunks; i++) {\n            // No need to double if accumulator is still zero.\n            if (res !== zero)\n                for (let j = 0; j < windowSize; j++)\n                    res = res.double();\n            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n            for (let j = 0; j < scalars.length; j++) {\n                const n = scalars[j];\n                const curr = Number((n >> shiftBy) & MASK);\n                if (!curr)\n                    continue; // skip zero scalars chunks\n                res = res.add(tables[j][curr - 1]);\n            }\n        }\n        return res;\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map","/**\n * Short Weierstrass curve methods. The formula is: y² = x³ + ax + b.\n *\n * ### Parameters\n *\n * To initialize a weierstrass curve, one needs to pass following params:\n *\n * * a: formula param\n * * b: formula param\n * * Fp: finite field of prime characteristic P; may be complex (Fp2). Arithmetics is done in field\n * * n: order of prime subgroup a.k.a total amount of valid curve points\n * * Gx: Base point (x, y) aka generator point. Gx = x coordinate\n * * Gy: ...y coordinate\n * * h: cofactor, usually 1. h*n = curve group order (n is only subgroup order)\n * * lowS: whether to enable (default) or disable \"low-s\" non-malleable signatures\n *\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n *   `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n *   it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance\n * of nominative types in TypeScript and interfaces only check for shape, so it's hard to create\n * unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n *     which is hard to debug.\n *     2. Params can be generic and we can't enforce them to be constant value:\n *     if somebody creates curve from non-constant params,\n *     it would be allowed to interact with other curves with non-constant params\n *\n * @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// prettier-ignore\nimport { pippenger, validateBasic, wNAF } from \"./curve.js\";\n// prettier-ignore\nimport { Field, FpInvertBatch, getMinHashLength, invert, mapHashToField, mod, validateField } from \"./modular.js\";\n// prettier-ignore\nimport { aInRange, abool, bitMask, bytesToHex, bytesToNumberBE, concatBytes, createHmacDrbg, ensureBytes, hexToBytes, inRange, isBytes, memoized, numberToBytesBE, numberToHexUnpadded, validateObject } from \"./utils.js\";\nfunction validateSigVerOpts(opts) {\n    if (opts.lowS !== undefined)\n        abool('lowS', opts.lowS);\n    if (opts.prehash !== undefined)\n        abool('prehash', opts.prehash);\n}\nfunction validatePointOpts(curve) {\n    const opts = validateBasic(curve);\n    validateObject(opts, {\n        a: 'field',\n        b: 'field',\n    }, {\n        allowInfinityPoint: 'boolean',\n        allowedPrivateKeyLengths: 'array',\n        clearCofactor: 'function',\n        fromBytes: 'function',\n        isTorsionFree: 'function',\n        toBytes: 'function',\n        wrapPrivateKey: 'boolean',\n    });\n    const { endo, Fp, a } = opts;\n    if (endo) {\n        if (!Fp.eql(a, Fp.ZERO)) {\n            throw new Error('invalid endo: CURVE.a must be 0');\n        }\n        if (typeof endo !== 'object' ||\n            typeof endo.beta !== 'bigint' ||\n            typeof endo.splitScalar !== 'function') {\n            throw new Error('invalid endo: expected \"beta\": bigint and \"splitScalar\": function');\n        }\n    }\n    return Object.freeze({ ...opts });\n}\nexport class DERErr extends Error {\n    constructor(m = '') {\n        super(m);\n    }\n}\n/**\n * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:\n *\n *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]\n *\n * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html\n */\nexport const DER = {\n    // asn.1 DER encoding utils\n    Err: DERErr,\n    // Basic building block is TLV (Tag-Length-Value)\n    _tlv: {\n        encode: (tag, data) => {\n            const { Err: E } = DER;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length & 1)\n                throw new E('tlv.encode: unpadded data');\n            const dataLen = data.length / 2;\n            const len = numberToHexUnpadded(dataLen);\n            if ((len.length / 2) & 128)\n                throw new E('tlv.encode: long form length too big');\n            // length of length with long form flag\n            const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 128) : '';\n            const t = numberToHexUnpadded(tag);\n            return t + lenLen + len + data;\n        },\n        // v - value, l - left bytes (unparsed)\n        decode(tag, data) {\n            const { Err: E } = DER;\n            let pos = 0;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length < 2 || data[pos++] !== tag)\n                throw new E('tlv.decode: wrong tlv');\n            const first = data[pos++];\n            const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form\n            let length = 0;\n            if (!isLong)\n                length = first;\n            else {\n                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]\n                const lenLen = first & 127;\n                if (!lenLen)\n                    throw new E('tlv.decode(long): indefinite length not supported');\n                if (lenLen > 4)\n                    throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js\n                const lengthBytes = data.subarray(pos, pos + lenLen);\n                if (lengthBytes.length !== lenLen)\n                    throw new E('tlv.decode: length bytes not complete');\n                if (lengthBytes[0] === 0)\n                    throw new E('tlv.decode(long): zero leftmost byte');\n                for (const b of lengthBytes)\n                    length = (length << 8) | b;\n                pos += lenLen;\n                if (length < 128)\n                    throw new E('tlv.decode(long): not minimal encoding');\n            }\n            const v = data.subarray(pos, pos + length);\n            if (v.length !== length)\n                throw new E('tlv.decode: wrong value length');\n            return { v, l: data.subarray(pos + length) };\n        },\n    },\n    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n    // since we always use positive integers here. It must always be empty:\n    // - add zero byte if exists\n    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n    _int: {\n        encode(num) {\n            const { Err: E } = DER;\n            if (num < _0n)\n                throw new E('integer: negative integers are not allowed');\n            let hex = numberToHexUnpadded(num);\n            // Pad with zero byte if negative flag is present\n            if (Number.parseInt(hex[0], 16) & 0b1000)\n                hex = '00' + hex;\n            if (hex.length & 1)\n                throw new E('unexpected DER parsing assertion: unpadded hex');\n            return hex;\n        },\n        decode(data) {\n            const { Err: E } = DER;\n            if (data[0] & 128)\n                throw new E('invalid signature integer: negative');\n            if (data[0] === 0x00 && !(data[1] & 128))\n                throw new E('invalid signature integer: unnecessary leading zero');\n            return bytesToNumberBE(data);\n        },\n    },\n    toSig(hex) {\n        // parse DER signature\n        const { Err: E, _int: int, _tlv: tlv } = DER;\n        const data = ensureBytes('signature', hex);\n        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);\n        if (seqLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);\n        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);\n        if (sLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        return { r: int.decode(rBytes), s: int.decode(sBytes) };\n    },\n    hexFromSig(sig) {\n        const { _tlv: tlv, _int: int } = DER;\n        const rs = tlv.encode(0x02, int.encode(sig.r));\n        const ss = tlv.encode(0x02, int.encode(sig.s));\n        const seq = rs + ss;\n        return tlv.encode(0x30, seq);\n    },\n};\nfunction numToSizedHex(num, size) {\n    return bytesToHex(numberToBytesBE(num, size));\n}\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\nexport function weierstrassPoints(opts) {\n    const CURVE = validatePointOpts(opts);\n    const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ\n    const Fn = Field(CURVE.n, CURVE.nBitLength);\n    const toBytes = CURVE.toBytes ||\n        ((_c, point, _isCompressed) => {\n            const a = point.toAffine();\n            return concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));\n        });\n    const fromBytes = CURVE.fromBytes ||\n        ((bytes) => {\n            // const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');\n            const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n            const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n            return { x, y };\n        });\n    /**\n     * y² = x³ + ax + b: Short weierstrass curve formula. Takes x, returns y².\n     * @returns y²\n     */\n    function weierstrassEquation(x) {\n        const { a, b } = CURVE;\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x² * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x³ + a * x + b\n    }\n    function isValidXY(x, y) {\n        const left = Fp.sqr(y); // y²\n        const right = weierstrassEquation(x); // x³ + ax + b\n        return Fp.eql(left, right);\n    }\n    // Validate whether the passed curve params are valid.\n    // Test 1: equation y² = x³ + ax + b should work for generator point.\n    if (!isValidXY(CURVE.Gx, CURVE.Gy))\n        throw new Error('bad curve params: generator point');\n    // Test 2: discriminant Δ part should be non-zero: 4a³ + 27b² != 0.\n    // Guarantees curve is genus-1, smooth (non-singular).\n    const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n), _4n);\n    const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));\n    if (Fp.is0(Fp.add(_4a3, _27b2)))\n        throw new Error('bad curve params: a or b');\n    // Valid group elements reside in range 1..n-1\n    function isWithinCurveOrder(num) {\n        return inRange(num, _1n, CURVE.n);\n    }\n    // Validates if priv key is valid and converts it to bigint.\n    // Supports options allowedPrivateKeyLengths and wrapPrivateKey.\n    function normPrivateKeyToScalar(key) {\n        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;\n        if (lengths && typeof key !== 'bigint') {\n            if (isBytes(key))\n                key = bytesToHex(key);\n            // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes\n            if (typeof key !== 'string' || !lengths.includes(key.length))\n                throw new Error('invalid private key');\n            key = key.padStart(nByteLength * 2, '0');\n        }\n        let num;\n        try {\n            num =\n                typeof key === 'bigint'\n                    ? key\n                    : bytesToNumberBE(ensureBytes('private key', key, nByteLength));\n        }\n        catch (error) {\n            throw new Error('invalid private key, expected hex or ' + nByteLength + ' bytes, got ' + typeof key);\n        }\n        if (wrapPrivateKey)\n            num = mod(num, N); // disabled by default, enabled for BLS\n        aInRange('private key', num, _1n, N); // num in range [1..N-1]\n        return num;\n    }\n    function aprjpoint(other) {\n        if (!(other instanceof Point))\n            throw new Error('ProjectivePoint expected');\n    }\n    // Memoized toAffine / validity check. They are heavy. Points are immutable.\n    // Converts Projective point to affine (x, y) coordinates.\n    // Can accept precomputed Z^-1 - for example, from invertBatch.\n    // (X, Y, Z) ∋ (x=X/Z, y=Y/Z)\n    const toAffineMemo = memoized((p, iz) => {\n        const { px: x, py: y, pz: z } = p;\n        // Fast-path for normalized points\n        if (Fp.eql(z, Fp.ONE))\n            return { x, y };\n        const is0 = p.is0();\n        // If invZ was 0, we return zero point. However we still want to execute\n        // all operations, so we replace invZ with a random number, 1.\n        if (iz == null)\n            iz = is0 ? Fp.ONE : Fp.inv(z);\n        const ax = Fp.mul(x, iz);\n        const ay = Fp.mul(y, iz);\n        const zz = Fp.mul(z, iz);\n        if (is0)\n            return { x: Fp.ZERO, y: Fp.ZERO };\n        if (!Fp.eql(zz, Fp.ONE))\n            throw new Error('invZ was invalid');\n        return { x: ax, y: ay };\n    });\n    // NOTE: on exception this will crash 'cached' and no value will be set.\n    // Otherwise true will be return\n    const assertValidMemo = memoized((p) => {\n        if (p.is0()) {\n            // (0, 1, 0) aka ZERO is invalid in most contexts.\n            // In BLS, ZERO can be serialized, so we allow it.\n            // (0, 0, 0) is invalid representation of ZERO.\n            if (CURVE.allowInfinityPoint && !Fp.is0(p.py))\n                return;\n            throw new Error('bad point: ZERO');\n        }\n        // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n        const { x, y } = p.toAffine();\n        // Check if x, y are valid field elements\n        if (!Fp.isValid(x) || !Fp.isValid(y))\n            throw new Error('bad point: x or y not FE');\n        if (!isValidXY(x, y))\n            throw new Error('bad point: equation left != right');\n        if (!p.isTorsionFree())\n            throw new Error('bad point: not in prime-order subgroup');\n        return true;\n    });\n    /**\n     * Projective Point works in 3d / projective (homogeneous) coordinates: (X, Y, Z) ∋ (x=X/Z, y=Y/Z)\n     * Default Point works in 2d / affine coordinates: (x, y)\n     * We're doing calculations in projective, because its operations don't require costly inversion.\n     */\n    class Point {\n        constructor(px, py, pz) {\n            if (px == null || !Fp.isValid(px))\n                throw new Error('x required');\n            if (py == null || !Fp.isValid(py) || Fp.is0(py))\n                throw new Error('y required');\n            if (pz == null || !Fp.isValid(pz))\n                throw new Error('z required');\n            this.px = px;\n            this.py = py;\n            this.pz = pz;\n            Object.freeze(this);\n        }\n        // Does not validate if the point is on-curve.\n        // Use fromHex instead, or call assertValidity() later.\n        static fromAffine(p) {\n            const { x, y } = p || {};\n            if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('invalid affine point');\n            if (p instanceof Point)\n                throw new Error('projective point not allowed');\n            const is0 = (i) => Fp.eql(i, Fp.ZERO);\n            // fromAffine(x:0, y:0) would produce (x:0, y:0, z:1), but we need (x:0, y:1, z:0)\n            if (is0(x) && is0(y))\n                return Point.ZERO;\n            return new Point(x, y, Fp.ONE);\n        }\n        get x() {\n            return this.toAffine().x;\n        }\n        get y() {\n            return this.toAffine().y;\n        }\n        /**\n         * Takes a bunch of Projective Points but executes only one\n         * inversion on all of them. Inversion is very slow operation,\n         * so this improves performance massively.\n         * Optimization: converts a list of projective points to a list of identical points with Z=1.\n         */\n        static normalizeZ(points) {\n            const toInv = FpInvertBatch(Fp, points.map((p) => p.pz));\n            return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n        }\n        /**\n         * Converts hash string or Uint8Array to Point.\n         * @param hex short/long ECDSA hex\n         */\n        static fromHex(hex) {\n            const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));\n            P.assertValidity();\n            return P;\n        }\n        // Multiplies generator point by privateKey.\n        static fromPrivateKey(privateKey) {\n            return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));\n        }\n        // Multiscalar Multiplication\n        static msm(points, scalars) {\n            return pippenger(Point, Fn, points, scalars);\n        }\n        // \"Private method\", don't use it directly\n        _setWindowSize(windowSize) {\n            wnaf.setWindowSize(this, windowSize);\n        }\n        // A point on curve is valid if it conforms to equation.\n        assertValidity() {\n            assertValidMemo(this);\n        }\n        hasEvenY() {\n            const { y } = this.toAffine();\n            if (Fp.isOdd)\n                return !Fp.isOdd(y);\n            throw new Error(\"Field doesn't support isOdd\");\n        }\n        /**\n         * Compare one point to another.\n         */\n        equals(other) {\n            aprjpoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n            const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n            return U1 && U2;\n        }\n        /**\n         * Flips point to one corresponding to (x, -y) in Affine coordinates.\n         */\n        negate() {\n            return new Point(this.px, Fp.neg(this.py), this.pz);\n        }\n        // Renes-Costello-Batina exception-free doubling formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 3\n        // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n        double() {\n            const { a, b } = CURVE;\n            const b3 = Fp.mul(b, _3n);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            let t0 = Fp.mul(X1, X1); // step 1\n            let t1 = Fp.mul(Y1, Y1);\n            let t2 = Fp.mul(Z1, Z1);\n            let t3 = Fp.mul(X1, Y1);\n            t3 = Fp.add(t3, t3); // step 5\n            Z3 = Fp.mul(X1, Z1);\n            Z3 = Fp.add(Z3, Z3);\n            X3 = Fp.mul(a, Z3);\n            Y3 = Fp.mul(b3, t2);\n            Y3 = Fp.add(X3, Y3); // step 10\n            X3 = Fp.sub(t1, Y3);\n            Y3 = Fp.add(t1, Y3);\n            Y3 = Fp.mul(X3, Y3);\n            X3 = Fp.mul(t3, X3);\n            Z3 = Fp.mul(b3, Z3); // step 15\n            t2 = Fp.mul(a, t2);\n            t3 = Fp.sub(t0, t2);\n            t3 = Fp.mul(a, t3);\n            t3 = Fp.add(t3, Z3);\n            Z3 = Fp.add(t0, t0); // step 20\n            t0 = Fp.add(Z3, t0);\n            t0 = Fp.add(t0, t2);\n            t0 = Fp.mul(t0, t3);\n            Y3 = Fp.add(Y3, t0);\n            t2 = Fp.mul(Y1, Z1); // step 25\n            t2 = Fp.add(t2, t2);\n            t0 = Fp.mul(t2, t3);\n            X3 = Fp.sub(X3, t0);\n            Z3 = Fp.mul(t2, t1);\n            Z3 = Fp.add(Z3, Z3); // step 30\n            Z3 = Fp.add(Z3, Z3);\n            return new Point(X3, Y3, Z3);\n        }\n        // Renes-Costello-Batina exception-free addition formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 1\n        // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n        add(other) {\n            aprjpoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            const a = CURVE.a;\n            const b3 = Fp.mul(CURVE.b, _3n);\n            let t0 = Fp.mul(X1, X2); // step 1\n            let t1 = Fp.mul(Y1, Y2);\n            let t2 = Fp.mul(Z1, Z2);\n            let t3 = Fp.add(X1, Y1);\n            let t4 = Fp.add(X2, Y2); // step 5\n            t3 = Fp.mul(t3, t4);\n            t4 = Fp.add(t0, t1);\n            t3 = Fp.sub(t3, t4);\n            t4 = Fp.add(X1, Z1);\n            let t5 = Fp.add(X2, Z2); // step 10\n            t4 = Fp.mul(t4, t5);\n            t5 = Fp.add(t0, t2);\n            t4 = Fp.sub(t4, t5);\n            t5 = Fp.add(Y1, Z1);\n            X3 = Fp.add(Y2, Z2); // step 15\n            t5 = Fp.mul(t5, X3);\n            X3 = Fp.add(t1, t2);\n            t5 = Fp.sub(t5, X3);\n            Z3 = Fp.mul(a, t4);\n            X3 = Fp.mul(b3, t2); // step 20\n            Z3 = Fp.add(X3, Z3);\n            X3 = Fp.sub(t1, Z3);\n            Z3 = Fp.add(t1, Z3);\n            Y3 = Fp.mul(X3, Z3);\n            t1 = Fp.add(t0, t0); // step 25\n            t1 = Fp.add(t1, t0);\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.mul(b3, t4);\n            t1 = Fp.add(t1, t2);\n            t2 = Fp.sub(t0, t2); // step 30\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.add(t4, t2);\n            t0 = Fp.mul(t1, t4);\n            Y3 = Fp.add(Y3, t0);\n            t0 = Fp.mul(t5, t4); // step 35\n            X3 = Fp.mul(t3, X3);\n            X3 = Fp.sub(X3, t0);\n            t0 = Fp.mul(t3, t1);\n            Z3 = Fp.mul(t5, Z3);\n            Z3 = Fp.add(Z3, t0); // step 40\n            return new Point(X3, Y3, Z3);\n        }\n        subtract(other) {\n            return this.add(other.negate());\n        }\n        is0() {\n            return this.equals(Point.ZERO);\n        }\n        wNAF(n) {\n            return wnaf.wNAFCached(this, n, Point.normalizeZ);\n        }\n        /**\n         * Non-constant-time multiplication. Uses double-and-add algorithm.\n         * It's faster, but should only be used when you don't care about\n         * an exposed private key e.g. sig verification, which works over *public* keys.\n         */\n        multiplyUnsafe(sc) {\n            const { endo, n: N } = CURVE;\n            aInRange('scalar', sc, _0n, N);\n            const I = Point.ZERO;\n            if (sc === _0n)\n                return I;\n            if (this.is0() || sc === _1n)\n                return this;\n            // Case a: no endomorphism. Case b: has precomputes.\n            if (!endo || wnaf.hasPrecomputes(this))\n                return wnaf.wNAFCachedUnsafe(this, sc, Point.normalizeZ);\n            // Case c: endomorphism\n            /** See docs for {@link EndomorphismOpts} */\n            let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);\n            let k1p = I;\n            let k2p = I;\n            let d = this;\n            while (k1 > _0n || k2 > _0n) {\n                if (k1 & _1n)\n                    k1p = k1p.add(d);\n                if (k2 & _1n)\n                    k2p = k2p.add(d);\n                d = d.double();\n                k1 >>= _1n;\n                k2 >>= _1n;\n            }\n            if (k1neg)\n                k1p = k1p.negate();\n            if (k2neg)\n                k2p = k2p.negate();\n            k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n            return k1p.add(k2p);\n        }\n        /**\n         * Constant time multiplication.\n         * Uses wNAF method. Windowed method may be 10% faster,\n         * but takes 2x longer to generate and consumes 2x memory.\n         * Uses precomputes when available.\n         * Uses endomorphism for Koblitz curves.\n         * @param scalar by which the point would be multiplied\n         * @returns New point\n         */\n        multiply(scalar) {\n            const { endo, n: N } = CURVE;\n            aInRange('scalar', scalar, _1n, N);\n            let point, fake; // Fake point is used to const-time mult\n            /** See docs for {@link EndomorphismOpts} */\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);\n                let { p: k1p, f: f1p } = this.wNAF(k1);\n                let { p: k2p, f: f2p } = this.wNAF(k2);\n                k1p = wnaf.constTimeNegate(k1neg, k1p);\n                k2p = wnaf.constTimeNegate(k2neg, k2p);\n                k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n                point = k1p.add(k2p);\n                fake = f1p.add(f2p);\n            }\n            else {\n                const { p, f } = this.wNAF(scalar);\n                point = p;\n                fake = f;\n            }\n            // Normalize `z` for both points, but return only real one\n            return Point.normalizeZ([point, fake])[0];\n        }\n        /**\n         * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.\n         * Not using Strauss-Shamir trick: precomputation tables are faster.\n         * The trick could be useful if both P and Q are not G (not in our case).\n         * @returns non-zero affine point\n         */\n        multiplyAndAddUnsafe(Q, a, b) {\n            const G = Point.BASE; // No Strauss-Shamir trick: we have 10% faster G precomputes\n            const mul = (P, a // Select faster multiply() method\n            ) => (a === _0n || a === _1n || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));\n            const sum = mul(this, a).add(mul(Q, b));\n            return sum.is0() ? undefined : sum;\n        }\n        // Converts Projective point to affine (x, y) coordinates.\n        // Can accept precomputed Z^-1 - for example, from invertBatch.\n        // (x, y, z) ∋ (x=x/z, y=y/z)\n        toAffine(iz) {\n            return toAffineMemo(this, iz);\n        }\n        isTorsionFree() {\n            const { h: cofactor, isTorsionFree } = CURVE;\n            if (cofactor === _1n)\n                return true; // No subgroups, always torsion-free\n            if (isTorsionFree)\n                return isTorsionFree(Point, this);\n            throw new Error('isTorsionFree() has not been declared for the elliptic curve');\n        }\n        clearCofactor() {\n            const { h: cofactor, clearCofactor } = CURVE;\n            if (cofactor === _1n)\n                return this; // Fast-path\n            if (clearCofactor)\n                return clearCofactor(Point, this);\n            return this.multiplyUnsafe(CURVE.h);\n        }\n        toRawBytes(isCompressed = true) {\n            abool('isCompressed', isCompressed);\n            this.assertValidity();\n            return toBytes(Point, this, isCompressed);\n        }\n        toHex(isCompressed = true) {\n            abool('isCompressed', isCompressed);\n            return bytesToHex(this.toRawBytes(isCompressed));\n        }\n    }\n    // base / generator point\n    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    // zero / infinity / identity point\n    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0\n    const { endo, nBitLength } = CURVE;\n    const wnaf = wNAF(Point, endo ? Math.ceil(nBitLength / 2) : nBitLength);\n    return {\n        CURVE,\n        ProjectivePoint: Point,\n        normPrivateKeyToScalar,\n        weierstrassEquation,\n        isWithinCurveOrder,\n    };\n}\nfunction validateOpts(curve) {\n    const opts = validateBasic(curve);\n    validateObject(opts, {\n        hash: 'hash',\n        hmac: 'function',\n        randomBytes: 'function',\n    }, {\n        bits2int: 'function',\n        bits2int_modN: 'function',\n        lowS: 'boolean',\n    });\n    return Object.freeze({ lowS: true, ...opts });\n}\n/**\n * Creates short weierstrass curve and ECDSA signature methods for it.\n * @example\n * import { Field } from '@noble/curves/abstract/modular';\n * // Before that, define BigInt-s: a, b, p, n, Gx, Gy\n * const curve = weierstrass({ a, b, Fp: Field(p), n, Gx, Gy, h: 1n })\n */\nexport function weierstrass(curveDef) {\n    const CURVE = validateOpts(curveDef);\n    const { Fp, n: CURVE_ORDER, nByteLength, nBitLength } = CURVE;\n    const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32\n    const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32\n    function modN(a) {\n        return mod(a, CURVE_ORDER);\n    }\n    function invN(a) {\n        return invert(a, CURVE_ORDER);\n    }\n    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder, } = weierstrassPoints({\n        ...CURVE,\n        toBytes(_c, point, isCompressed) {\n            const a = point.toAffine();\n            const x = Fp.toBytes(a.x);\n            const cat = concatBytes;\n            abool('isCompressed', isCompressed);\n            if (isCompressed) {\n                return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);\n            }\n            else {\n                return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));\n            }\n        },\n        fromBytes(bytes) {\n            const len = bytes.length;\n            const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // this.assertValidity() is done inside of fromHex\n            if (len === compressedLen && (head === 0x02 || head === 0x03)) {\n                const x = bytesToNumberBE(tail);\n                if (!inRange(x, _1n, Fp.ORDER))\n                    throw new Error('Point is not on curve');\n                const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n                let y;\n                try {\n                    y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n                }\n                catch (sqrtError) {\n                    const suffix = sqrtError instanceof Error ? ': ' + sqrtError.message : '';\n                    throw new Error('Point is not on curve' + suffix);\n                }\n                const isYOdd = (y & _1n) === _1n;\n                // ECDSA\n                const isHeadOdd = (head & 1) === 1;\n                if (isHeadOdd !== isYOdd)\n                    y = Fp.neg(y);\n                return { x, y };\n            }\n            else if (len === uncompressedLen && head === 0x04) {\n                const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n                const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n                return { x, y };\n            }\n            else {\n                const cl = compressedLen;\n                const ul = uncompressedLen;\n                throw new Error('invalid Point, expected length of ' + cl + ', or uncompressed ' + ul + ', got ' + len);\n            }\n        },\n    });\n    function isBiggerThanHalfOrder(number) {\n        const HALF = CURVE_ORDER >> _1n;\n        return number > HALF;\n    }\n    function normalizeS(s) {\n        return isBiggerThanHalfOrder(s) ? modN(-s) : s;\n    }\n    // slice bytes num\n    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));\n    /**\n     * ECDSA signature with its (r, s) properties. Supports DER & compact representations.\n     */\n    class Signature {\n        constructor(r, s, recovery) {\n            aInRange('r', r, _1n, CURVE_ORDER); // r in [1..N]\n            aInRange('s', s, _1n, CURVE_ORDER); // s in [1..N]\n            this.r = r;\n            this.s = s;\n            if (recovery != null)\n                this.recovery = recovery;\n            Object.freeze(this);\n        }\n        // pair (bytes of r, bytes of s)\n        static fromCompact(hex) {\n            const l = nByteLength;\n            hex = ensureBytes('compactSignature', hex, l * 2);\n            return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));\n        }\n        // DER encoded ECDSA signature\n        // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script\n        static fromDER(hex) {\n            const { r, s } = DER.toSig(ensureBytes('DER', hex));\n            return new Signature(r, s);\n        }\n        /**\n         * @todo remove\n         * @deprecated\n         */\n        assertValidity() { }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(msgHash) {\n            const { r, s, recovery: rec } = this;\n            const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash\n            if (rec == null || ![0, 1, 2, 3].includes(rec))\n                throw new Error('recovery id invalid');\n            const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;\n            if (radj >= Fp.ORDER)\n                throw new Error('recovery id 2 or 3 invalid');\n            const prefix = (rec & 1) === 0 ? '02' : '03';\n            const R = Point.fromHex(prefix + numToSizedHex(radj, Fp.BYTES));\n            const ir = invN(radj); // r^-1\n            const u1 = modN(-h * ir); // -hr^-1\n            const u2 = modN(s * ir); // sr^-1\n            const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)\n            if (!Q)\n                throw new Error('point at infinify'); // unsafe is fine: no priv data leaked\n            Q.assertValidity();\n            return Q;\n        }\n        // Signatures should be low-s, to prevent malleability.\n        hasHighS() {\n            return isBiggerThanHalfOrder(this.s);\n        }\n        normalizeS() {\n            return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;\n        }\n        // DER-encoded\n        toDERRawBytes() {\n            return hexToBytes(this.toDERHex());\n        }\n        toDERHex() {\n            return DER.hexFromSig(this);\n        }\n        // padded bytes of r, then padded bytes of s\n        toCompactRawBytes() {\n            return hexToBytes(this.toCompactHex());\n        }\n        toCompactHex() {\n            const l = nByteLength;\n            return numToSizedHex(this.r, l) + numToSizedHex(this.s, l);\n        }\n    }\n    const utils = {\n        isValidPrivateKey(privateKey) {\n            try {\n                normPrivateKeyToScalar(privateKey);\n                return true;\n            }\n            catch (error) {\n                return false;\n            }\n        },\n        normPrivateKeyToScalar: normPrivateKeyToScalar,\n        /**\n         * Produces cryptographically secure private key from random of size\n         * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n         */\n        randomPrivateKey: () => {\n            const length = getMinHashLength(CURVE.n);\n            return mapHashToField(CURVE.randomBytes(length), CURVE.n);\n        },\n        /**\n         * Creates precompute table for an arbitrary EC point. Makes point \"cached\".\n         * Allows to massively speed-up `point.multiply(scalar)`.\n         * @returns cached point\n         * @example\n         * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));\n         * fast.multiply(privKey); // much faster ECDH now\n         */\n        precompute(windowSize = 8, point = Point.BASE) {\n            point._setWindowSize(windowSize);\n            point.multiply(BigInt(3)); // 3 is arbitrary, just need any number here\n            return point;\n        },\n    };\n    /**\n     * Computes public key for a private key. Checks for validity of the private key.\n     * @param privateKey private key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns Public key, full when isCompressed=false; short when isCompressed=true\n     */\n    function getPublicKey(privateKey, isCompressed = true) {\n        return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        if (typeof item === 'bigint')\n            return false;\n        if (item instanceof Point)\n            return true;\n        const arr = ensureBytes('key', item);\n        const len = arr.length;\n        const fpl = Fp.BYTES;\n        const compLen = fpl + 1; // e.g. 33 for 32\n        const uncompLen = 2 * fpl + 1; // e.g. 65 for 32\n        if (CURVE.allowedPrivateKeyLengths || nByteLength === compLen) {\n            return undefined;\n        }\n        else {\n            return len === compLen || len === uncompLen;\n        }\n    }\n    /**\n     * ECDH (Elliptic Curve Diffie Hellman).\n     * Computes shared public key from private key and public key.\n     * Checks: 1) private key validity 2) shared key is on-curve.\n     * Does NOT hash the result.\n     * @param privateA private key\n     * @param publicB different public key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns shared public key\n     */\n    function getSharedSecret(privateA, publicB, isCompressed = true) {\n        if (isProbPub(privateA) === true)\n            throw new Error('first arg must be private key');\n        if (isProbPub(publicB) === false)\n            throw new Error('second arg must be public key');\n        const b = Point.fromHex(publicB); // check for being on-curve\n        return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);\n    }\n    // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n    // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n    // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n    // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n    const bits2int = CURVE.bits2int ||\n        function (bytes) {\n            // Our custom check \"just in case\", for protection against DoS\n            if (bytes.length > 8192)\n                throw new Error('input is too large');\n            // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n            // for some cases, since bytes.length * 8 is not actual bitLength.\n            const num = bytesToNumberBE(bytes); // check for == u8 done here\n            const delta = bytes.length * 8 - nBitLength; // truncate to nBitLength leftmost bits\n            return delta > 0 ? num >> BigInt(delta) : num;\n        };\n    const bits2int_modN = CURVE.bits2int_modN ||\n        function (bytes) {\n            return modN(bits2int(bytes)); // can't use bytesToNumberBE here\n        };\n    // NOTE: pads output with zero as per spec\n    const ORDER_MASK = bitMask(nBitLength);\n    /**\n     * Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.\n     */\n    function int2octets(num) {\n        aInRange('num < 2^' + nBitLength, num, _0n, ORDER_MASK);\n        // works with order, can have different size than numToField!\n        return numberToBytesBE(num, nByteLength);\n    }\n    // Steps A, D of RFC6979 3.2\n    // Creates RFC6979 seed; converts msg/privKey to numbers.\n    // Used only in sign, not in verify.\n    // NOTE: we cannot assume here that msgHash has same amount of bytes as curve order,\n    // this will be invalid at least for P521. Also it can be bigger for P224 + SHA256\n    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {\n        if (['recovered', 'canonical'].some((k) => k in opts))\n            throw new Error('sign() legacy options not supported');\n        const { hash, randomBytes } = CURVE;\n        let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default\n        if (lowS == null)\n            lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash\n        msgHash = ensureBytes('msgHash', msgHash);\n        validateSigVerOpts(opts);\n        if (prehash)\n            msgHash = ensureBytes('prehashed msgHash', hash(msgHash));\n        // We can't later call bits2octets, since nested bits2int is broken for curves\n        // with nBitLength % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n        // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n        const h1int = bits2int_modN(msgHash);\n        const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint\n        const seedArgs = [int2octets(d), int2octets(h1int)];\n        // extraEntropy. RFC6979 3.6: additional k' (optional).\n        if (ent != null && ent !== false) {\n            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n            const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is\n            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes\n        }\n        const seed = concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n        // Converts signature params into point w r/s, checks result for validity.\n        function k2sig(kBytes) {\n            // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n            const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n            if (!isWithinCurveOrder(k))\n                return; // Important: all mod() calls here must be done over N\n            const ik = invN(k); // k^-1 mod n\n            const q = Point.BASE.multiply(k).toAffine(); // q = Gk\n            const r = modN(q.x); // r = q.x mod n\n            if (r === _0n)\n                return;\n            // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n            // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n            // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n            const s = modN(ik * modN(m + r * d)); // Not using blinding here\n            if (s === _0n)\n                return;\n            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n            let normS = s;\n            if (lowS && isBiggerThanHalfOrder(s)) {\n                normS = normalizeS(s); // if lowS was passed, ensure s is always\n                recovery ^= 1; // // in the bottom half of N\n            }\n            return new Signature(r, normS, recovery); // use normS, not s\n        }\n        return { seed, k2sig };\n    }\n    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };\n    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };\n    /**\n     * Signs message hash with a private key.\n     * ```\n     * sign(m, d, k) where\n     *   (x, y) = G × k\n     *   r = x mod n\n     *   s = (m + dr)/k mod n\n     * ```\n     * @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.\n     * @param privKey private key\n     * @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.\n     * @returns signature with recovery param\n     */\n    function sign(msgHash, privKey, opts = defaultSigOpts) {\n        const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.\n        const C = CURVE;\n        const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);\n        return drbg(seed, k2sig); // Steps B, C, D, E, F, G\n    }\n    // Enable precomputes. Slows down first publicKey computation by 20ms.\n    Point.BASE._setWindowSize(8);\n    // utils.precompute(8, ProjectivePoint.BASE)\n    /**\n     * Verifies a signature against message hash and public key.\n     * Rejects lowS signatures by default: to override,\n     * specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n     *\n     * ```\n     * verify(r, s, h, P) where\n     *   U1 = hs^-1 mod n\n     *   U2 = rs^-1 mod n\n     *   R = U1⋅G - U2⋅P\n     *   mod(R.x, n) == r\n     * ```\n     */\n    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {\n        const sg = signature;\n        msgHash = ensureBytes('msgHash', msgHash);\n        publicKey = ensureBytes('publicKey', publicKey);\n        const { lowS, prehash, format } = opts;\n        // Verify opts, deduce signature format\n        validateSigVerOpts(opts);\n        if ('strict' in opts)\n            throw new Error('options.strict was renamed to lowS');\n        if (format !== undefined && format !== 'compact' && format !== 'der')\n            throw new Error('format must be compact or der');\n        const isHex = typeof sg === 'string' || isBytes(sg);\n        const isObj = !isHex &&\n            !format &&\n            typeof sg === 'object' &&\n            sg !== null &&\n            typeof sg.r === 'bigint' &&\n            typeof sg.s === 'bigint';\n        if (!isHex && !isObj)\n            throw new Error('invalid signature, expected Uint8Array, hex string or Signature instance');\n        let _sig = undefined;\n        let P;\n        try {\n            if (isObj)\n                _sig = new Signature(sg.r, sg.s);\n            if (isHex) {\n                // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).\n                // Since DER can also be 2*nByteLength bytes, we check for it first.\n                try {\n                    if (format !== 'compact')\n                        _sig = Signature.fromDER(sg);\n                }\n                catch (derError) {\n                    if (!(derError instanceof DER.Err))\n                        throw derError;\n                }\n                if (!_sig && format !== 'der')\n                    _sig = Signature.fromCompact(sg);\n            }\n            P = Point.fromHex(publicKey);\n        }\n        catch (error) {\n            return false;\n        }\n        if (!_sig)\n            return false;\n        if (lowS && _sig.hasHighS())\n            return false;\n        if (prehash)\n            msgHash = CURVE.hash(msgHash);\n        const { r, s } = _sig;\n        const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element\n        const is = invN(s); // s^-1\n        const u1 = modN(h * is); // u1 = hs^-1 mod n\n        const u2 = modN(r * is); // u2 = rs^-1 mod n\n        const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); // R = u1⋅G + u2⋅P\n        if (!R)\n            return false;\n        const v = modN(R.x);\n        return v === r;\n    }\n    return {\n        CURVE,\n        getPublicKey,\n        getSharedSecret,\n        sign,\n        verify,\n        ProjectivePoint: Point,\n        Signature,\n        utils,\n    };\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n    // Generic implementation\n    const q = Fp.ORDER;\n    let l = _0n;\n    for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n        l += _1n;\n    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n    // 2n ** c1 == 2n << (c1-1)\n    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n    const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n    const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n    let sqrtRatio = (u, v) => {\n        let tv1 = c6; // 1. tv1 = c6\n        let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n        let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n        tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n        let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n        tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n        tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n        tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n        tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n        let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n        tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n        let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n        tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n        tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n        tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n        tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n        // 17. for i in (c1, c1 - 1, ..., 2):\n        for (let i = c1; i > _1n; i--) {\n            let tv5 = i - _2n; // 18.    tv5 = i - 2\n            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n            let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n            const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n            tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n            tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n            tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n            tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n            tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n        }\n        return { isValid: isQR, value: tv3 };\n    };\n    if (Fp.ORDER % _4n === _3n) {\n        // sqrt_ratio_3mod4(u, v)\n        const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n        const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n        sqrtRatio = (u, v) => {\n            let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n    validateField(Fp);\n    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n    if (!Fp.isOdd)\n        throw new Error('Fp.isOdd is not implemented!');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n        tv5 = Fp.mul(tv6, opts.A); // 11. tv5 = A * tv6\n        tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n        tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n        tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n        tv5 = Fp.mul(tv6, opts.B); // 15. tv5 = B * tv6\n        tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n        x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n        y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n        y = Fp.mul(y, value); // 20.   y = y * y1\n        x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n        y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n        const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)\n        y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n        const tv4_inv = FpInvertBatch(Fp, [tv4], true)[0];\n        x = Fp.mul(x, tv4_inv); // 25.   x = x / tv4\n        return { x, y };\n    };\n}\n//# sourceMappingURL=weierstrass.js.map","/**\n * Utilities for short weierstrass curves, combined with noble-hashes.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from \"./abstract/weierstrass.js\";\n/** connects noble-curves to noble-hashes */\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return { ...create(defHash), create };\n}\n//# sourceMappingURL=_shortw_utils.js.map","/**\n * NIST secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).\n *\n * Seems to be rigid (not backdoored)\n * [as per discussion](https://bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975).\n *\n * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.\n * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.\n * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.\n * [See explanation](https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066).\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha2';\nimport { randomBytes } from '@noble/hashes/utils';\nimport { createCurve } from \"./_shortw_utils.js\";\nimport { createHasher, isogenyMap } from \"./abstract/hash-to-curve.js\";\nimport { Field, mod, pow2 } from \"./abstract/modular.js\";\nimport { aInRange, bytesToNumberBE, concatBytes, ensureBytes, inRange, numberToBytesBE, } from \"./abstract/utils.js\";\nimport { mapToCurveSimpleSWU } from \"./abstract/weierstrass.js\";\nconst secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');\nconst secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst divNearest = (a, b) => (a + b / _2n) / b;\n/**\n * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y) {\n    const P = secp256k1P;\n    // prettier-ignore\n    const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n    // prettier-ignore\n    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n    const b2 = (y * y * y) % P; // x^3, 11\n    const b3 = (b2 * b2 * y) % P; // x^7\n    const b6 = (pow2(b3, _3n, P) * b3) % P;\n    const b9 = (pow2(b6, _3n, P) * b3) % P;\n    const b11 = (pow2(b9, _2n, P) * b2) % P;\n    const b22 = (pow2(b11, _11n, P) * b11) % P;\n    const b44 = (pow2(b22, _22n, P) * b22) % P;\n    const b88 = (pow2(b44, _44n, P) * b44) % P;\n    const b176 = (pow2(b88, _88n, P) * b88) % P;\n    const b220 = (pow2(b176, _44n, P) * b44) % P;\n    const b223 = (pow2(b220, _3n, P) * b3) % P;\n    const t1 = (pow2(b223, _23n, P) * b22) % P;\n    const t2 = (pow2(t1, _6n, P) * b2) % P;\n    const root = pow2(t2, _2n, P);\n    if (!Fpk1.eql(Fpk1.sqr(root), y))\n        throw new Error('Cannot find square root');\n    return root;\n}\nconst Fpk1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });\n/**\n * secp256k1 curve, ECDSA and ECDH methods.\n *\n * Field: `2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n`\n *\n * @example\n * ```js\n * import { secp256k1 } from '@noble/curves/secp256k1';\n * const priv = secp256k1.utils.randomPrivateKey();\n * const pub = secp256k1.getPublicKey(priv);\n * const msg = new Uint8Array(32).fill(1); // message hash (not message) in ecdsa\n * const sig = secp256k1.sign(msg, priv); // `{prehash: true}` option is available\n * const isValid = secp256k1.verify(sig, msg, pub) === true;\n * ```\n */\nexport const secp256k1 = createCurve({\n    a: _0n,\n    b: BigInt(7),\n    Fp: Fpk1,\n    n: secp256k1N,\n    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n    h: BigInt(1),\n    lowS: true, // Allow only low-S signatures by default in sign() and verify()\n    endo: {\n        // Endomorphism, see above\n        beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n        splitScalar: (k) => {\n            const n = secp256k1N;\n            const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n            const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n            const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n            const b2 = a1;\n            const POW_2_128 = BigInt('0x100000000000000000000000000000000'); // (2n**128n).toString(16)\n            const c1 = divNearest(b2 * k, n);\n            const c2 = divNearest(-b1 * k, n);\n            let k1 = mod(k - c1 * a1 - c2 * a2, n);\n            let k2 = mod(-c1 * b1 - c2 * b2, n);\n            const k1neg = k1 > POW_2_128;\n            const k2neg = k2 > POW_2_128;\n            if (k1neg)\n                k1 = n - k1;\n            if (k2neg)\n                k2 = n - k2;\n            if (k1 > POW_2_128 || k2 > POW_2_128) {\n                throw new Error('splitScalar: Endomorphism failed, k=' + k);\n            }\n            return { k1neg, k1, k2neg, k2 };\n        },\n    },\n}, sha256);\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES = {};\nfunction taggedHash(tag, ...messages) {\n    let tagP = TAGGED_HASH_PREFIXES[tag];\n    if (tagP === undefined) {\n        const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n        tagP = concatBytes(tagH, tagH);\n        TAGGED_HASH_PREFIXES[tag] = tagP;\n    }\n    return sha256(concatBytes(tagP, ...messages));\n}\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point) => point.toRawBytes(true).slice(1);\nconst numTo32b = (n) => numberToBytesBE(n, 32);\nconst modP = (x) => mod(x, secp256k1P);\nconst modN = (x) => mod(x, secp256k1N);\nconst Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();\nconst GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv); // same method executed in fromPrivateKey\n    let p = Point.fromPrivateKey(d_); // P = d'⋅G; 0 < d' < n check is done inside\n    const scalar = p.hasEvenY() ? d_ : modN(-d_);\n    return { scalar: scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x) {\n    aInRange('x', x, _1n, secp256k1P); // Fail if x ≥ p.\n    const xx = modP(x * x);\n    const c = modP(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.\n    let y = sqrtMod(c); // Let y = c^(p+1)/4 mod p.\n    if (y % _2n !== _0n)\n        y = modP(-y); // Return the unique point P such that x(P) = x and\n    const p = new Point(x, y, _1n); // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n    p.assertValidity();\n    return p;\n}\nconst num = bytesToNumberBE;\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args) {\n    return modN(num(taggedHash('BIP0340/challenge', ...args)));\n}\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(privateKey) {\n    return schnorrGetExtPubKey(privateKey).bytes; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)\n}\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(message, privateKey, auxRand = randomBytes(32)) {\n    const m = ensureBytes('message', message);\n    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey); // checks for isWithinCurveOrder\n    const a = ensureBytes('auxRand', auxRand, 32); // Auxiliary random data a: a 32-byte array\n    const t = numTo32b(d ^ num(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n    const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n    const k_ = modN(num(rand)); // Let k' = int(rand) mod n\n    if (k_ === _0n)\n        throw new Error('sign failed: k is zero'); // Fail if k' = 0.\n    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_); // Let R = k'⋅G.\n    const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n    const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n    sig.set(rx, 0);\n    sig.set(numTo32b(modN(k + e * d)), 32);\n    // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n    if (!schnorrVerify(sig, m, px))\n        throw new Error('sign: Invalid signature produced');\n    return sig;\n}\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature, message, publicKey) {\n    const sig = ensureBytes('signature', signature, 64);\n    const m = ensureBytes('message', message);\n    const pub = ensureBytes('publicKey', publicKey, 32);\n    try {\n        const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails\n        const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.\n        if (!inRange(r, _1n, secp256k1P))\n            return false;\n        const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n        if (!inRange(s, _1n, secp256k1N))\n            return false;\n        const e = challenge(numTo32b(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\n        const R = GmulAdd(P, s, modN(-e)); // R = s⋅G - e⋅P\n        if (!R || !R.hasEvenY() || R.toAffine().x !== r)\n            return false; // -eP == (n-e)P\n        return true; // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.\n    }\n    catch (error) {\n        return false;\n    }\n}\n/**\n * Schnorr signatures over secp256k1.\n * https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n * @example\n * ```js\n * import { schnorr } from '@noble/curves/secp256k1';\n * const priv = schnorr.utils.randomPrivateKey();\n * const pub = schnorr.getPublicKey(priv);\n * const msg = new TextEncoder().encode('hello');\n * const sig = schnorr.sign(msg, priv);\n * const isValid = schnorr.verify(sig, msg, pub);\n * ```\n */\nexport const schnorr = /* @__PURE__ */ (() => ({\n    getPublicKey: schnorrGetPublicKey,\n    sign: schnorrSign,\n    verify: schnorrVerify,\n    utils: {\n        randomPrivateKey: secp256k1.utils.randomPrivateKey,\n        lift_x,\n        pointToBytes,\n        numberToBytesBE,\n        bytesToNumberBE,\n        taggedHash,\n        mod,\n    },\n}))();\nconst isoMap = /* @__PURE__ */ (() => isogenyMap(Fpk1, [\n    // xNum\n    [\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n        '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n        '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n    ],\n    // xDen\n    [\n        '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n        '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n    // yNum\n    [\n        '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n        '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n        '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n        '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n    ],\n    // yDen\n    [\n        '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n        '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n        '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n].map((i) => i.map((j) => BigInt(j)))))();\nconst mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fpk1, {\n    A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n    B: BigInt('1771'),\n    Z: Fpk1.create(BigInt('-11')),\n}))();\n/** Hashing / encoding to secp256k1 points / field. RFC 9380 methods. */\nexport const secp256k1_hasher = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {\n    const { x, y } = mapSWU(Fpk1.create(scalars[0]));\n    return isoMap(x, y);\n}, {\n    DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n    encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n    p: Fpk1.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha256,\n}))();\nexport const hashToCurve = /* @__PURE__ */ (() => secp256k1_hasher.hashToCurve)();\nexport const encodeToCurve = /* @__PURE__ */ (() => secp256k1_hasher.encodeToCurve)();\n//# sourceMappingURL=secp256k1.js.map"],"names":["_0n","_1n","_2n","_3n","_4n","bitLen","wbits","endo","a","randomBytes","concatBytes"],"mappings":";AASA,MAAMA,QAAsB,uBAAO,CAAC;AACpC,MAAMC,QAAsB,uBAAO,CAAC;AAC7B,SAAS,QAAQ,GAAG;AACvB,SAAO,aAAa,cAAe,YAAY,OAAO,CAAC,KAAK,EAAE,YAAY,SAAS;AACvF;AACO,SAAS,OAAO,MAAM;AACzB,MAAI,CAAC,QAAQ,IAAI;AACb,UAAM,IAAI,MAAM,qBAAqB;AAC7C;AACO,SAAS,MAAM,OAAO,OAAO;AAChC,MAAI,OAAO,UAAU;AACjB,UAAM,IAAI,MAAM,QAAQ,4BAA4B,KAAK;AACjE;AAEO,SAAS,oBAAoB,KAAK;AACrC,QAAM,MAAM,IAAI,SAAS,EAAE;AAC3B,SAAO,IAAI,SAAS,IAAI,MAAM,MAAM;AACxC;AACO,SAAS,YAAY,KAAK;AAC7B,MAAI,OAAO,QAAQ;AACf,UAAM,IAAI,MAAM,8BAA8B,OAAO,GAAG;AAC5D,SAAO,QAAQ,KAAKD,QAAM,OAAO,OAAO,GAAG;AAC/C;AAEA,MAAM;AAAA;AAAA,EAEN,OAAO,WAAW,KAAK,CAAA,CAAE,EAAE,UAAU,cAAc,OAAO,WAAW,YAAY;AAAA;AAEjF,MAAM,QAAwB,sBAAM,KAAK,EAAE,QAAQ,IAAK,GAAE,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAK5F,SAAS,WAAW,OAAO;AAC9B,SAAO,KAAK;AAEZ,MAAI;AACA,WAAO,MAAM,MAAO;AAExB,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,WAAO,MAAM,MAAM,CAAC,CAAC;AAAA,EAC7B;AACI,SAAO;AACX;AAEA,MAAM,SAAS,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAK;AAC9D,SAAS,cAAc,IAAI;AACvB,MAAI,MAAM,OAAO,MAAM,MAAM,OAAO;AAChC,WAAO,KAAK,OAAO;AACvB,MAAI,MAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,WAAO,MAAM,OAAO,IAAI;AAC5B,MAAI,MAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,WAAO,MAAM,OAAO,IAAI;AAC5B;AACJ;AAKO,SAAS,WAAW,KAAK;AAC5B,MAAI,OAAO,QAAQ;AACf,UAAM,IAAI,MAAM,8BAA8B,OAAO,GAAG;AAE5D,MAAI;AACA,WAAO,WAAW,QAAQ,GAAG;AACjC,QAAM,KAAK,IAAI;AACf,QAAM,KAAK,KAAK;AAChB,MAAI,KAAK;AACL,UAAM,IAAI,MAAM,qDAAqD,EAAE;AAC3E,QAAM,QAAQ,IAAI,WAAW,EAAE;AAC/B,WAAS,KAAK,GAAG,KAAK,GAAG,KAAK,IAAI,MAAM,MAAM,GAAG;AAC7C,UAAM,KAAK,cAAc,IAAI,WAAW,EAAE,CAAC;AAC3C,UAAM,KAAK,cAAc,IAAI,WAAW,KAAK,CAAC,CAAC;AAC/C,QAAI,OAAO,UAAa,OAAO,QAAW;AACtC,YAAM,OAAO,IAAI,EAAE,IAAI,IAAI,KAAK,CAAC;AACjC,YAAM,IAAI,MAAM,iDAAiD,OAAO,gBAAgB,EAAE;AAAA,IACtG;AACQ,UAAM,EAAE,IAAI,KAAK,KAAK;AAAA,EAC9B;AACI,SAAO;AACX;AAEO,SAAS,gBAAgB,OAAO;AACnC,SAAO,YAAY,WAAW,KAAK,CAAC;AACxC;AACO,SAAS,gBAAgB,OAAO;AACnC,SAAO,KAAK;AACZ,SAAO,YAAY,WAAW,WAAW,KAAK,KAAK,EAAE,QAAO,CAAE,CAAC;AACnE;AACO,SAAS,gBAAgB,GAAG,KAAK;AACpC,SAAO,WAAW,EAAE,SAAS,EAAE,EAAE,SAAS,MAAM,GAAG,GAAG,CAAC;AAC3D;AACO,SAAS,gBAAgB,GAAG,KAAK;AACpC,SAAO,gBAAgB,GAAG,GAAG,EAAE,QAAS;AAC5C;AAcO,SAAS,YAAY,OAAO,KAAK,gBAAgB;AACpD,MAAI;AACJ,MAAI,OAAO,QAAQ,UAAU;AACzB,QAAI;AACA,YAAM,WAAW,GAAG;AAAA,IAChC,SACe,GAAG;AACN,YAAM,IAAI,MAAM,QAAQ,+CAA+C,CAAC;AAAA,IACpF;AAAA,EACA,WACa,QAAQ,GAAG,GAAG;AAGnB,UAAM,WAAW,KAAK,GAAG;AAAA,EACjC,OACS;AACD,UAAM,IAAI,MAAM,QAAQ,mCAAmC;AAAA,EACnE;AACI,QAAM,MAAM,IAAI;AAChB,MAAI,OAAO,mBAAmB,YAAY,QAAQ;AAC9C,UAAM,IAAI,MAAM,QAAQ,gBAAgB,iBAAiB,oBAAoB,GAAG;AACpF,SAAO;AACX;AAIO,SAAS,eAAe,QAAQ;AACnC,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,UAAM,IAAI,OAAO,CAAC;AAClB,WAAO,CAAC;AACR,WAAO,EAAE;AAAA,EACjB;AACI,QAAM,MAAM,IAAI,WAAW,GAAG;AAC9B,WAAS,IAAI,GAAG,MAAM,GAAG,IAAI,OAAO,QAAQ,KAAK;AAC7C,UAAM,IAAI,OAAO,CAAC;AAClB,QAAI,IAAI,GAAG,GAAG;AACd,WAAO,EAAE;AAAA,EACjB;AACI,SAAO;AACX;AAmBA,MAAM,WAAW,CAAC,MAAM,OAAO,MAAM,YAAYA,SAAO;AACjD,SAAS,QAAQ,GAAG,KAAK,KAAK;AACjC,SAAO,SAAS,CAAC,KAAK,SAAS,GAAG,KAAK,SAAS,GAAG,KAAK,OAAO,KAAK,IAAI;AAC5E;AAMO,SAAS,SAAS,OAAO,GAAG,KAAK,KAAK;AAMzC,MAAI,CAAC,QAAQ,GAAG,KAAK,GAAG;AACpB,UAAM,IAAI,MAAM,oBAAoB,QAAQ,OAAO,MAAM,aAAa,MAAM,WAAW,CAAC;AAChG;AAOO,SAAS,OAAO,GAAG;AACtB,MAAI;AACJ,OAAK,MAAM,GAAG,IAAIA,OAAK,MAAMC,OAAK,OAAO;AACrC;AACJ,SAAO;AACX;AAmBO,MAAM,UAAU,CAAC,OAAOA,SAAO,OAAO,CAAC,KAAKA;AAEnD,MAAM,MAAM,CAAC,QAAQ,IAAI,WAAW,GAAG;AACvC,MAAM,OAAO,CAAC,QAAQ,WAAW,KAAK,GAAG;AAQlC,SAAS,eAAe,SAAS,UAAU,QAAQ;AACtD,MAAI,OAAO,YAAY,YAAY,UAAU;AACzC,UAAM,IAAI,MAAM,0BAA0B;AAC9C,MAAI,OAAO,aAAa,YAAY,WAAW;AAC3C,UAAM,IAAI,MAAM,2BAA2B;AAC/C,MAAI,OAAO,WAAW;AAClB,UAAM,IAAI,MAAM,2BAA2B;AAE/C,MAAI,IAAI,IAAI,OAAO;AACnB,MAAI,IAAI,IAAI,OAAO;AACnB,MAAI,IAAI;AACR,QAAM,QAAQ,MAAM;AAChB,MAAE,KAAK,CAAC;AACR,MAAE,KAAK,CAAC;AACR,QAAI;AAAA,EACP;AACD,QAAM,IAAI,IAAI,MAAM,OAAO,GAAG,GAAG,GAAG,CAAC;AACrC,QAAM,SAAS,CAAC,OAAO,IAAI,CAAC,MAAM;AAE9B,QAAI,EAAE,KAAK,CAAC,CAAI,CAAC,GAAG,IAAI;AACxB,QAAI,EAAC;AACL,QAAI,KAAK,WAAW;AAChB;AACJ,QAAI,EAAE,KAAK,CAAC,CAAI,CAAC,GAAG,IAAI;AACxB,QAAI,EAAC;AAAA,EACR;AACD,QAAM,MAAM,MAAM;AAEd,QAAI,OAAO;AACP,YAAM,IAAI,MAAM,yBAAyB;AAC7C,QAAI,MAAM;AACV,UAAM,MAAM,CAAE;AACd,WAAO,MAAM,UAAU;AACnB,UAAI,EAAG;AACP,YAAM,KAAK,EAAE,MAAO;AACpB,UAAI,KAAK,EAAE;AACX,aAAO,EAAE;AAAA,IACrB;AACQ,WAAO,YAAY,GAAG,GAAG;AAAA,EAC5B;AACD,QAAM,WAAW,CAAC,MAAM,SAAS;AAC7B,UAAO;AACP,WAAO,IAAI;AACX,QAAI,MAAM;AACV,WAAO,EAAE,MAAM,KAAK,IAAK,CAAA;AACrB,aAAQ;AACZ,UAAO;AACP,WAAO;AAAA,EACV;AACD,SAAO;AACX;AAEA,MAAM,eAAe;AAAA,EACjB,QAAQ,CAAC,QAAQ,OAAO,QAAQ;AAAA,EAChC,UAAU,CAAC,QAAQ,OAAO,QAAQ;AAAA,EAClC,SAAS,CAAC,QAAQ,OAAO,QAAQ;AAAA,EACjC,QAAQ,CAAC,QAAQ,OAAO,QAAQ;AAAA,EAChC,oBAAoB,CAAC,QAAQ,OAAO,QAAQ,YAAY,QAAQ,GAAG;AAAA,EACnE,eAAe,CAAC,QAAQ,OAAO,cAAc,GAAG;AAAA,EAChD,OAAO,CAAC,QAAQ,MAAM,QAAQ,GAAG;AAAA,EACjC,OAAO,CAAC,KAAK,WAAW,OAAO,GAAG,QAAQ,GAAG;AAAA,EAC7C,MAAM,CAAC,QAAQ,OAAO,QAAQ,cAAc,OAAO,cAAc,IAAI,SAAS;AAClF;AAEO,SAAS,eAAe,QAAQ,YAAY,gBAAgB,CAAA,GAAI;AACnE,QAAM,aAAa,CAAC,WAAW,MAAM,eAAe;AAChD,UAAM,WAAW,aAAa,IAAI;AAClC,QAAI,OAAO,aAAa;AACpB,YAAM,IAAI,MAAM,4BAA4B;AAChD,UAAM,MAAM,OAAO,SAAS;AAC5B,QAAI,cAAc,QAAQ;AACtB;AACJ,QAAI,CAAC,SAAS,KAAK,MAAM,GAAG;AACxB,YAAM,IAAI,MAAM,WAAW,OAAO,SAAS,IAAI,2BAA2B,OAAO,WAAW,GAAG;AAAA,IAC3G;AAAA,EACK;AACD,aAAW,CAAC,WAAW,IAAI,KAAK,OAAO,QAAQ,UAAU;AACrD,eAAW,WAAW,MAAM,KAAK;AACrC,aAAW,CAAC,WAAW,IAAI,KAAK,OAAO,QAAQ,aAAa;AACxD,eAAW,WAAW,MAAM,IAAI;AACpC,SAAO;AACX;AAmBO,SAAS,SAAS,IAAI;AACzB,QAAM,MAAM,oBAAI,QAAS;AACzB,SAAO,CAAC,QAAQ,SAAS;AACrB,UAAM,MAAM,IAAI,IAAI,GAAG;AACvB,QAAI,QAAQ;AACR,aAAO;AACX,UAAM,WAAW,GAAG,KAAK,GAAG,IAAI;AAChC,QAAI,IAAI,KAAK,QAAQ;AACrB,WAAO;AAAA,EACV;AACL;AChVA,MAAMD,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGC,QAAsB,uBAAO,CAAC,GAAGC,QAAsB,uBAAO,CAAC;AAEvG,MAAMC,QAAsB,uBAAO,CAAC,GAAG,MAAsB,uBAAO,CAAC,GAAG,MAAsB,uBAAO,CAAC;AAE/F,SAAS,IAAI,GAAG,GAAG;AACtB,QAAM,SAAS,IAAI;AACnB,SAAO,UAAUJ,QAAM,SAAS,IAAI;AACxC;AAYO,SAAS,KAAK,GAAG,OAAO,QAAQ;AACnC,MAAI,MAAM;AACV,SAAO,UAAUA,OAAK;AAClB,WAAO;AACP,WAAO;AAAA,EACf;AACI,SAAO;AACX;AAKO,SAAS,OAAO,QAAQ,QAAQ;AACnC,MAAI,WAAWA;AACX,UAAM,IAAI,MAAM,kCAAkC;AACtD,MAAI,UAAUA;AACV,UAAM,IAAI,MAAM,4CAA4C,MAAM;AAEtE,MAAI,IAAI,IAAI,QAAQ,MAAM;AAC1B,MAAI,IAAI;AAEL,MAAC,IAAIA,OAAc,IAAIC;AAC1B,SAAO,MAAMD,OAAK;AAEd,UAAM,IAAI,IAAI;AACd,UAAM,IAAI,IAAI;AACd,UAAM,IAAI,IAAI,IAAI;AAGlB,QAAI,GAAG,IAAI,GAAG,IAAI,GAAU,IAAI;AAAA,EACxC;AACI,QAAM,MAAM;AACZ,MAAI,QAAQC;AACR,UAAM,IAAI,MAAM,wBAAwB;AAC5C,SAAO,IAAI,GAAG,MAAM;AACxB;AAKA,SAAS,UAAU,IAAI,GAAG;AACtB,QAAM,UAAU,GAAG,QAAQA,SAAOG;AAClC,QAAM,OAAO,GAAG,IAAI,GAAG,MAAM;AAE7B,MAAI,CAAC,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,CAAC;AACvB,UAAM,IAAI,MAAM,yBAAyB;AAC7C,SAAO;AACX;AACA,SAAS,UAAU,IAAI,GAAG;AACtB,QAAM,UAAU,GAAG,QAAQ,OAAO;AAClC,QAAM,KAAK,GAAG,IAAI,GAAGF,KAAG;AACxB,QAAM,IAAI,GAAG,IAAI,IAAI,MAAM;AAC3B,QAAM,KAAK,GAAG,IAAI,GAAG,CAAC;AACtB,QAAM,IAAI,GAAG,IAAI,GAAG,IAAI,IAAIA,KAAG,GAAG,CAAC;AACnC,QAAM,OAAO,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,CAAC;AACzC,MAAI,CAAC,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,CAAC;AACvB,UAAM,IAAI,MAAM,yBAAyB;AAC7C,SAAO;AACX;AA8BO,SAAS,cAAc,GAAG;AAE7B,MAAI,IAAI,OAAO,CAAC;AACZ,UAAM,IAAI,MAAM,qCAAqC;AAEzD,MAAI,IAAI,IAAID;AACZ,MAAI,IAAI;AACR,SAAO,IAAIC,UAAQF,OAAK;AACpB,SAAKE;AACL;AAAA,EACR;AAEI,MAAI,IAAIA;AACR,QAAM,MAAM,MAAM,CAAC;AACnB,SAAO,WAAW,KAAK,CAAC,MAAM,GAAG;AAG7B,QAAI,MAAM;AACN,YAAM,IAAI,MAAM,+CAA+C;AAAA,EAC3E;AAEI,MAAI,MAAM;AACN,WAAO;AAGX,MAAI,KAAK,IAAI,IAAI,GAAG,CAAC;AACrB,QAAM,UAAU,IAAID,SAAOC;AAC3B,SAAO,SAAS,YAAY,IAAI,GAAG;AAC/B,QAAI,GAAG,IAAI,CAAC;AACR,aAAO;AAEX,QAAI,WAAW,IAAI,CAAC,MAAM;AACtB,YAAM,IAAI,MAAM,yBAAyB;AAE7C,QAAI,IAAI;AACR,QAAI,IAAI,GAAG,IAAI,GAAG,KAAK,EAAE;AACzB,QAAI,IAAI,GAAG,IAAI,GAAG,CAAC;AACnB,QAAI,IAAI,GAAG,IAAI,GAAG,MAAM;AAGxB,WAAO,CAAC,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG;AACvB,UAAI,GAAG,IAAI,CAAC;AACR,eAAO,GAAG;AACd,UAAI,IAAI;AAER,UAAI,QAAQ,GAAG,IAAI,CAAC;AACpB,aAAO,CAAC,GAAG,IAAI,OAAO,GAAG,GAAG,GAAG;AAC3B;AACA,gBAAQ,GAAG,IAAI,KAAK;AACpB,YAAI,MAAM;AACN,gBAAM,IAAI,MAAM,yBAAyB;AAAA,MAC7D;AAEY,YAAM,WAAWD,SAAO,OAAO,IAAI,IAAI,CAAC;AACxC,YAAM,IAAI,GAAG,IAAI,GAAG,QAAQ;AAE5B,UAAI;AACJ,UAAI,GAAG,IAAI,CAAC;AACZ,UAAI,GAAG,IAAI,GAAG,CAAC;AACf,UAAI,GAAG,IAAI,GAAG,CAAC;AAAA,IAC3B;AACQ,WAAO;AAAA,EACV;AACL;AAWO,SAAS,OAAO,GAAG;AAEtB,MAAI,IAAIG,UAAQD;AACZ,WAAO;AAEX,MAAI,IAAI,QAAQ;AACZ,WAAO;AAGX,SAAO,cAAc,CAAC;AAC1B;AAIA,MAAM,eAAe;AAAA,EACjB;AAAA,EAAU;AAAA,EAAW;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAQ;AAAA,EAClD;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EACnC;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAC5B;AACO,SAAS,cAAc,OAAO;AACjC,QAAM,UAAU;AAAA,IACZ,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO;AAAA,IACP,MAAM;AAAA,EACT;AACD,QAAM,OAAO,aAAa,OAAO,CAAC,KAAK,QAAQ;AAC3C,QAAI,GAAG,IAAI;AACX,WAAO;AAAA,EACV,GAAE,OAAO;AACV,SAAO,eAAe,OAAO,IAAI;AACrC;AAMO,SAAS,MAAM,IAAI,KAAK,OAAO;AAClC,MAAI,QAAQH;AACR,UAAM,IAAI,MAAM,yCAAyC;AAC7D,MAAI,UAAUA;AACV,WAAO,GAAG;AACd,MAAI,UAAUC;AACV,WAAO;AACX,MAAI,IAAI,GAAG;AACX,MAAI,IAAI;AACR,SAAO,QAAQD,OAAK;AAChB,QAAI,QAAQC;AACR,UAAI,GAAG,IAAI,GAAG,CAAC;AACnB,QAAI,GAAG,IAAI,CAAC;AACZ,cAAUA;AAAAA,EAClB;AACI,SAAO;AACX;AAMO,SAAS,cAAc,IAAI,MAAM,WAAW,OAAO;AACtD,QAAM,WAAW,IAAI,MAAM,KAAK,MAAM,EAAE,KAAK,WAAW,GAAG,OAAO,MAAS;AAE3E,QAAM,gBAAgB,KAAK,OAAO,CAAC,KAAK,KAAK,MAAM;AAC/C,QAAI,GAAG,IAAI,GAAG;AACV,aAAO;AACX,aAAS,CAAC,IAAI;AACd,WAAO,GAAG,IAAI,KAAK,GAAG;AAAA,EAC9B,GAAO,GAAG,GAAG;AAET,QAAM,cAAc,GAAG,IAAI,aAAa;AAExC,OAAK,YAAY,CAAC,KAAK,KAAK,MAAM;AAC9B,QAAI,GAAG,IAAI,GAAG;AACV,aAAO;AACX,aAAS,CAAC,IAAI,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC;AACrC,WAAO,GAAG,IAAI,KAAK,GAAG;AAAA,EACzB,GAAE,WAAW;AACd,SAAO;AACX;AAcO,SAAS,WAAW,IAAI,GAAG;AAG9B,QAAM,UAAU,GAAG,QAAQA,SAAOC;AAClC,QAAM,UAAU,GAAG,IAAI,GAAG,MAAM;AAChC,QAAM,MAAM,GAAG,IAAI,SAAS,GAAG,GAAG;AAClC,QAAM,OAAO,GAAG,IAAI,SAAS,GAAG,IAAI;AACpC,QAAM,KAAK,GAAG,IAAI,SAAS,GAAG,IAAI,GAAG,GAAG,CAAC;AACzC,MAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;AAClB,UAAM,IAAI,MAAM,gCAAgC;AACpD,SAAO,MAAM,IAAI,OAAO,IAAI;AAChC;AAOO,SAAS,QAAQ,GAAG,YAAY;AAEnC,MAAI,eAAe;AACf,YAAQ,UAAU;AACtB,QAAM,cAAc,eAAe,SAAY,aAAa,EAAE,SAAS,CAAC,EAAE;AAC1E,QAAM,cAAc,KAAK,KAAK,cAAc,CAAC;AAC7C,SAAO,EAAE,YAAY,aAAa,YAAa;AACnD;AAgBO,SAAS,MAAM,OAAOG,SAAQ,OAAO,OAAO,QAAQ,IAAI;AAC3D,MAAI,SAASL;AACT,UAAM,IAAI,MAAM,4CAA4C,KAAK;AACrE,QAAM,EAAE,YAAY,MAAM,aAAa,MAAK,IAAK,QAAQ,OAAOK,OAAM;AACtE,MAAI,QAAQ;AACR,UAAM,IAAI,MAAM,gDAAgD;AACpE,MAAI;AACJ,QAAM,IAAI,OAAO,OAAO;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,QAAQ,IAAI;AAAA,IAClB,MAAML;AAAAA,IACN,KAAKC;AAAAA,IACL,QAAQ,CAAC,QAAQ,IAAI,KAAK,KAAK;AAAA,IAC/B,SAAS,CAAC,QAAQ;AACd,UAAI,OAAO,QAAQ;AACf,cAAM,IAAI,MAAM,iDAAiD,OAAO,GAAG;AAC/E,aAAOD,SAAO,OAAO,MAAM;AAAA,IAC9B;AAAA,IACD,KAAK,CAAC,QAAQ,QAAQA;AAAAA,IACtB,OAAO,CAAC,SAAS,MAAMC,WAASA;AAAAA,IAChC,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,KAAK;AAAA,IAC7B,KAAK,CAAC,KAAK,QAAQ,QAAQ;AAAA,IAC3B,KAAK,CAAC,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IAClC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IACvC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IACvC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IACvC,KAAK,CAAC,KAAK,UAAU,MAAM,GAAG,KAAK,KAAK;AAAA,IACxC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,OAAO,KAAK,KAAK,GAAG,KAAK;AAAA;AAAA,IAEtD,MAAM,CAAC,QAAQ,MAAM;AAAA,IACrB,MAAM,CAAC,KAAK,QAAQ,MAAM;AAAA,IAC1B,MAAM,CAAC,KAAK,QAAQ,MAAM;AAAA,IAC1B,MAAM,CAAC,KAAK,QAAQ,MAAM;AAAA,IAC1B,KAAK,CAAC,QAAQ,OAAO,KAAK,KAAK;AAAA,IAC/B,MAAM,MAAM,SACP,CAAC,MAAM;AACJ,UAAI,CAAC;AACD,gBAAQ,OAAO,KAAK;AACxB,aAAO,MAAM,GAAG,CAAC;AAAA,IACjC;AAAA,IACQ,SAAS,CAAC,QAAS,OAAO,gBAAgB,KAAK,KAAK,IAAI,gBAAgB,KAAK,KAAK;AAAA,IAClF,WAAW,CAAC,UAAU;AAClB,UAAI,MAAM,WAAW;AACjB,cAAM,IAAI,MAAM,+BAA+B,QAAQ,iBAAiB,MAAM,MAAM;AACxF,aAAO,OAAO,gBAAgB,KAAK,IAAI,gBAAgB,KAAK;AAAA,IAC/D;AAAA;AAAA,IAED,aAAa,CAAC,QAAQ,cAAc,GAAG,GAAG;AAAA;AAAA;AAAA,IAG1C,MAAM,CAAC,GAAG,GAAG,MAAO,IAAI,IAAI;AAAA,EACpC,CAAK;AACD,SAAO,OAAO,OAAO,CAAC;AAC1B;AAkCO,SAAS,oBAAoB,YAAY;AAC5C,MAAI,OAAO,eAAe;AACtB,UAAM,IAAI,MAAM,4BAA4B;AAChD,QAAM,YAAY,WAAW,SAAS,CAAC,EAAE;AACzC,SAAO,KAAK,KAAK,YAAY,CAAC;AAClC;AAQO,SAAS,iBAAiB,YAAY;AACzC,QAAM,SAAS,oBAAoB,UAAU;AAC7C,SAAO,SAAS,KAAK,KAAK,SAAS,CAAC;AACxC;AAcO,SAAS,eAAe,KAAK,YAAY,OAAO,OAAO;AAC1D,QAAM,MAAM,IAAI;AAChB,QAAM,WAAW,oBAAoB,UAAU;AAC/C,QAAM,SAAS,iBAAiB,UAAU;AAE1C,MAAI,MAAM,MAAM,MAAM,UAAU,MAAM;AAClC,UAAM,IAAI,MAAM,cAAc,SAAS,+BAA+B,GAAG;AAC7E,QAAM,MAAM,OAAO,gBAAgB,GAAG,IAAI,gBAAgB,GAAG;AAE7D,QAAM,UAAU,IAAI,KAAK,aAAaA,KAAG,IAAIA;AAC7C,SAAO,OAAO,gBAAgB,SAAS,QAAQ,IAAI,gBAAgB,SAAS,QAAQ;AACxF;AC/bA,MAAMD,QAAM,OAAO,CAAC;AACpB,MAAMC,QAAM,OAAO,CAAC;AACpB,SAAS,gBAAgB,WAAW,MAAM;AACtC,QAAM,MAAM,KAAK,OAAQ;AACzB,SAAO,YAAY,MAAM;AAC7B;AACA,SAAS,UAAU,GAAG,MAAM;AACxB,MAAI,CAAC,OAAO,cAAc,CAAC,KAAK,KAAK,KAAK,IAAI;AAC1C,UAAM,IAAI,MAAM,uCAAuC,OAAO,cAAc,CAAC;AACrF;AACA,SAAS,UAAU,GAAG,YAAY;AAC9B,YAAU,GAAG,UAAU;AACvB,QAAM,UAAU,KAAK,KAAK,aAAa,CAAC,IAAI;AAC5C,QAAM,aAAa,MAAM,IAAI;AAC7B,QAAM,YAAY,KAAK;AACvB,QAAM,OAAO,QAAQ,CAAC;AACtB,QAAM,UAAU,OAAO,CAAC;AACxB,SAAO,EAAE,SAAS,YAAY,MAAM,WAAW,QAAS;AAC5D;AACA,SAAS,YAAY,GAAG,QAAQ,OAAO;AACnC,QAAM,EAAE,YAAY,MAAM,WAAW,QAAS,IAAG;AACjD,MAAI,QAAQ,OAAO,IAAI,IAAI;AAC3B,MAAI,QAAQ,KAAK;AAMjB,MAAI,QAAQ,YAAY;AAEpB,aAAS;AACT,aAASA;AAAAA,EACjB;AACI,QAAM,cAAc,SAAS;AAC7B,QAAM,SAAS,cAAc,KAAK,IAAI,KAAK,IAAI;AAC/C,QAAM,SAAS,UAAU;AACzB,QAAM,QAAQ,QAAQ;AACtB,QAAM,SAAS,SAAS,MAAM;AAC9B,QAAM,UAAU;AAChB,SAAO,EAAE,OAAO,QAAQ,QAAQ,OAAO,QAAQ,QAAS;AAC5D;AACA,SAAS,kBAAkB,QAAQ,GAAG;AAClC,MAAI,CAAC,MAAM,QAAQ,MAAM;AACrB,UAAM,IAAI,MAAM,gBAAgB;AACpC,SAAO,QAAQ,CAAC,GAAG,MAAM;AACrB,QAAI,EAAE,aAAa;AACf,YAAM,IAAI,MAAM,4BAA4B,CAAC;AAAA,EACzD,CAAK;AACL;AACA,SAAS,mBAAmB,SAAS,OAAO;AACxC,MAAI,CAAC,MAAM,QAAQ,OAAO;AACtB,UAAM,IAAI,MAAM,2BAA2B;AAC/C,UAAQ,QAAQ,CAAC,GAAG,MAAM;AACtB,QAAI,CAAC,MAAM,QAAQ,CAAC;AAChB,YAAM,IAAI,MAAM,6BAA6B,CAAC;AAAA,EAC1D,CAAK;AACL;AAIA,MAAM,mBAAmB,oBAAI,QAAS;AACtC,MAAM,mBAAmB,oBAAI,QAAS;AACtC,SAAS,KAAK,GAAG;AACb,SAAO,iBAAiB,IAAI,CAAC,KAAK;AACtC;AAeO,SAAS,KAAK,GAAG,MAAM;AAC1B,SAAO;AAAA,IACH;AAAA,IACA,eAAe,KAAK;AAChB,aAAO,KAAK,GAAG,MAAM;AAAA,IACxB;AAAA;AAAA,IAED,aAAa,KAAK,GAAG,IAAI,EAAE,MAAM;AAC7B,UAAI,IAAI;AACR,aAAO,IAAID,OAAK;AACZ,YAAI,IAAIC;AACJ,cAAI,EAAE,IAAI,CAAC;AACf,YAAI,EAAE,OAAQ;AACd,cAAMA;AAAAA,MACtB;AACY,aAAO;AAAA,IACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAaD,iBAAiB,KAAK,GAAG;AACrB,YAAM,EAAE,SAAS,WAAU,IAAK,UAAU,GAAG,IAAI;AACjD,YAAM,SAAS,CAAE;AACjB,UAAI,IAAI;AACR,UAAI,OAAO;AACX,eAAS,SAAS,GAAG,SAAS,SAAS,UAAU;AAC7C,eAAO;AACP,eAAO,KAAK,IAAI;AAEhB,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACjC,iBAAO,KAAK,IAAI,CAAC;AACjB,iBAAO,KAAK,IAAI;AAAA,QACpC;AACgB,YAAI,KAAK,OAAQ;AAAA,MACjC;AACY,aAAO;AAAA,IACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQD,KAAK,GAAG,aAAa,GAAG;AAOpB,UAAI,IAAI,EAAE;AACV,UAAI,IAAI,EAAE;AAMV,YAAM,KAAK,UAAU,GAAG,IAAI;AAC5B,eAAS,SAAS,GAAG,SAAS,GAAG,SAAS,UAAU;AAEhD,cAAM,EAAE,OAAO,QAAQ,QAAQ,OAAO,QAAQ,QAAO,IAAK,YAAY,GAAG,QAAQ,EAAE;AACnF,YAAI;AACJ,YAAI,QAAQ;AAGR,cAAI,EAAE,IAAI,gBAAgB,QAAQ,YAAY,OAAO,CAAC,CAAC;AAAA,QAC3E,OACqB;AAED,cAAI,EAAE,IAAI,gBAAgB,OAAO,YAAY,MAAM,CAAC,CAAC;AAAA,QACzE;AAAA,MACA;AAIY,aAAO,EAAE,GAAG,EAAG;AAAA,IAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASD,WAAW,GAAG,aAAa,GAAG,MAAM,EAAE,MAAM;AACxC,YAAM,KAAK,UAAU,GAAG,IAAI;AAC5B,eAAS,SAAS,GAAG,SAAS,GAAG,SAAS,UAAU;AAChD,YAAI,MAAMD;AACN;AACJ,cAAM,EAAE,OAAO,QAAQ,QAAQ,MAAO,IAAG,YAAY,GAAG,QAAQ,EAAE;AAClE,YAAI;AACJ,YAAI,QAAQ;AAGR;AAAA,QACpB,OACqB;AACD,gBAAM,OAAO,YAAY,MAAM;AAC/B,gBAAM,IAAI,IAAI,QAAQ,KAAK,OAAM,IAAK,IAAI;AAAA,QAC9D;AAAA,MACA;AACY,aAAO;AAAA,IACV;AAAA,IACD,eAAe,GAAG,GAAG,WAAW;AAE5B,UAAI,OAAO,iBAAiB,IAAI,CAAC;AACjC,UAAI,CAAC,MAAM;AACP,eAAO,KAAK,iBAAiB,GAAG,CAAC;AACjC,YAAI,MAAM;AACN,2BAAiB,IAAI,GAAG,UAAU,IAAI,CAAC;AAAA,MAC3D;AACY,aAAO;AAAA,IACV;AAAA,IACD,WAAW,GAAG,GAAG,WAAW;AACxB,YAAM,IAAI,KAAK,CAAC;AAChB,aAAO,KAAK,KAAK,GAAG,KAAK,eAAe,GAAG,GAAG,SAAS,GAAG,CAAC;AAAA,IAC9D;AAAA,IACD,iBAAiB,GAAG,GAAG,WAAW,MAAM;AACpC,YAAM,IAAI,KAAK,CAAC;AAChB,UAAI,MAAM;AACN,eAAO,KAAK,aAAa,GAAG,GAAG,IAAI;AACvC,aAAO,KAAK,WAAW,GAAG,KAAK,eAAe,GAAG,GAAG,SAAS,GAAG,GAAG,IAAI;AAAA,IAC1E;AAAA;AAAA;AAAA;AAAA,IAID,cAAc,GAAG,GAAG;AAChB,gBAAU,GAAG,IAAI;AACjB,uBAAiB,IAAI,GAAG,CAAC;AACzB,uBAAiB,OAAO,CAAC;AAAA,IAC5B;AAAA,EACJ;AACL;AAWO,SAAS,UAAU,GAAG,QAAQ,QAAQ,SAAS;AAOlD,oBAAkB,QAAQ,CAAC;AAC3B,qBAAmB,SAAS,MAAM;AAClC,QAAM,UAAU,OAAO;AACvB,QAAM,UAAU,QAAQ;AACxB,MAAI,YAAY;AACZ,UAAM,IAAI,MAAM,qDAAqD;AAEzE,QAAM,OAAO,EAAE;AACf,QAAM,QAAQ,OAAO,OAAO,OAAO,CAAC;AACpC,MAAI,aAAa;AACjB,MAAI,QAAQ;AACR,iBAAa,QAAQ;AAAA,WAChB,QAAQ;AACb,iBAAa,QAAQ;AAAA,WAChB,QAAQ;AACb,iBAAa;AACjB,QAAM,OAAO,QAAQ,UAAU;AAC/B,QAAM,UAAU,IAAI,MAAM,OAAO,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI;AACrD,QAAM,WAAW,KAAK,OAAO,OAAO,OAAO,KAAK,UAAU,IAAI;AAC9D,MAAI,MAAM;AACV,WAAS,IAAI,UAAU,KAAK,GAAG,KAAK,YAAY;AAC5C,YAAQ,KAAK,IAAI;AACjB,aAAS,IAAI,GAAG,IAAI,SAAS,KAAK;AAC9B,YAAM,SAAS,QAAQ,CAAC;AACxB,YAAMM,SAAQ,OAAQ,UAAU,OAAO,CAAC,IAAK,IAAI;AACjD,cAAQA,MAAK,IAAI,QAAQA,MAAK,EAAE,IAAI,OAAO,CAAC,CAAC;AAAA,IACzD;AACQ,QAAI,OAAO;AAEX,aAAS,IAAI,QAAQ,SAAS,GAAG,OAAO,MAAM,IAAI,GAAG,KAAK;AACtD,aAAO,KAAK,IAAI,QAAQ,CAAC,CAAC;AAC1B,aAAO,KAAK,IAAI,IAAI;AAAA,IAChC;AACQ,UAAM,IAAI,IAAI,IAAI;AAClB,QAAI,MAAM;AACN,eAAS,IAAI,GAAG,IAAI,YAAY;AAC5B,cAAM,IAAI,OAAQ;AAAA,EAClC;AACI,SAAO;AACX;AAgFO,SAAS,cAAc,OAAO;AACjC,gBAAc,MAAM,EAAE;AACtB,iBAAe,OAAO;AAAA,IAClB,GAAG;AAAA,IACH,GAAG;AAAA,IACH,IAAI;AAAA,IACJ,IAAI;AAAA,EACZ,GAAO;AAAA,IACC,YAAY;AAAA,IACZ,aAAa;AAAA,EACrB,CAAK;AAED,SAAO,OAAO,OAAO;AAAA,IACjB,GAAG,QAAQ,MAAM,GAAG,MAAM,UAAU;AAAA,IACpC,GAAG;AAAA,IACH,GAAG,EAAE,GAAG,MAAM,GAAG,MAAO;AAAA,EAChC,CAAK;AACL;AClVA,SAAS,mBAAmB,MAAM;AAC9B,MAAI,KAAK,SAAS;AACd,UAAM,QAAQ,KAAK,IAAI;AAC3B,MAAI,KAAK,YAAY;AACjB,UAAM,WAAW,KAAK,OAAO;AACrC;AACA,SAAS,kBAAkB,OAAO;AAC9B,QAAM,OAAO,cAAc,KAAK;AAChC,iBAAe,MAAM;AAAA,IACjB,GAAG;AAAA,IACH,GAAG;AAAA,EACX,GAAO;AAAA,IACC,oBAAoB;AAAA,IACpB,0BAA0B;AAAA,IAC1B,eAAe;AAAA,IACf,WAAW;AAAA,IACX,eAAe;AAAA,IACf,SAAS;AAAA,IACT,gBAAgB;AAAA,EACxB,CAAK;AACD,QAAM,EAAE,MAAM,IAAI,EAAG,IAAG;AACxB,MAAI,MAAM;AACN,QAAI,CAAC,GAAG,IAAI,GAAG,GAAG,IAAI,GAAG;AACrB,YAAM,IAAI,MAAM,iCAAiC;AAAA,IAC7D;AACQ,QAAI,OAAO,SAAS,YAChB,OAAO,KAAK,SAAS,YACrB,OAAO,KAAK,gBAAgB,YAAY;AACxC,YAAM,IAAI,MAAM,mEAAmE;AAAA,IAC/F;AAAA,EACA;AACI,SAAO,OAAO,OAAO,EAAE,GAAG,KAAI,CAAE;AACpC;AACO,MAAM,eAAe,MAAM;AAAA,EAC9B,YAAY,IAAI,IAAI;AAChB,UAAM,CAAC;AAAA,EACf;AACA;AAQO,MAAM,MAAM;AAAA;AAAA,EAEf,KAAK;AAAA;AAAA,EAEL,MAAM;AAAA,IACF,QAAQ,CAAC,KAAK,SAAS;AACnB,YAAM,EAAE,KAAK,EAAC,IAAK;AACnB,UAAI,MAAM,KAAK,MAAM;AACjB,cAAM,IAAI,EAAE,uBAAuB;AACvC,UAAI,KAAK,SAAS;AACd,cAAM,IAAI,EAAE,2BAA2B;AAC3C,YAAM,UAAU,KAAK,SAAS;AAC9B,YAAM,MAAM,oBAAoB,OAAO;AACvC,UAAK,IAAI,SAAS,IAAK;AACnB,cAAM,IAAI,EAAE,sCAAsC;AAEtD,YAAM,SAAS,UAAU,MAAM,oBAAqB,IAAI,SAAS,IAAK,GAAG,IAAI;AAC7E,YAAM,IAAI,oBAAoB,GAAG;AACjC,aAAO,IAAI,SAAS,MAAM;AAAA,IAC7B;AAAA;AAAA,IAED,OAAO,KAAK,MAAM;AACd,YAAM,EAAE,KAAK,EAAC,IAAK;AACnB,UAAI,MAAM;AACV,UAAI,MAAM,KAAK,MAAM;AACjB,cAAM,IAAI,EAAE,uBAAuB;AACvC,UAAI,KAAK,SAAS,KAAK,KAAK,KAAK,MAAM;AACnC,cAAM,IAAI,EAAE,uBAAuB;AACvC,YAAM,QAAQ,KAAK,KAAK;AACxB,YAAM,SAAS,CAAC,EAAE,QAAQ;AAC1B,UAAI,SAAS;AACb,UAAI,CAAC;AACD,iBAAS;AAAA,WACR;AAED,cAAM,SAAS,QAAQ;AACvB,YAAI,CAAC;AACD,gBAAM,IAAI,EAAE,mDAAmD;AACnE,YAAI,SAAS;AACT,gBAAM,IAAI,EAAE,0CAA0C;AAC1D,cAAM,cAAc,KAAK,SAAS,KAAK,MAAM,MAAM;AACnD,YAAI,YAAY,WAAW;AACvB,gBAAM,IAAI,EAAE,uCAAuC;AACvD,YAAI,YAAY,CAAC,MAAM;AACnB,gBAAM,IAAI,EAAE,sCAAsC;AACtD,mBAAW,KAAK;AACZ,mBAAU,UAAU,IAAK;AAC7B,eAAO;AACP,YAAI,SAAS;AACT,gBAAM,IAAI,EAAE,wCAAwC;AAAA,MACxE;AACY,YAAM,IAAI,KAAK,SAAS,KAAK,MAAM,MAAM;AACzC,UAAI,EAAE,WAAW;AACb,cAAM,IAAI,EAAE,gCAAgC;AAChD,aAAO,EAAE,GAAG,GAAG,KAAK,SAAS,MAAM,MAAM,EAAG;AAAA,IAC/C;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,MAAM;AAAA,IACF,OAAO,KAAK;AACR,YAAM,EAAE,KAAK,EAAC,IAAK;AACnB,UAAI,MAAMN;AACN,cAAM,IAAI,EAAE,4CAA4C;AAC5D,UAAI,MAAM,oBAAoB,GAAG;AAEjC,UAAI,OAAO,SAAS,IAAI,CAAC,GAAG,EAAE,IAAI;AAC9B,cAAM,OAAO;AACjB,UAAI,IAAI,SAAS;AACb,cAAM,IAAI,EAAE,gDAAgD;AAChE,aAAO;AAAA,IACV;AAAA,IACD,OAAO,MAAM;AACT,YAAM,EAAE,KAAK,EAAC,IAAK;AACnB,UAAI,KAAK,CAAC,IAAI;AACV,cAAM,IAAI,EAAE,qCAAqC;AACrD,UAAI,KAAK,CAAC,MAAM,KAAQ,EAAE,KAAK,CAAC,IAAI;AAChC,cAAM,IAAI,EAAE,qDAAqD;AACrE,aAAO,gBAAgB,IAAI;AAAA,IAC9B;AAAA,EACJ;AAAA,EACD,MAAM,KAAK;AAEP,UAAM,EAAE,KAAK,GAAG,MAAM,KAAK,MAAM,IAAG,IAAK;AACzC,UAAM,OAAO,YAAY,aAAa,GAAG;AACzC,UAAM,EAAE,GAAG,UAAU,GAAG,aAAc,IAAG,IAAI,OAAO,IAAM,IAAI;AAC9D,QAAI,aAAa;AACb,YAAM,IAAI,EAAE,6CAA6C;AAC7D,UAAM,EAAE,GAAG,QAAQ,GAAG,WAAY,IAAG,IAAI,OAAO,GAAM,QAAQ;AAC9D,UAAM,EAAE,GAAG,QAAQ,GAAG,WAAY,IAAG,IAAI,OAAO,GAAM,UAAU;AAChE,QAAI,WAAW;AACX,YAAM,IAAI,EAAE,6CAA6C;AAC7D,WAAO,EAAE,GAAG,IAAI,OAAO,MAAM,GAAG,GAAG,IAAI,OAAO,MAAM,EAAG;AAAA,EAC1D;AAAA,EACD,WAAW,KAAK;AACZ,UAAM,EAAE,MAAM,KAAK,MAAM,IAAK,IAAG;AACjC,UAAM,KAAK,IAAI,OAAO,GAAM,IAAI,OAAO,IAAI,CAAC,CAAC;AAC7C,UAAM,KAAK,IAAI,OAAO,GAAM,IAAI,OAAO,IAAI,CAAC,CAAC;AAC7C,UAAM,MAAM,KAAK;AACjB,WAAO,IAAI,OAAO,IAAM,GAAG;AAAA,EAC9B;AACL;AACA,SAAS,cAAc,KAAK,MAAM;AAC9B,SAAO,WAAW,gBAAgB,KAAK,IAAI,CAAC;AAChD;AAGK,MAACA,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC;AAAS,OAAO,CAAC;AAAG,MAAA,MAAM,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC;AACjF,SAAS,kBAAkB,MAAM;AACpC,QAAM,QAAQ,kBAAkB,IAAI;AACpC,QAAM,EAAE,GAAI,IAAG;AACf,QAAM,KAAK,MAAM,MAAM,GAAG,MAAM,UAAU;AAC1C,QAAM,UAAU,MAAM,YACjB,CAAC,IAAI,OAAO,kBAAkB;AAC3B,UAAM,IAAI,MAAM,SAAU;AAC1B,WAAO,YAAY,WAAW,KAAK,CAAC,CAAI,CAAC,GAAG,GAAG,QAAQ,EAAE,CAAC,GAAG,GAAG,QAAQ,EAAE,CAAC,CAAC;AAAA,EACxF;AACI,QAAM,YAAY,MAAM,cACnB,CAAC,UAAU;AAER,UAAM,OAAO,MAAM,SAAS,CAAC;AAE7B,UAAM,IAAI,GAAG,UAAU,KAAK,SAAS,GAAG,GAAG,KAAK,CAAC;AACjD,UAAM,IAAI,GAAG,UAAU,KAAK,SAAS,GAAG,OAAO,IAAI,GAAG,KAAK,CAAC;AAC5D,WAAO,EAAE,GAAG,EAAG;AAAA,EAC3B;AAKI,WAAS,oBAAoB,GAAG;AAC5B,UAAM,EAAE,GAAG,EAAC,IAAK;AACjB,UAAM,KAAK,GAAG,IAAI,CAAC;AACnB,UAAM,KAAK,GAAG,IAAI,IAAI,CAAC;AACvB,WAAO,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC;AAAA,EACjD;AACI,WAAS,UAAU,GAAG,GAAG;AACrB,UAAM,OAAO,GAAG,IAAI,CAAC;AACrB,UAAM,QAAQ,oBAAoB,CAAC;AACnC,WAAO,GAAG,IAAI,MAAM,KAAK;AAAA,EACjC;AAGI,MAAI,CAAC,UAAU,MAAM,IAAI,MAAM,EAAE;AAC7B,UAAM,IAAI,MAAM,mCAAmC;AAGvD,QAAM,OAAO,GAAG,IAAI,GAAG,IAAI,MAAM,GAAG,GAAG,GAAG,GAAG;AAC7C,QAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,MAAM,CAAC,GAAG,OAAO,EAAE,CAAC;AAChD,MAAI,GAAG,IAAI,GAAG,IAAI,MAAM,KAAK,CAAC;AAC1B,UAAM,IAAI,MAAM,0BAA0B;AAE9C,WAAS,mBAAmB,KAAK;AAC7B,WAAO,QAAQ,KAAKA,OAAK,MAAM,CAAC;AAAA,EACxC;AAGI,WAAS,uBAAuB,KAAK;AACjC,UAAM,EAAE,0BAA0B,SAAS,aAAa,gBAAgB,GAAG,EAAC,IAAK;AACjF,QAAI,WAAW,OAAO,QAAQ,UAAU;AACpC,UAAI,QAAQ,GAAG;AACX,cAAM,WAAW,GAAG;AAExB,UAAI,OAAO,QAAQ,YAAY,CAAC,QAAQ,SAAS,IAAI,MAAM;AACvD,cAAM,IAAI,MAAM,qBAAqB;AACzC,YAAM,IAAI,SAAS,cAAc,GAAG,GAAG;AAAA,IACnD;AACQ,QAAI;AACJ,QAAI;AACA,YACI,OAAO,QAAQ,WACT,MACA,gBAAgB,YAAY,eAAe,KAAK,WAAW,CAAC;AAAA,IAClF,SACe,OAAO;AACV,YAAM,IAAI,MAAM,0CAA0C,cAAc,iBAAiB,OAAO,GAAG;AAAA,IAC/G;AACQ,QAAI;AACA,YAAM,IAAI,KAAK,CAAC;AACpB,aAAS,eAAe,KAAKA,OAAK,CAAC;AACnC,WAAO;AAAA,EACf;AACI,WAAS,UAAU,OAAO;AACtB,QAAI,EAAE,iBAAiB;AACnB,YAAM,IAAI,MAAM,0BAA0B;AAAA,EACtD;AAKI,QAAM,eAAe,SAAS,CAAC,GAAG,OAAO;AACrC,UAAM,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,EAAC,IAAK;AAEhC,QAAI,GAAG,IAAI,GAAG,GAAG,GAAG;AAChB,aAAO,EAAE,GAAG,EAAG;AACnB,UAAM,MAAM,EAAE,IAAK;AAGnB,QAAI,MAAM;AACN,WAAK,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAChC,UAAM,KAAK,GAAG,IAAI,GAAG,EAAE;AACvB,UAAM,KAAK,GAAG,IAAI,GAAG,EAAE;AACvB,UAAM,KAAK,GAAG,IAAI,GAAG,EAAE;AACvB,QAAI;AACA,aAAO,EAAE,GAAG,GAAG,MAAM,GAAG,GAAG,KAAM;AACrC,QAAI,CAAC,GAAG,IAAI,IAAI,GAAG,GAAG;AAClB,YAAM,IAAI,MAAM,kBAAkB;AACtC,WAAO,EAAE,GAAG,IAAI,GAAG,GAAI;AAAA,EAC/B,CAAK;AAGD,QAAM,kBAAkB,SAAS,CAAC,MAAM;AACpC,QAAI,EAAE,OAAO;AAIT,UAAI,MAAM,sBAAsB,CAAC,GAAG,IAAI,EAAE,EAAE;AACxC;AACJ,YAAM,IAAI,MAAM,iBAAiB;AAAA,IAC7C;AAEQ,UAAM,EAAE,GAAG,MAAM,EAAE,SAAU;AAE7B,QAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC;AAC/B,YAAM,IAAI,MAAM,0BAA0B;AAC9C,QAAI,CAAC,UAAU,GAAG,CAAC;AACf,YAAM,IAAI,MAAM,mCAAmC;AACvD,QAAI,CAAC,EAAE,cAAe;AAClB,YAAM,IAAI,MAAM,wCAAwC;AAC5D,WAAO;AAAA,EACf,CAAK;AAAA,EAMD,MAAM,MAAM;AAAA,IACR,YAAY,IAAI,IAAI,IAAI;AACpB,UAAI,MAAM,QAAQ,CAAC,GAAG,QAAQ,EAAE;AAC5B,cAAM,IAAI,MAAM,YAAY;AAChC,UAAI,MAAM,QAAQ,CAAC,GAAG,QAAQ,EAAE,KAAK,GAAG,IAAI,EAAE;AAC1C,cAAM,IAAI,MAAM,YAAY;AAChC,UAAI,MAAM,QAAQ,CAAC,GAAG,QAAQ,EAAE;AAC5B,cAAM,IAAI,MAAM,YAAY;AAChC,WAAK,KAAK;AACV,WAAK,KAAK;AACV,WAAK,KAAK;AACV,aAAO,OAAO,IAAI;AAAA,IAC9B;AAAA;AAAA;AAAA,IAGQ,OAAO,WAAW,GAAG;AACjB,YAAM,EAAE,GAAG,EAAG,IAAG,KAAK,CAAE;AACxB,UAAI,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC;AACrC,cAAM,IAAI,MAAM,sBAAsB;AAC1C,UAAI,aAAa;AACb,cAAM,IAAI,MAAM,8BAA8B;AAClD,YAAM,MAAM,CAAC,MAAM,GAAG,IAAI,GAAG,GAAG,IAAI;AAEpC,UAAI,IAAI,CAAC,KAAK,IAAI,CAAC;AACf,eAAO,MAAM;AACjB,aAAO,IAAI,MAAM,GAAG,GAAG,GAAG,GAAG;AAAA,IACzC;AAAA,IACQ,IAAI,IAAI;AACJ,aAAO,KAAK,SAAQ,EAAG;AAAA,IACnC;AAAA,IACQ,IAAI,IAAI;AACJ,aAAO,KAAK,SAAQ,EAAG;AAAA,IACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOQ,OAAO,WAAW,QAAQ;AACtB,YAAM,QAAQ,cAAc,IAAI,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AACvD,aAAO,OAAO,IAAI,CAAC,GAAG,MAAM,EAAE,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,MAAM,UAAU;AAAA,IAClF;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,OAAO,QAAQ,KAAK;AAChB,YAAM,IAAI,MAAM,WAAW,UAAU,YAAY,YAAY,GAAG,CAAC,CAAC;AAClE,QAAE,eAAgB;AAClB,aAAO;AAAA,IACnB;AAAA;AAAA,IAEQ,OAAO,eAAe,YAAY;AAC9B,aAAO,MAAM,KAAK,SAAS,uBAAuB,UAAU,CAAC;AAAA,IACzE;AAAA;AAAA,IAEQ,OAAO,IAAI,QAAQ,SAAS;AACxB,aAAO,UAAU,OAAO,IAAI,QAAQ,OAAO;AAAA,IACvD;AAAA;AAAA,IAEQ,eAAe,YAAY;AACvB,WAAK,cAAc,MAAM,UAAU;AAAA,IAC/C;AAAA;AAAA,IAEQ,iBAAiB;AACb,sBAAgB,IAAI;AAAA,IAChC;AAAA,IACQ,WAAW;AACP,YAAM,EAAE,EAAC,IAAK,KAAK,SAAU;AAC7B,UAAI,GAAG;AACH,eAAO,CAAC,GAAG,MAAM,CAAC;AACtB,YAAM,IAAI,MAAM,6BAA6B;AAAA,IACzD;AAAA;AAAA;AAAA;AAAA,IAIQ,OAAO,OAAO;AACV,gBAAU,KAAK;AACf,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,YAAM,KAAK,GAAG,IAAI,GAAG,IAAI,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;AAChD,YAAM,KAAK,GAAG,IAAI,GAAG,IAAI,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;AAChD,aAAO,MAAM;AAAA,IACzB;AAAA;AAAA;AAAA;AAAA,IAIQ,SAAS;AACL,aAAO,IAAI,MAAM,KAAK,IAAI,GAAG,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE;AAAA,IAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,SAAS;AACL,YAAM,EAAE,GAAG,EAAC,IAAK;AACjB,YAAM,KAAK,GAAG,IAAI,GAAG,GAAG;AACxB,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,UAAI,KAAK,GAAG,MAAM,KAAK,GAAG,MAAM,KAAK,GAAG;AACxC,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,GAAG,EAAE;AACjB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,GAAG,EAAE;AACjB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,GAAG,EAAE;AACjB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAO,IAAI,MAAM,IAAI,IAAI,EAAE;AAAA,IACvC;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,IAAI,OAAO;AACP,gBAAU,KAAK;AACf,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,UAAI,KAAK,GAAG,MAAM,KAAK,GAAG,MAAM,KAAK,GAAG;AACxC,YAAM,IAAI,MAAM;AAChB,YAAM,KAAK,GAAG,IAAI,MAAM,GAAG,GAAG;AAC9B,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,UAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,GAAG,EAAE;AACjB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,GAAG,EAAE;AACjB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,GAAG,EAAE;AACjB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,WAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAO,IAAI,MAAM,IAAI,IAAI,EAAE;AAAA,IACvC;AAAA,IACQ,SAAS,OAAO;AACZ,aAAO,KAAK,IAAI,MAAM,OAAM,CAAE;AAAA,IAC1C;AAAA,IACQ,MAAM;AACF,aAAO,KAAK,OAAO,MAAM,IAAI;AAAA,IACzC;AAAA,IACQ,KAAK,GAAG;AACJ,aAAO,KAAK,WAAW,MAAM,GAAG,MAAM,UAAU;AAAA,IAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMQ,eAAe,IAAI;AACf,YAAM,EAAE,MAAAM,OAAM,GAAG,EAAG,IAAG;AACvB,eAAS,UAAU,IAAIP,OAAK,CAAC;AAC7B,YAAM,IAAI,MAAM;AAChB,UAAI,OAAOA;AACP,eAAO;AACX,UAAI,KAAK,SAAS,OAAOC;AACrB,eAAO;AAEX,UAAI,CAACM,SAAQ,KAAK,eAAe,IAAI;AACjC,eAAO,KAAK,iBAAiB,MAAM,IAAI,MAAM,UAAU;AAG3D,UAAI,EAAE,OAAO,IAAI,OAAO,GAAE,IAAKA,MAAK,YAAY,EAAE;AAClD,UAAI,MAAM;AACV,UAAI,MAAM;AACV,UAAI,IAAI;AACR,aAAO,KAAKP,SAAO,KAAKA,OAAK;AACzB,YAAI,KAAKC;AACL,gBAAM,IAAI,IAAI,CAAC;AACnB,YAAI,KAAKA;AACL,gBAAM,IAAI,IAAI,CAAC;AACnB,YAAI,EAAE,OAAQ;AACd,eAAOA;AACP,eAAOA;AAAAA,MACvB;AACY,UAAI;AACA,cAAM,IAAI,OAAQ;AACtB,UAAI;AACA,cAAM,IAAI,OAAQ;AACtB,YAAM,IAAI,MAAM,GAAG,IAAI,IAAI,IAAIM,MAAK,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE;AACzD,aAAO,IAAI,IAAI,GAAG;AAAA,IAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUQ,SAAS,QAAQ;AACb,YAAM,EAAE,MAAAA,OAAM,GAAG,EAAG,IAAG;AACvB,eAAS,UAAU,QAAQN,OAAK,CAAC;AACjC,UAAI,OAAO;AAEX,UAAIM,OAAM;AACN,cAAM,EAAE,OAAO,IAAI,OAAO,GAAE,IAAKA,MAAK,YAAY,MAAM;AACxD,YAAI,EAAE,GAAG,KAAK,GAAG,IAAG,IAAK,KAAK,KAAK,EAAE;AACrC,YAAI,EAAE,GAAG,KAAK,GAAG,IAAG,IAAK,KAAK,KAAK,EAAE;AACrC,cAAM,KAAK,gBAAgB,OAAO,GAAG;AACrC,cAAM,KAAK,gBAAgB,OAAO,GAAG;AACrC,cAAM,IAAI,MAAM,GAAG,IAAI,IAAI,IAAIA,MAAK,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE;AACzD,gBAAQ,IAAI,IAAI,GAAG;AACnB,eAAO,IAAI,IAAI,GAAG;AAAA,MAClC,OACiB;AACD,cAAM,EAAE,GAAG,EAAC,IAAK,KAAK,KAAK,MAAM;AACjC,gBAAQ;AACR,eAAO;AAAA,MACvB;AAEY,aAAO,MAAM,WAAW,CAAC,OAAO,IAAI,CAAC,EAAE,CAAC;AAAA,IACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOQ,qBAAqB,GAAG,GAAG,GAAG;AAC1B,YAAM,IAAI,MAAM;AAChB,YAAM,MAAM,CAAC,GAAGC,OACVA,OAAMR,SAAOQ,OAAMP,SAAO,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,eAAeO,EAAC,IAAI,EAAE,SAASA,EAAC;AACjF,YAAM,MAAM,IAAI,MAAM,CAAC,EAAE,IAAI,IAAI,GAAG,CAAC,CAAC;AACtC,aAAO,IAAI,QAAQ,SAAY;AAAA,IAC3C;AAAA;AAAA;AAAA;AAAA,IAIQ,SAAS,IAAI;AACT,aAAO,aAAa,MAAM,EAAE;AAAA,IACxC;AAAA,IACQ,gBAAgB;AACZ,YAAM,EAAE,GAAG,UAAU,cAAe,IAAG;AACvC,UAAI,aAAaP;AACb,eAAO;AACX,UAAI;AACA,eAAO,cAAc,OAAO,IAAI;AACpC,YAAM,IAAI,MAAM,8DAA8D;AAAA,IAC1F;AAAA,IACQ,gBAAgB;AACZ,YAAM,EAAE,GAAG,UAAU,cAAe,IAAG;AACvC,UAAI,aAAaA;AACb,eAAO;AACX,UAAI;AACA,eAAO,cAAc,OAAO,IAAI;AACpC,aAAO,KAAK,eAAe,MAAM,CAAC;AAAA,IAC9C;AAAA,IACQ,WAAW,eAAe,MAAM;AAC5B,YAAM,gBAAgB,YAAY;AAClC,WAAK,eAAgB;AACrB,aAAO,QAAQ,OAAO,MAAM,YAAY;AAAA,IACpD;AAAA,IACQ,MAAM,eAAe,MAAM;AACvB,YAAM,gBAAgB,YAAY;AAClC,aAAO,WAAW,KAAK,WAAW,YAAY,CAAC;AAAA,IAC3D;AAAA,EACA;AAEI,QAAM,OAAO,IAAI,MAAM,MAAM,IAAI,MAAM,IAAI,GAAG,GAAG;AAEjD,QAAM,OAAO,IAAI,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,IAAI;AAC/C,QAAM,EAAE,MAAM,WAAU,IAAK;AAC7B,QAAM,OAAO,KAAK,OAAO,OAAO,KAAK,KAAK,aAAa,CAAC,IAAI,UAAU;AACtE,SAAO;AAAA,IACH;AAAA,IACA,iBAAiB;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,EACH;AACL;AACA,SAAS,aAAa,OAAO;AACzB,QAAM,OAAO,cAAc,KAAK;AAChC,iBAAe,MAAM;AAAA,IACjB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,aAAa;AAAA,EACrB,GAAO;AAAA,IACC,UAAU;AAAA,IACV,eAAe;AAAA,IACf,MAAM;AAAA,EACd,CAAK;AACD,SAAO,OAAO,OAAO,EAAE,MAAM,MAAM,GAAG,MAAM;AAChD;AAQO,SAAS,YAAY,UAAU;AAClC,QAAM,QAAQ,aAAa,QAAQ;AACnC,QAAM,EAAE,IAAI,GAAG,aAAa,aAAa,WAAU,IAAK;AACxD,QAAM,gBAAgB,GAAG,QAAQ;AACjC,QAAM,kBAAkB,IAAI,GAAG,QAAQ;AACvC,WAAS,KAAK,GAAG;AACb,WAAO,IAAI,GAAG,WAAW;AAAA,EACjC;AACI,WAAS,KAAK,GAAG;AACb,WAAO,OAAO,GAAG,WAAW;AAAA,EACpC;AACI,QAAM,EAAE,iBAAiB,OAAO,wBAAwB,qBAAqB,mBAAqB,IAAG,kBAAkB;AAAA,IACnH,GAAG;AAAA,IACH,QAAQ,IAAI,OAAO,cAAc;AAC7B,YAAM,IAAI,MAAM,SAAU;AAC1B,YAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;AACxB,YAAM,MAAM;AACZ,YAAM,gBAAgB,YAAY;AAClC,UAAI,cAAc;AACd,eAAO,IAAI,WAAW,KAAK,CAAC,MAAM,SAAU,IAAG,IAAO,CAAI,CAAC,GAAG,CAAC;AAAA,MAC/E,OACiB;AACD,eAAO,IAAI,WAAW,KAAK,CAAC,CAAI,CAAC,GAAG,GAAG,GAAG,QAAQ,EAAE,CAAC,CAAC;AAAA,MACtE;AAAA,IACS;AAAA,IACD,UAAU,OAAO;AACb,YAAM,MAAM,MAAM;AAClB,YAAM,OAAO,MAAM,CAAC;AACpB,YAAM,OAAO,MAAM,SAAS,CAAC;AAE7B,UAAI,QAAQ,kBAAkB,SAAS,KAAQ,SAAS,IAAO;AAC3D,cAAM,IAAI,gBAAgB,IAAI;AAC9B,YAAI,CAAC,QAAQ,GAAGA,OAAK,GAAG,KAAK;AACzB,gBAAM,IAAI,MAAM,uBAAuB;AAC3C,cAAM,KAAK,oBAAoB,CAAC;AAChC,YAAI;AACJ,YAAI;AACA,cAAI,GAAG,KAAK,EAAE;AAAA,QAClC,SACuB,WAAW;AACd,gBAAM,SAAS,qBAAqB,QAAQ,OAAO,UAAU,UAAU;AACvE,gBAAM,IAAI,MAAM,0BAA0B,MAAM;AAAA,QACpE;AACgB,cAAM,UAAU,IAAIA,WAASA;AAE7B,cAAM,aAAa,OAAO,OAAO;AACjC,YAAI,cAAc;AACd,cAAI,GAAG,IAAI,CAAC;AAChB,eAAO,EAAE,GAAG,EAAG;AAAA,MAC/B,WACqB,QAAQ,mBAAmB,SAAS,GAAM;AAC/C,cAAM,IAAI,GAAG,UAAU,KAAK,SAAS,GAAG,GAAG,KAAK,CAAC;AACjD,cAAM,IAAI,GAAG,UAAU,KAAK,SAAS,GAAG,OAAO,IAAI,GAAG,KAAK,CAAC;AAC5D,eAAO,EAAE,GAAG,EAAG;AAAA,MAC/B,OACiB;AACD,cAAM,KAAK;AACX,cAAM,KAAK;AACX,cAAM,IAAI,MAAM,uCAAuC,KAAK,uBAAuB,KAAK,WAAW,GAAG;AAAA,MACtH;AAAA,IACS;AAAA,EACT,CAAK;AACD,WAAS,sBAAsB,QAAQ;AACnC,UAAM,OAAO,eAAeA;AAC5B,WAAO,SAAS;AAAA,EACxB;AACI,WAAS,WAAW,GAAG;AACnB,WAAO,sBAAsB,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;AAAA,EACrD;AAEI,QAAM,SAAS,CAAC,GAAG,MAAM,OAAO,gBAAgB,EAAE,MAAM,MAAM,EAAE,CAAC;AAAA,EAIjE,MAAM,UAAU;AAAA,IACZ,YAAY,GAAG,GAAG,UAAU;AACxB,eAAS,KAAK,GAAGA,OAAK,WAAW;AACjC,eAAS,KAAK,GAAGA,OAAK,WAAW;AACjC,WAAK,IAAI;AACT,WAAK,IAAI;AACT,UAAI,YAAY;AACZ,aAAK,WAAW;AACpB,aAAO,OAAO,IAAI;AAAA,IAC9B;AAAA;AAAA,IAEQ,OAAO,YAAY,KAAK;AACpB,YAAM,IAAI;AACV,YAAM,YAAY,oBAAoB,KAAK,IAAI,CAAC;AAChD,aAAO,IAAI,UAAU,OAAO,KAAK,GAAG,CAAC,GAAG,OAAO,KAAK,GAAG,IAAI,CAAC,CAAC;AAAA,IACzE;AAAA;AAAA;AAAA,IAGQ,OAAO,QAAQ,KAAK;AAChB,YAAM,EAAE,GAAG,MAAM,IAAI,MAAM,YAAY,OAAO,GAAG,CAAC;AAClD,aAAO,IAAI,UAAU,GAAG,CAAC;AAAA,IACrC;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,iBAAiB;AAAA,IAAA;AAAA,IACjB,eAAe,UAAU;AACrB,aAAO,IAAI,UAAU,KAAK,GAAG,KAAK,GAAG,QAAQ;AAAA,IACzD;AAAA,IACQ,iBAAiB,SAAS;AACtB,YAAM,EAAE,GAAG,GAAG,UAAU,IAAK,IAAG;AAChC,YAAM,IAAI,cAAc,YAAY,WAAW,OAAO,CAAC;AACvD,UAAI,OAAO,QAAQ,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,SAAS,GAAG;AACzC,cAAM,IAAI,MAAM,qBAAqB;AACzC,YAAM,OAAO,QAAQ,KAAK,QAAQ,IAAI,IAAI,MAAM,IAAI;AACpD,UAAI,QAAQ,GAAG;AACX,cAAM,IAAI,MAAM,4BAA4B;AAChD,YAAM,UAAU,MAAM,OAAO,IAAI,OAAO;AACxC,YAAM,IAAI,MAAM,QAAQ,SAAS,cAAc,MAAM,GAAG,KAAK,CAAC;AAC9D,YAAM,KAAK,KAAK,IAAI;AACpB,YAAM,KAAK,KAAK,CAAC,IAAI,EAAE;AACvB,YAAM,KAAK,KAAK,IAAI,EAAE;AACtB,YAAM,IAAI,MAAM,KAAK,qBAAqB,GAAG,IAAI,EAAE;AACnD,UAAI,CAAC;AACD,cAAM,IAAI,MAAM,mBAAmB;AACvC,QAAE,eAAgB;AAClB,aAAO;AAAA,IACnB;AAAA;AAAA,IAEQ,WAAW;AACP,aAAO,sBAAsB,KAAK,CAAC;AAAA,IAC/C;AAAA,IACQ,aAAa;AACT,aAAO,KAAK,SAAQ,IAAK,IAAI,UAAU,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,KAAK,QAAQ,IAAI;AAAA,IAC3F;AAAA;AAAA,IAEQ,gBAAgB;AACZ,aAAO,WAAW,KAAK,UAAU;AAAA,IAC7C;AAAA,IACQ,WAAW;AACP,aAAO,IAAI,WAAW,IAAI;AAAA,IACtC;AAAA;AAAA,IAEQ,oBAAoB;AAChB,aAAO,WAAW,KAAK,cAAc;AAAA,IACjD;AAAA,IACQ,eAAe;AACX,YAAM,IAAI;AACV,aAAO,cAAc,KAAK,GAAG,CAAC,IAAI,cAAc,KAAK,GAAG,CAAC;AAAA,IACrE;AAAA,EACA;AACI,QAAM,QAAQ;AAAA,IACV,kBAAkB,YAAY;AAC1B,UAAI;AACA,+BAAuB,UAAU;AACjC,eAAO;AAAA,MACvB,SACmB,OAAO;AACV,eAAO;AAAA,MACvB;AAAA,IACS;AAAA,IACD;AAAA;AAAA;AAAA;AAAA;AAAA,IAKA,kBAAkB,MAAM;AACpB,YAAM,SAAS,iBAAiB,MAAM,CAAC;AACvC,aAAO,eAAe,MAAM,YAAY,MAAM,GAAG,MAAM,CAAC;AAAA,IAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASD,WAAW,aAAa,GAAG,QAAQ,MAAM,MAAM;AAC3C,YAAM,eAAe,UAAU;AAC/B,YAAM,SAAS,OAAO,CAAC,CAAC;AACxB,aAAO;AAAA,IACV;AAAA,EACJ;AAOD,WAAS,aAAa,YAAY,eAAe,MAAM;AACnD,WAAO,MAAM,eAAe,UAAU,EAAE,WAAW,YAAY;AAAA,EACvE;AAII,WAAS,UAAU,MAAM;AACrB,QAAI,OAAO,SAAS;AAChB,aAAO;AACX,QAAI,gBAAgB;AAChB,aAAO;AACX,UAAM,MAAM,YAAY,OAAO,IAAI;AACnC,UAAM,MAAM,IAAI;AAChB,UAAM,MAAM,GAAG;AACf,UAAM,UAAU,MAAM;AACtB,UAAM,YAAY,IAAI,MAAM;AAC5B,QAAI,MAAM,4BAA4B,gBAAgB,SAAS;AAC3D,aAAO;AAAA,IACnB,OACa;AACD,aAAO,QAAQ,WAAW,QAAQ;AAAA,IAC9C;AAAA,EACA;AAWI,WAAS,gBAAgB,UAAU,SAAS,eAAe,MAAM;AAC7D,QAAI,UAAU,QAAQ,MAAM;AACxB,YAAM,IAAI,MAAM,+BAA+B;AACnD,QAAI,UAAU,OAAO,MAAM;AACvB,YAAM,IAAI,MAAM,+BAA+B;AACnD,UAAM,IAAI,MAAM,QAAQ,OAAO;AAC/B,WAAO,EAAE,SAAS,uBAAuB,QAAQ,CAAC,EAAE,WAAW,YAAY;AAAA,EACnF;AAKI,QAAM,WAAW,MAAM,YACnB,SAAU,OAAO;AAEb,QAAI,MAAM,SAAS;AACf,YAAM,IAAI,MAAM,oBAAoB;AAGxC,UAAM,MAAM,gBAAgB,KAAK;AACjC,UAAM,QAAQ,MAAM,SAAS,IAAI;AACjC,WAAO,QAAQ,IAAI,OAAO,OAAO,KAAK,IAAI;AAAA,EAC7C;AACL,QAAM,gBAAgB,MAAM,iBACxB,SAAU,OAAO;AACb,WAAO,KAAK,SAAS,KAAK,CAAC;AAAA,EAC9B;AAEL,QAAM,aAAa,QAAQ,UAAU;AAIrC,WAAS,WAAW,KAAK;AACrB,aAAS,aAAa,YAAY,KAAKD,OAAK,UAAU;AAEtD,WAAO,gBAAgB,KAAK,WAAW;AAAA,EAC/C;AAMI,WAAS,QAAQ,SAAS,YAAY,OAAO,gBAAgB;AACzD,QAAI,CAAC,aAAa,WAAW,EAAE,KAAK,CAAC,MAAM,KAAK,IAAI;AAChD,YAAM,IAAI,MAAM,qCAAqC;AACzD,UAAM,EAAE,MAAM,aAAAS,aAAW,IAAK;AAC9B,QAAI,EAAE,MAAM,SAAS,cAAc,IAAG,IAAK;AAC3C,QAAI,QAAQ;AACR,aAAO;AACX,cAAU,YAAY,WAAW,OAAO;AACxC,uBAAmB,IAAI;AACvB,QAAI;AACA,gBAAU,YAAY,qBAAqB,KAAK,OAAO,CAAC;AAI5D,UAAM,QAAQ,cAAc,OAAO;AACnC,UAAM,IAAI,uBAAuB,UAAU;AAC3C,UAAM,WAAW,CAAC,WAAW,CAAC,GAAG,WAAW,KAAK,CAAC;AAElD,QAAI,OAAO,QAAQ,QAAQ,OAAO;AAE9B,YAAM,IAAI,QAAQ,OAAOA,aAAY,GAAG,KAAK,IAAI;AACjD,eAAS,KAAK,YAAY,gBAAgB,CAAC,CAAC;AAAA,IACxD;AACQ,UAAM,OAAO,YAAY,GAAG,QAAQ;AACpC,UAAM,IAAI;AAEV,aAAS,MAAM,QAAQ;AAEnB,YAAM,IAAI,SAAS,MAAM;AACzB,UAAI,CAAC,mBAAmB,CAAC;AACrB;AACJ,YAAM,KAAK,KAAK,CAAC;AACjB,YAAM,IAAI,MAAM,KAAK,SAAS,CAAC,EAAE;AACjC,YAAM,IAAI,KAAK,EAAE,CAAC;AAClB,UAAI,MAAMT;AACN;AAIJ,YAAM,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,CAAC;AACnC,UAAI,MAAMA;AACN;AACJ,UAAI,YAAY,EAAE,MAAM,IAAI,IAAI,KAAK,OAAO,EAAE,IAAIC,KAAG;AACrD,UAAI,QAAQ;AACZ,UAAI,QAAQ,sBAAsB,CAAC,GAAG;AAClC,gBAAQ,WAAW,CAAC;AACpB,oBAAY;AAAA,MAC5B;AACY,aAAO,IAAI,UAAU,GAAG,OAAO,QAAQ;AAAA,IACnD;AACQ,WAAO,EAAE,MAAM,MAAO;AAAA,EAC9B;AACI,QAAM,iBAAiB,EAAE,MAAM,MAAM,MAAM,SAAS,MAAO;AAC3D,QAAM,iBAAiB,EAAE,MAAM,MAAM,MAAM,SAAS,MAAO;AAc3D,WAAS,KAAK,SAAS,SAAS,OAAO,gBAAgB;AACnD,UAAM,EAAE,MAAM,MAAO,IAAG,QAAQ,SAAS,SAAS,IAAI;AACtD,UAAM,IAAI;AACV,UAAM,OAAO,eAAe,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,IAAI;AACnE,WAAO,KAAK,MAAM,KAAK;AAAA,EAC/B;AAEI,QAAM,KAAK,eAAe,CAAC;AAe3B,WAAS,OAAO,WAAW,SAAS,WAAW,OAAO,gBAAgB;;AAClE,UAAM,KAAK;AACX,cAAU,YAAY,WAAW,OAAO;AACxC,gBAAY,YAAY,aAAa,SAAS;AAC9C,UAAM,EAAE,MAAM,SAAS,OAAQ,IAAG;AAElC,uBAAmB,IAAI;AACvB,QAAI,YAAY;AACZ,YAAM,IAAI,MAAM,oCAAoC;AACxD,QAAI,WAAW,UAAa,WAAW,aAAa,WAAW;AAC3D,YAAM,IAAI,MAAM,+BAA+B;AACnD,UAAM,QAAQ,OAAO,OAAO,YAAY,QAAQ,EAAE;AAClD,UAAM,QAAQ,CAAC,SACX,CAAC,UACD,OAAO,OAAO,YACd,OAAO,QACP,OAAO,GAAG,MAAM,YAChB,OAAO,GAAG,MAAM;AACpB,QAAI,CAAC,SAAS,CAAC;AACX,YAAM,IAAI,MAAM,0EAA0E;AAC9F,QAAI,OAAO;AACX,QAAI;AACJ,QAAI;AACA,UAAI;AACA,eAAO,IAAI,UAAU,GAAG,GAAG,GAAG,CAAC;AACnC,UAAI,OAAO;AAGP,YAAI;AACA,cAAI,WAAW;AACX,mBAAO,UAAU,QAAQ,EAAE;AAAA,QACnD,SACuB,UAAU;AACb,cAAI,EAAE,oBAAoB,IAAI;AAC1B,kBAAM;AAAA,QAC9B;AACgB,YAAI,CAAC,QAAQ,WAAW;AACpB,iBAAO,UAAU,YAAY,EAAE;AAAA,MACnD;AACY,UAAI,MAAM,QAAQ,SAAS;AAAA,IACvC,SACe,OAAO;AACV,aAAO;AAAA,IACnB;AACQ,QAAI,CAAC;AACD,aAAO;AACX,QAAI,QAAQ,KAAK,SAAU;AACvB,aAAO;AACX,QAAI;AACA,gBAAU,MAAM,KAAK,OAAO;AAChC,UAAM,EAAE,GAAG,EAAC,IAAK;AACjB,UAAM,IAAI,cAAc,OAAO;AAC/B,UAAM,KAAK,KAAK,CAAC;AACjB,UAAM,KAAK,KAAK,IAAI,EAAE;AACtB,UAAM,KAAK,KAAK,IAAI,EAAE;AACtB,UAAM,KAAI,WAAM,KAAK,qBAAqB,GAAG,IAAI,EAAE,MAAzC,mBAA4C;AACtD,QAAI,CAAC;AACD,aAAO;AACX,UAAM,IAAI,KAAK,EAAE,CAAC;AAClB,WAAO,MAAM;AAAA,EACrB;AACI,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,iBAAiB;AAAA,IACjB;AAAA,IACA;AAAA,EACH;AACL;AC5jCO,SAAS,QAAQ,MAAM;AAC1B,SAAO;AAAA,IACH;AAAA,IACA,MAAM,CAAC,QAAQ,SAAS,KAAK,MAAM,KAAKS,cAAY,GAAG,IAAI,CAAC;AAAA,IAC5D;AAAA,EACH;AACL;AACO,SAAS,YAAY,UAAU,SAAS;AAC3C,QAAM,SAAS,CAAC,SAAS,YAAY,EAAE,GAAG,UAAU,GAAG,QAAQ,IAAI,GAAG;AACtE,SAAO,EAAE,GAAG,OAAO,OAAO,GAAG,OAAQ;AACzC;ACCA,MAAM,aAAa,OAAO,oEAAoE;AAC9F,MAAM,aAAa,OAAO,oEAAoE;AAC9F,MAAM,MAAM,OAAO,CAAC;AACpB,MAAM,MAAM,OAAO,CAAC;AACpB,MAAM,MAAM,OAAO,CAAC;AACpB,MAAM,aAAa,CAAC,GAAG,OAAO,IAAI,IAAI,OAAO;AAK7C,SAAS,QAAQ,GAAG;AAChB,QAAM,IAAI;AAEV,QAAMP,OAAM,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,OAAO,OAAO,EAAE,GAAG,OAAO,OAAO,EAAE;AAE3E,QAAM,OAAO,OAAO,EAAE,GAAG,OAAO,OAAO,EAAE,GAAG,OAAO,OAAO,EAAE;AAC5D,QAAM,KAAM,IAAI,IAAI,IAAK;AACzB,QAAM,KAAM,KAAK,KAAK,IAAK;AAC3B,QAAM,KAAM,KAAK,IAAIA,MAAK,CAAC,IAAI,KAAM;AACrC,QAAM,KAAM,KAAK,IAAIA,MAAK,CAAC,IAAI,KAAM;AACrC,QAAM,MAAO,KAAK,IAAI,KAAK,CAAC,IAAI,KAAM;AACtC,QAAM,MAAO,KAAK,KAAK,MAAM,CAAC,IAAI,MAAO;AACzC,QAAM,MAAO,KAAK,KAAK,MAAM,CAAC,IAAI,MAAO;AACzC,QAAM,MAAO,KAAK,KAAK,MAAM,CAAC,IAAI,MAAO;AACzC,QAAM,OAAQ,KAAK,KAAK,MAAM,CAAC,IAAI,MAAO;AAC1C,QAAM,OAAQ,KAAK,MAAM,MAAM,CAAC,IAAI,MAAO;AAC3C,QAAM,OAAQ,KAAK,MAAMA,MAAK,CAAC,IAAI,KAAM;AACzC,QAAM,KAAM,KAAK,MAAM,MAAM,CAAC,IAAI,MAAO;AACzC,QAAM,KAAM,KAAK,IAAI,KAAK,CAAC,IAAI,KAAM;AACrC,QAAM,OAAO,KAAK,IAAI,KAAK,CAAC;AAC5B,MAAI,CAAC,KAAK,IAAI,KAAK,IAAI,IAAI,GAAG,CAAC;AAC3B,UAAM,IAAI,MAAM,yBAAyB;AAC7C,SAAO;AACX;AACA,MAAM,OAAO,MAAM,YAAY,QAAW,QAAW,EAAE,MAAM,SAAS;AAgB1D,MAAC,YAAY,YAAY;AAAA,EACjC,GAAG;AAAA,EACH,GAAG,OAAO,CAAC;AAAA,EACX,IAAI;AAAA,EACJ,GAAG;AAAA,EACH,IAAI,OAAO,+EAA+E;AAAA,EAC1F,IAAI,OAAO,+EAA+E;AAAA,EAC1F,GAAG,OAAO,CAAC;AAAA,EACX,MAAM;AAAA;AAAA,EACN,MAAM;AAAA;AAAA,IAEF,MAAM,OAAO,oEAAoE;AAAA,IACjF,aAAa,CAAC,MAAM;AAChB,YAAM,IAAI;AACV,YAAM,KAAK,OAAO,oCAAoC;AACtD,YAAM,KAAK,CAAC,MAAM,OAAO,oCAAoC;AAC7D,YAAM,KAAK,OAAO,qCAAqC;AACvD,YAAM,KAAK;AACX,YAAM,YAAY,OAAO,qCAAqC;AAC9D,YAAM,KAAK,WAAW,KAAK,GAAG,CAAC;AAC/B,YAAM,KAAK,WAAW,CAAC,KAAK,GAAG,CAAC;AAChC,UAAI,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,CAAC;AACrC,UAAI,KAAK,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,CAAC;AAClC,YAAM,QAAQ,KAAK;AACnB,YAAM,QAAQ,KAAK;AACnB,UAAI;AACA,aAAK,IAAI;AACb,UAAI;AACA,aAAK,IAAI;AACb,UAAI,KAAK,aAAa,KAAK,WAAW;AAClC,cAAM,IAAI,MAAM,yCAAyC,CAAC;AAAA,MAC1E;AACY,aAAO,EAAE,OAAO,IAAI,OAAO,GAAI;AAAA,IAClC;AAAA,EACJ;AACL,GAAG,MAAM;","x_google_ignoreList":[0,1,2,3,4,5]}

package/dist/send-pvA8KHBc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"send-pvA8KHBc.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/send.js"],"sourcesContent":["import { svg } from 'lit';\nexport const sendSvg = svg `<svg fill=\"none\" viewBox=\"0 0 21 20\">\n  <path\n    fill=\"currentColor\"\n    fill-rule=\"evenodd\"\n    d=\"M14.3808 4.34812C13.72 4.47798 12.8501 4.7587 11.5748 5.17296L9.00869 6.00646C6.90631 6.68935 5.40679 7.17779 4.38121 7.63178C3.87166 7.85734 3.5351 8.05091 3.32022 8.22035C3.11183 8.38466 3.07011 8.48486 3.05969 8.51817C2.98058 8.77103 2.98009 9.04195 3.05831 9.29509C3.06861 9.32844 3.10998 9.42878 3.31777 9.59384C3.53205 9.76404 3.86792 9.95881 4.37667 10.1862C5.29287 10.5957 6.58844 11.0341 8.35529 11.6164L10.8876 8.59854C11.2426 8.17547 11.8733 8.12028 12.2964 8.47528C12.7195 8.83029 12.7746 9.46104 12.4196 9.88412L9.88738 12.9019C10.7676 14.5408 11.4244 15.7406 11.9867 16.5718C12.299 17.0333 12.5491 17.3303 12.7539 17.5117C12.9526 17.6877 13.0586 17.711 13.0932 17.7154C13.3561 17.7484 13.6228 17.7009 13.8581 17.5791C13.8891 17.563 13.9805 17.5046 14.1061 17.2708C14.2357 17.0298 14.3679 16.6647 14.5015 16.1237C14.7705 15.0349 14.9912 13.4733 15.2986 11.2843L15.6738 8.61249C15.8603 7.28456 15.9857 6.37917 15.9989 5.7059C16.012 5.03702 15.9047 4.8056 15.8145 4.69183C15.7044 4.55297 15.5673 4.43792 15.4114 4.35365C15.2837 4.28459 15.0372 4.2191 14.3808 4.34812ZM7.99373 13.603C6.11919 12.9864 4.6304 12.4902 3.5606 12.0121C2.98683 11.7557 2.4778 11.4808 2.07383 11.1599C1.66337 10.8339 1.31312 10.4217 1.14744 9.88551C0.949667 9.24541 0.950886 8.56035 1.15094 7.92096C1.31852 7.38534 1.67024 6.97442 2.08185 6.64985C2.48697 6.33041 2.99697 6.05734 3.57166 5.80295C4.70309 5.3021 6.30179 4.78283 8.32903 4.12437L11.0196 3.25042C12.2166 2.86159 13.2017 2.54158 13.9951 2.38566C14.8065 2.22618 15.6202 2.19289 16.3627 2.59437C16.7568 2.80747 17.1035 3.09839 17.3818 3.4495C17.9062 4.111 18.0147 4.91815 17.9985 5.74496C17.9827 6.55332 17.8386 7.57903 17.6636 8.82534L17.2701 11.6268C16.9737 13.7376 16.7399 15.4022 16.4432 16.6034C16.2924 17.2135 16.1121 17.7632 15.8678 18.2176C15.6197 18.6794 15.2761 19.0971 14.7777 19.3551C14.1827 19.6632 13.5083 19.7833 12.8436 19.6997C12.2867 19.6297 11.82 19.3563 11.4277 19.0087C11.0415 18.6666 10.6824 18.213 10.3302 17.6925C9.67361 16.722 8.92648 15.342 7.99373 13.603Z\"\n    clip-rule=\"evenodd\"\n  />\n  <svg\n    xmlns=\"http://www.w3.org/2000/svg\"\n    width=\"21\"\n    height=\"20\"\n    viewBox=\"0 0 21 20\"\n    fill=\"none\"\n  ></svg></svg\n>`;\n//# sourceMappingURL=send.js.map"],"names":["svg"],"mappings":";AACO,MAAM,UAAUA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/shareicon-BdQizUDb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shareicon-BdQizUDb.js","sources":["../node_modules/@mui/system/esm/colorManipulator.js","../node_modules/@mui/material/styles/cssUtils.js","../node_modules/@mui/material/Skeleton/skeletonClasses.js","../node_modules/@mui/material/Skeleton/Skeleton.js","../src/Components/Svg/shareicon.js"],"sourcesContent":["import _formatMuiErrorMessage from \"@mui/utils/formatMuiErrorMessage\";\n/* eslint-disable @typescript-eslint/naming-convention */\nimport clamp from '@mui/utils/clamp';\n/**\n * Returns a number whose value is limited to the given range.\n * @param {number} value The value to be clamped\n * @param {number} min The lower boundary of the output range\n * @param {number} max The upper boundary of the output range\n * @returns {number} A number in the range [min, max]\n */\nfunction clampWrapper(value, min = 0, max = 1) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (value < min || value > max) {\n      console.error(`MUI: The value provided ${value} is out of range [${min}, ${max}].`);\n    }\n  }\n  return clamp(value, min, max);\n}\n\n/**\n * Converts a color from CSS hex format to CSS rgb format.\n * @param {string} color - Hex color, i.e. #nnn or #nnnnnn\n * @returns {string} A CSS rgb color string\n */\nexport function hexToRgb(color) {\n  color = color.slice(1);\n  const re = new RegExp(`.{1,${color.length >= 6 ? 2 : 1}}`, 'g');\n  let colors = color.match(re);\n  if (colors && colors[0].length === 1) {\n    colors = colors.map(n => n + n);\n  }\n  return colors ? `rgb${colors.length === 4 ? 'a' : ''}(${colors.map((n, index) => {\n    return index < 3 ? parseInt(n, 16) : Math.round(parseInt(n, 16) / 255 * 1000) / 1000;\n  }).join(', ')})` : '';\n}\nfunction intToHex(int) {\n  const hex = int.toString(16);\n  return hex.length === 1 ? `0${hex}` : hex;\n}\n\n/**\n * Returns an object with the type and values of a color.\n *\n * Note: Does not support rgb % values.\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @returns {object} - A MUI color object: {type: string, values: number[]}\n */\nexport function decomposeColor(color) {\n  // Idempotent\n  if (color.type) {\n    return color;\n  }\n  if (color.charAt(0) === '#') {\n    return decomposeColor(hexToRgb(color));\n  }\n  const marker = color.indexOf('(');\n  const type = color.substring(0, marker);\n  if (['rgb', 'rgba', 'hsl', 'hsla', 'color'].indexOf(type) === -1) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? `MUI: Unsupported \\`${color}\\` color.\nThe following formats are supported: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().` : _formatMuiErrorMessage(9, color));\n  }\n  let values = color.substring(marker + 1, color.length - 1);\n  let colorSpace;\n  if (type === 'color') {\n    values = values.split(' ');\n    colorSpace = values.shift();\n    if (values.length === 4 && values[3].charAt(0) === '/') {\n      values[3] = values[3].slice(1);\n    }\n    if (['srgb', 'display-p3', 'a98-rgb', 'prophoto-rgb', 'rec-2020'].indexOf(colorSpace) === -1) {\n      throw new Error(process.env.NODE_ENV !== \"production\" ? `MUI: unsupported \\`${colorSpace}\\` color space.\nThe following color spaces are supported: srgb, display-p3, a98-rgb, prophoto-rgb, rec-2020.` : _formatMuiErrorMessage(10, colorSpace));\n    }\n  } else {\n    values = values.split(',');\n  }\n  values = values.map(value => parseFloat(value));\n  return {\n    type,\n    values,\n    colorSpace\n  };\n}\n\n/**\n * Returns a channel created from the input color.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @returns {string} - The channel for the color, that can be used in rgba or hsla colors\n */\nexport const colorChannel = color => {\n  const decomposedColor = decomposeColor(color);\n  return decomposedColor.values.slice(0, 3).map((val, idx) => decomposedColor.type.indexOf('hsl') !== -1 && idx !== 0 ? `${val}%` : val).join(' ');\n};\nexport const private_safeColorChannel = (color, warning) => {\n  try {\n    return colorChannel(color);\n  } catch (error) {\n    if (warning && process.env.NODE_ENV !== 'production') {\n      console.warn(warning);\n    }\n    return color;\n  }\n};\n\n/**\n * Converts a color object with type and values to a string.\n * @param {object} color - Decomposed color\n * @param {string} color.type - One of: 'rgb', 'rgba', 'hsl', 'hsla', 'color'\n * @param {array} color.values - [n,n,n] or [n,n,n,n]\n * @returns {string} A CSS color string\n */\nexport function recomposeColor(color) {\n  const {\n    type,\n    colorSpace\n  } = color;\n  let {\n    values\n  } = color;\n  if (type.indexOf('rgb') !== -1) {\n    // Only convert the first 3 values to int (i.e. not alpha)\n    values = values.map((n, i) => i < 3 ? parseInt(n, 10) : n);\n  } else if (type.indexOf('hsl') !== -1) {\n    values[1] = `${values[1]}%`;\n    values[2] = `${values[2]}%`;\n  }\n  if (type.indexOf('color') !== -1) {\n    values = `${colorSpace} ${values.join(' ')}`;\n  } else {\n    values = `${values.join(', ')}`;\n  }\n  return `${type}(${values})`;\n}\n\n/**\n * Converts a color from CSS rgb format to CSS hex format.\n * @param {string} color - RGB color, i.e. rgb(n, n, n)\n * @returns {string} A CSS rgb color string, i.e. #nnnnnn\n */\nexport function rgbToHex(color) {\n  // Idempotent\n  if (color.indexOf('#') === 0) {\n    return color;\n  }\n  const {\n    values\n  } = decomposeColor(color);\n  return `#${values.map((n, i) => intToHex(i === 3 ? Math.round(255 * n) : n)).join('')}`;\n}\n\n/**\n * Converts a color from hsl format to rgb format.\n * @param {string} color - HSL color values\n * @returns {string} rgb color values\n */\nexport function hslToRgb(color) {\n  color = decomposeColor(color);\n  const {\n    values\n  } = color;\n  const h = values[0];\n  const s = values[1] / 100;\n  const l = values[2] / 100;\n  const a = s * Math.min(l, 1 - l);\n  const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);\n  let type = 'rgb';\n  const rgb = [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)];\n  if (color.type === 'hsla') {\n    type += 'a';\n    rgb.push(values[3]);\n  }\n  return recomposeColor({\n    type,\n    values: rgb\n  });\n}\n/**\n * The relative brightness of any point in a color space,\n * normalized to 0 for darkest black and 1 for lightest white.\n *\n * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @returns {number} The relative brightness of the color in the range 0 - 1\n */\nexport function getLuminance(color) {\n  color = decomposeColor(color);\n  let rgb = color.type === 'hsl' || color.type === 'hsla' ? decomposeColor(hslToRgb(color)).values : color.values;\n  rgb = rgb.map(val => {\n    if (color.type !== 'color') {\n      val /= 255; // normalized\n    }\n    return val <= 0.03928 ? val / 12.92 : ((val + 0.055) / 1.055) ** 2.4;\n  });\n\n  // Truncate at 3 digits\n  return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3));\n}\n\n/**\n * Calculates the contrast ratio between two colors.\n *\n * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests\n * @param {string} foreground - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {string} background - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @returns {number} A contrast ratio value in the range 0 - 21.\n */\nexport function getContrastRatio(foreground, background) {\n  const lumA = getLuminance(foreground);\n  const lumB = getLuminance(background);\n  return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05);\n}\n\n/**\n * Sets the absolute transparency of a color.\n * Any existing alpha values are overwritten.\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @param {number} value - value to set the alpha channel to in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\nexport function alpha(color, value) {\n  color = decomposeColor(color);\n  value = clampWrapper(value);\n  if (color.type === 'rgb' || color.type === 'hsl') {\n    color.type += 'a';\n  }\n  if (color.type === 'color') {\n    color.values[3] = `/${value}`;\n  } else {\n    color.values[3] = value;\n  }\n  return recomposeColor(color);\n}\nexport function private_safeAlpha(color, value, warning) {\n  try {\n    return alpha(color, value);\n  } catch (error) {\n    if (warning && process.env.NODE_ENV !== 'production') {\n      console.warn(warning);\n    }\n    return color;\n  }\n}\n\n/**\n * Darkens a color.\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @param {number} coefficient - multiplier in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\nexport function darken(color, coefficient) {\n  color = decomposeColor(color);\n  coefficient = clampWrapper(coefficient);\n  if (color.type.indexOf('hsl') !== -1) {\n    color.values[2] *= 1 - coefficient;\n  } else if (color.type.indexOf('rgb') !== -1 || color.type.indexOf('color') !== -1) {\n    for (let i = 0; i < 3; i += 1) {\n      color.values[i] *= 1 - coefficient;\n    }\n  }\n  return recomposeColor(color);\n}\nexport function private_safeDarken(color, coefficient, warning) {\n  try {\n    return darken(color, coefficient);\n  } catch (error) {\n    if (warning && process.env.NODE_ENV !== 'production') {\n      console.warn(warning);\n    }\n    return color;\n  }\n}\n\n/**\n * Lightens a color.\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @param {number} coefficient - multiplier in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\nexport function lighten(color, coefficient) {\n  color = decomposeColor(color);\n  coefficient = clampWrapper(coefficient);\n  if (color.type.indexOf('hsl') !== -1) {\n    color.values[2] += (100 - color.values[2]) * coefficient;\n  } else if (color.type.indexOf('rgb') !== -1) {\n    for (let i = 0; i < 3; i += 1) {\n      color.values[i] += (255 - color.values[i]) * coefficient;\n    }\n  } else if (color.type.indexOf('color') !== -1) {\n    for (let i = 0; i < 3; i += 1) {\n      color.values[i] += (1 - color.values[i]) * coefficient;\n    }\n  }\n  return recomposeColor(color);\n}\nexport function private_safeLighten(color, coefficient, warning) {\n  try {\n    return lighten(color, coefficient);\n  } catch (error) {\n    if (warning && process.env.NODE_ENV !== 'production') {\n      console.warn(warning);\n    }\n    return color;\n  }\n}\n\n/**\n * Darken or lighten a color, depending on its luminance.\n * Light colors are darkened, dark colors are lightened.\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()\n * @param {number} coefficient=0.15 - multiplier in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\nexport function emphasize(color, coefficient = 0.15) {\n  return getLuminance(color) > 0.5 ? darken(color, coefficient) : lighten(color, coefficient);\n}\nexport function private_safeEmphasize(color, coefficient, warning) {\n  try {\n    return emphasize(color, coefficient);\n  } catch (error) {\n    if (warning && process.env.NODE_ENV !== 'production') {\n      console.warn(warning);\n    }\n    return color;\n  }\n}\n\n/**\n * Blend a transparent overlay color with a background color, resulting in a single\n * RGB color.\n * @param {string} background - CSS color\n * @param {string} overlay - CSS color\n * @param {number} opacity - Opacity multiplier in the range 0 - 1\n * @param {number} [gamma=1.0] - Gamma correction factor. For gamma-correct blending, 2.2 is usual.\n */\nexport function blend(background, overlay, opacity, gamma = 1.0) {\n  const blendChannel = (b, o) => Math.round((b ** (1 / gamma) * (1 - opacity) + o ** (1 / gamma) * opacity) ** gamma);\n  const backgroundColor = decomposeColor(background);\n  const overlayColor = decomposeColor(overlay);\n  const rgb = [blendChannel(backgroundColor.values[0], overlayColor.values[0]), blendChannel(backgroundColor.values[1], overlayColor.values[1]), blendChannel(backgroundColor.values[2], overlayColor.values[2])];\n  return recomposeColor({\n    type: 'rgb',\n    values: rgb\n  });\n}","export function isUnitless(value) {\n  return String(parseFloat(value)).length === String(value).length;\n}\n\n// Ported from Compass\n// https://github.com/Compass/compass/blob/master/core/stylesheets/compass/typography/_units.scss\n// Emulate the sass function \"unit\"\nexport function getUnit(input) {\n  return String(input).match(/[\\d.\\-+]*\\s*(.*)/)[1] || '';\n}\n\n// Emulate the sass function \"unitless\"\nexport function toUnitless(length) {\n  return parseFloat(length);\n}\n\n// Convert any CSS <length> or <percentage> value to any another.\n// From https://github.com/KyleAMathews/convert-css-length\nexport function convertLength(baseFontSize) {\n  return (length, toUnit) => {\n    const fromUnit = getUnit(length);\n\n    // Optimize for cases where `from` and `to` units are accidentally the same.\n    if (fromUnit === toUnit) {\n      return length;\n    }\n\n    // Convert input length to pixels.\n    let pxLength = toUnitless(length);\n    if (fromUnit !== 'px') {\n      if (fromUnit === 'em') {\n        pxLength = toUnitless(length) * toUnitless(baseFontSize);\n      } else if (fromUnit === 'rem') {\n        pxLength = toUnitless(length) * toUnitless(baseFontSize);\n      }\n    }\n\n    // Convert length in pixels to the output unit\n    let outputLength = pxLength;\n    if (toUnit !== 'px') {\n      if (toUnit === 'em') {\n        outputLength = pxLength / toUnitless(baseFontSize);\n      } else if (toUnit === 'rem') {\n        outputLength = pxLength / toUnitless(baseFontSize);\n      } else {\n        return length;\n      }\n    }\n    return parseFloat(outputLength.toFixed(5)) + toUnit;\n  };\n}\nexport function alignProperty({\n  size,\n  grid\n}) {\n  const sizeBelow = size - size % grid;\n  const sizeAbove = sizeBelow + grid;\n  return size - sizeBelow < sizeAbove - size ? sizeBelow : sizeAbove;\n}\n\n// fontGrid finds a minimal grid (in rem) for the fontSize values so that the\n// lineHeight falls under a x pixels grid, 4px in the case of Material Design,\n// without changing the relative line height\nexport function fontGrid({\n  lineHeight,\n  pixels,\n  htmlFontSize\n}) {\n  return pixels / (lineHeight * htmlFontSize);\n}\n\n/**\n * generate a responsive version of a given CSS property\n * @example\n * responsiveProperty({\n *   cssProperty: 'fontSize',\n *   min: 15,\n *   max: 20,\n *   unit: 'px',\n *   breakpoints: [300, 600],\n * })\n *\n * // this returns\n *\n * {\n *   fontSize: '15px',\n *   '@media (min-width:300px)': {\n *     fontSize: '17.5px',\n *   },\n *   '@media (min-width:600px)': {\n *     fontSize: '20px',\n *   },\n * }\n * @param {Object} params\n * @param {string} params.cssProperty - The CSS property to be made responsive\n * @param {number} params.min - The smallest value of the CSS property\n * @param {number} params.max - The largest value of the CSS property\n * @param {string} [params.unit] - The unit to be used for the CSS property\n * @param {Array.number} [params.breakpoints]  - An array of breakpoints\n * @param {number} [params.alignStep] - Round scaled value to fall under this grid\n * @returns {Object} responsive styles for {params.cssProperty}\n */\nexport function responsiveProperty({\n  cssProperty,\n  min,\n  max,\n  unit = 'rem',\n  breakpoints = [600, 900, 1200],\n  transform = null\n}) {\n  const output = {\n    [cssProperty]: `${min}${unit}`\n  };\n  const factor = (max - min) / breakpoints[breakpoints.length - 1];\n  breakpoints.forEach(breakpoint => {\n    let value = min + factor * breakpoint;\n    if (transform !== null) {\n      value = transform(value);\n    }\n    output[`@media (min-width:${breakpoint}px)`] = {\n      [cssProperty]: `${Math.round(value * 10000) / 10000}${unit}`\n    };\n  });\n  return output;\n}","import generateUtilityClasses from '@mui/utils/generateUtilityClasses';\nimport generateUtilityClass from '@mui/utils/generateUtilityClass';\nexport function getSkeletonUtilityClass(slot) {\n  return generateUtilityClass('MuiSkeleton', slot);\n}\nconst skeletonClasses = generateUtilityClasses('MuiSkeleton', ['root', 'text', 'rectangular', 'rounded', 'circular', 'pulse', 'wave', 'withChildren', 'fitContent', 'heightAuto']);\nexport default skeletonClasses;","'use client';\n\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"animation\", \"className\", \"component\", \"height\", \"style\", \"variant\", \"width\"];\nlet _ = t => t,\n  _t,\n  _t2,\n  _t3,\n  _t4;\nimport * as React from 'react';\nimport clsx from 'clsx';\nimport PropTypes from 'prop-types';\nimport { keyframes, css } from '@mui/system';\nimport composeClasses from '@mui/utils/composeClasses';\nimport { alpha, unstable_getUnit as getUnit, unstable_toUnitless as toUnitless } from '../styles';\nimport styled from '../styles/styled';\nimport { useDefaultProps } from '../DefaultPropsProvider';\nimport { getSkeletonUtilityClass } from './skeletonClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    variant,\n    animation,\n    hasChildren,\n    width,\n    height\n  } = ownerState;\n  const slots = {\n    root: ['root', variant, animation, hasChildren && 'withChildren', hasChildren && !width && 'fitContent', hasChildren && !height && 'heightAuto']\n  };\n  return composeClasses(slots, getSkeletonUtilityClass, classes);\n};\nconst pulseKeyframe = keyframes(_t || (_t = _`\n  0% {\n    opacity: 1;\n  }\n\n  50% {\n    opacity: 0.4;\n  }\n\n  100% {\n    opacity: 1;\n  }\n`));\nconst waveKeyframe = keyframes(_t2 || (_t2 = _`\n  0% {\n    transform: translateX(-100%);\n  }\n\n  50% {\n    /* +0.5s of delay between each loop */\n    transform: translateX(100%);\n  }\n\n  100% {\n    transform: translateX(100%);\n  }\n`));\nconst SkeletonRoot = styled('span', {\n  name: 'MuiSkeleton',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, styles[ownerState.variant], ownerState.animation !== false && styles[ownerState.animation], ownerState.hasChildren && styles.withChildren, ownerState.hasChildren && !ownerState.width && styles.fitContent, ownerState.hasChildren && !ownerState.height && styles.heightAuto];\n  }\n})(({\n  theme,\n  ownerState\n}) => {\n  const radiusUnit = getUnit(theme.shape.borderRadius) || 'px';\n  const radiusValue = toUnitless(theme.shape.borderRadius);\n  return _extends({\n    display: 'block',\n    // Create a \"on paper\" color with sufficient contrast retaining the color\n    backgroundColor: theme.vars ? theme.vars.palette.Skeleton.bg : alpha(theme.palette.text.primary, theme.palette.mode === 'light' ? 0.11 : 0.13),\n    height: '1.2em'\n  }, ownerState.variant === 'text' && {\n    marginTop: 0,\n    marginBottom: 0,\n    height: 'auto',\n    transformOrigin: '0 55%',\n    transform: 'scale(1, 0.60)',\n    borderRadius: `${radiusValue}${radiusUnit}/${Math.round(radiusValue / 0.6 * 10) / 10}${radiusUnit}`,\n    '&:empty:before': {\n      content: '\"\\\\00a0\"'\n    }\n  }, ownerState.variant === 'circular' && {\n    borderRadius: '50%'\n  }, ownerState.variant === 'rounded' && {\n    borderRadius: (theme.vars || theme).shape.borderRadius\n  }, ownerState.hasChildren && {\n    '& > *': {\n      visibility: 'hidden'\n    }\n  }, ownerState.hasChildren && !ownerState.width && {\n    maxWidth: 'fit-content'\n  }, ownerState.hasChildren && !ownerState.height && {\n    height: 'auto'\n  });\n}, ({\n  ownerState\n}) => ownerState.animation === 'pulse' && css(_t3 || (_t3 = _`\n      animation: ${0} 2s ease-in-out 0.5s infinite;\n    `), pulseKeyframe), ({\n  ownerState,\n  theme\n}) => ownerState.animation === 'wave' && css(_t4 || (_t4 = _`\n      position: relative;\n      overflow: hidden;\n\n      /* Fix bug in Safari https://bugs.webkit.org/show_bug.cgi?id=68196 */\n      -webkit-mask-image: -webkit-radial-gradient(white, black);\n\n      &::after {\n        animation: ${0} 2s linear 0.5s infinite;\n        background: linear-gradient(\n          90deg,\n          transparent,\n          ${0},\n          transparent\n        );\n        content: '';\n        position: absolute;\n        transform: translateX(-100%); /* Avoid flash during server-side hydration */\n        bottom: 0;\n        left: 0;\n        right: 0;\n        top: 0;\n      }\n    `), waveKeyframe, (theme.vars || theme).palette.action.hover));\nconst Skeleton = /*#__PURE__*/React.forwardRef(function Skeleton(inProps, ref) {\n  const props = useDefaultProps({\n    props: inProps,\n    name: 'MuiSkeleton'\n  });\n  const {\n      animation = 'pulse',\n      className,\n      component = 'span',\n      height,\n      style,\n      variant = 'text',\n      width\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const ownerState = _extends({}, props, {\n    animation,\n    component,\n    variant,\n    hasChildren: Boolean(other.children)\n  });\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(SkeletonRoot, _extends({\n    as: component,\n    ref: ref,\n    className: clsx(classes.root, className),\n    ownerState: ownerState\n  }, other, {\n    style: _extends({\n      width,\n      height\n    }, style)\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Skeleton.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * The animation.\n   * If `false` the animation effect is disabled.\n   * @default 'pulse'\n   */\n  animation: PropTypes.oneOf(['pulse', 'wave', false]),\n  /**\n   * Optional children to infer width and height from.\n   */\n  children: PropTypes.node,\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n  /**\n   * Height of the skeleton.\n   * Useful when you don't want to adapt the skeleton to a text element but for instance a card.\n   */\n  height: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n  /**\n   * @ignore\n   */\n  style: PropTypes.object,\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n  /**\n   * The type of content that will be rendered.\n   * @default 'text'\n   */\n  variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['circular', 'rectangular', 'rounded', 'text']), PropTypes.string]),\n  /**\n   * Width of the skeleton.\n   * Useful when the skeleton is inside an inline element with no width of its own.\n   */\n  width: PropTypes.oneOfType([PropTypes.number, PropTypes.string])\n} : void 0;\nexport default Skeleton;","\n\n\nexport default function ShareIcon({fill}){\n    return <svg width=\"13\" height=\"13\" viewBox=\"0 0 13 13\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n    <path d=\"M6 2H2C1.44772 2 1 2.44772 1 3V11C1 11.5523 1.44772 12 2 12H10C10.5523 12 11 11.5523 11 11V7\" stroke={fill} stroke-linecap=\"round\"/>\n    <path d=\"M4.64645 8.14645C4.45118 8.34171 4.45118 8.65829 4.64645 8.85355C4.84171 9.04882 5.15829 9.04882 5.35355 8.85355L4.64645 8.14645ZM13 1C13 0.723858 12.7761 0.5 12.5 0.5H8C7.72386 0.5 7.5 0.723858 7.5 1C7.5 1.27614 7.72386 1.5 8 1.5H12V5.5C12 5.77614 12.2239 6 12.5 6C12.7761 6 13 5.77614 13 5.5V1ZM5.35355 8.85355L12.8536 1.35355L12.1464 0.646447L4.64645 8.14645L5.35355 8.85355Z\" fill={fill}/>\n    </svg>\n}"],"names":["process","_formatMuiErrorMessage","Skeleton","_jsx"],"mappings":";;;;AAUA,SAAS,aAAa,OAAO,MAAM,GAAG,MAAM,GAAG;AAC7C,MAAIA,UAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,QAAQ,OAAO,QAAQ,KAAK;AAAA,IAEpC;AAAA,EACA;AACE,SAAO,MAAM,OAAO,KAAK,GAAG;AAC9B;AAOO,SAAS,SAAS,OAAO;AAC9B,UAAQ,MAAM,MAAM,CAAC;AACrB,QAAM,KAAK,IAAI,OAAO,OAAO,MAAM,UAAU,IAAI,IAAI,CAAC,KAAK,GAAG;AAC9D,MAAI,SAAS,MAAM,MAAM,EAAE;AAC3B,MAAI,UAAU,OAAO,CAAC,EAAE,WAAW,GAAG;AACpC,aAAS,OAAO,IAAI,OAAK,IAAI,CAAC;AAAA,EAClC;AACE,SAAO,SAAS,MAAM,OAAO,WAAW,IAAI,MAAM,EAAE,IAAI,OAAO,IAAI,CAAC,GAAG,UAAU;AAC/E,WAAO,QAAQ,IAAI,SAAS,GAAG,EAAE,IAAI,KAAK,MAAM,SAAS,GAAG,EAAE,IAAI,MAAM,GAAI,IAAI;AAAA,EACjF,CAAA,EAAE,KAAK,IAAI,CAAC,MAAM;AACrB;AAaO,SAAS,eAAe,OAAO;AAEpC,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACX;AACE,MAAI,MAAM,OAAO,CAAC,MAAM,KAAK;AAC3B,WAAO,eAAe,SAAS,KAAK,CAAC;AAAA,EACzC;AACE,QAAM,SAAS,MAAM,QAAQ,GAAG;AAChC,QAAM,OAAO,MAAM,UAAU,GAAG,MAAM;AACtC,MAAI,CAAC,OAAO,QAAQ,OAAO,QAAQ,OAAO,EAAE,QAAQ,IAAI,MAAM,IAAI;AAChE,UAAM,IAAI,MAAMA,UAAQ,IAAI,aAAa,eAAe,sBAAsB,KAAK;AAAA,8FACOC,sBAAuB,GAAG,KAAK,CAAC;AAAA,EAC9H;AACE,MAAI,SAAS,MAAM,UAAU,SAAS,GAAG,MAAM,SAAS,CAAC;AACzD,MAAI;AACJ,MAAI,SAAS,SAAS;AACpB,aAAS,OAAO,MAAM,GAAG;AACzB,iBAAa,OAAO,MAAO;AAC3B,QAAI,OAAO,WAAW,KAAK,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,KAAK;AACtD,aAAO,CAAC,IAAI,OAAO,CAAC,EAAE,MAAM,CAAC;AAAA,IACnC;AACI,QAAI,CAAC,QAAQ,cAAc,WAAW,gBAAgB,UAAU,EAAE,QAAQ,UAAU,MAAM,IAAI;AAC5F,YAAM,IAAI,MAAMD,UAAQ,IAAI,aAAa,eAAe,sBAAsB,UAAU;AAAA,gGACEC,sBAAuB,IAAI,UAAU,CAAC;AAAA,IACtI;AAAA,EACA,OAAS;AACL,aAAS,OAAO,MAAM,GAAG;AAAA,EAC7B;AACE,WAAS,OAAO,IAAI,WAAS,WAAW,KAAK,CAAC;AAC9C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACH;AA8BO,SAAS,eAAe,OAAO;AACpC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACJ,IAAM;AACJ,MAAI;AAAA,IACF;AAAA,EACJ,IAAM;AACJ,MAAI,KAAK,QAAQ,KAAK,MAAM,IAAI;AAE9B,aAAS,OAAO,IAAI,CAAC,GAAG,MAAM,IAAI,IAAI,SAAS,GAAG,EAAE,IAAI,CAAC;AAAA,EAC1D,WAAU,KAAK,QAAQ,KAAK,MAAM,IAAI;AACrC,WAAO,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC;AACxB,WAAO,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC;AAAA,EAC5B;AACE,MAAI,KAAK,QAAQ,OAAO,MAAM,IAAI;AAChC,aAAS,GAAG,UAAU,IAAI,OAAO,KAAK,GAAG,CAAC;AAAA,EAC9C,OAAS;AACL,aAAS,GAAG,OAAO,KAAK,IAAI,CAAC;AAAA,EACjC;AACE,SAAO,GAAG,IAAI,IAAI,MAAM;AAC1B;AAuFO,SAAS,MAAM,OAAO,OAAO;AAClC,UAAQ,eAAe,KAAK;AAC5B,UAAQ,aAAa,KAAK;AAC1B,MAAI,MAAM,SAAS,SAAS,MAAM,SAAS,OAAO;AAChD,UAAM,QAAQ;AAAA,EAClB;AACE,MAAI,MAAM,SAAS,SAAS;AAC1B,UAAM,OAAO,CAAC,IAAI,IAAI,KAAK;AAAA,EAC/B,OAAS;AACL,UAAM,OAAO,CAAC,IAAI;AAAA,EACtB;AACE,SAAO,eAAe,KAAK;AAC7B;ACjOO,SAAS,QAAQ,OAAO;AAC7B,SAAO,OAAO,KAAK,EAAE,MAAM,kBAAkB,EAAE,CAAC,KAAK;AACvD;AAGO,SAAS,WAAW,QAAQ;AACjC,SAAO,WAAW,MAAM;AAC1B;ACZO,SAAS,wBAAwB,MAAM;AAC5C,SAAO,qBAAqB,eAAe,IAAI;AACjD;AACwB,uBAAuB,eAAe,CAAC,QAAQ,QAAQ,eAAe,WAAW,YAAY,SAAS,QAAQ,gBAAgB,cAAc,YAAY,CAAC;ACDjL,MAAM,YAAY,CAAC,aAAa,aAAa,aAAa,UAAU,SAAS,WAAW,OAAO;AAC/F,IAAI,IAAI,OAAK,GACX,IACA,KACA,KACA;AAWF,MAAM,oBAAoB,gBAAc;AACtC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ,IAAM;AACJ,QAAM,QAAQ;AAAA,IACZ,MAAM,CAAC,QAAQ,SAAS,WAAW,eAAe,gBAAgB,eAAe,CAAC,SAAS,cAAc,eAAe,CAAC,UAAU,YAAY;AAAA,EAChJ;AACD,SAAO,eAAe,OAAO,yBAAyB,OAAO;AAC/D;AACA,MAAM,gBAAgB,UAAU,OAAO,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAY1C;AACF,MAAM,eAAe,UAAU,QAAQ,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAa3C;AACF,MAAM,eAAe,OAAO,QAAQ;AAAA,EAClC,MAAM;AAAA,EACN,MAAM;AAAA,EACN,mBAAmB,CAAC,OAAO,WAAW;AACpC,UAAM;AAAA,MACJ;AAAA,IACN,IAAQ;AACJ,WAAO,CAAC,OAAO,MAAM,OAAO,WAAW,OAAO,GAAG,WAAW,cAAc,SAAS,OAAO,WAAW,SAAS,GAAG,WAAW,eAAe,OAAO,cAAc,WAAW,eAAe,CAAC,WAAW,SAAS,OAAO,YAAY,WAAW,eAAe,CAAC,WAAW,UAAU,OAAO,UAAU;AAAA,EACvS;AACA,CAAC,EAAE,CAAC;AAAA,EACF;AAAA,EACA;AACF,MAAM;AACJ,QAAM,aAAa,QAAQ,MAAM,MAAM,YAAY,KAAK;AACxD,QAAM,cAAc,WAAW,MAAM,MAAM,YAAY;AACvD,SAAO,SAAS;AAAA,IACd,SAAS;AAAA;AAAA,IAET,iBAAiB,MAAM,OAAO,MAAM,KAAK,QAAQ,SAAS,KAAK,MAAM,MAAM,QAAQ,KAAK,SAAS,MAAM,QAAQ,SAAS,UAAU,OAAO,IAAI;AAAA,IAC7I,QAAQ;AAAA,EACZ,GAAK,WAAW,YAAY,UAAU;AAAA,IAClC,WAAW;AAAA,IACX,cAAc;AAAA,IACd,QAAQ;AAAA,IACR,iBAAiB;AAAA,IACjB,WAAW;AAAA,IACX,cAAc,GAAG,WAAW,GAAG,UAAU,IAAI,KAAK,MAAM,cAAc,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU;AAAA,IACjG,kBAAkB;AAAA,MAChB,SAAS;AAAA,IACf;AAAA,EACA,GAAK,WAAW,YAAY,cAAc;AAAA,IACtC,cAAc;AAAA,EAClB,GAAK,WAAW,YAAY,aAAa;AAAA,IACrC,eAAe,MAAM,QAAQ,OAAO,MAAM;AAAA,EAC9C,GAAK,WAAW,eAAe;AAAA,IAC3B,SAAS;AAAA,MACP,YAAY;AAAA,IAClB;AAAA,EACG,GAAE,WAAW,eAAe,CAAC,WAAW,SAAS;AAAA,IAChD,UAAU;AAAA,EACX,GAAE,WAAW,eAAe,CAAC,WAAW,UAAU;AAAA,IACjD,QAAQ;AAAA,EACZ,CAAG;AACH,GAAG,CAAC;AAAA,EACF;AACF,MAAM,WAAW,cAAc,WAAW,IAAI,QAAQ,MAAM;AAAA,mBACzC,CAAC;AAAA,QACZ,aAAa,GAAG,CAAC;AAAA,EACvB;AAAA,EACA;AACF,MAAM,WAAW,cAAc,UAAU,IAAI,QAAQ,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAQtC,CAAC;AAAA;AAAA;AAAA;AAAA,YAIV,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAWL,eAAe,MAAM,QAAQ,OAAO,QAAQ,OAAO,KAAK,CAAC;AAC5D,MAAC,WAAwB,sBAAM,WAAW,SAASC,UAAS,SAAS,KAAK;AAC7E,QAAM,QAAQ,gBAAgB;AAAA,IAC5B,OAAO;AAAA,IACP,MAAM;AAAA,EACV,CAAG;AACD,QAAM;AAAA,IACF,YAAY;AAAA,IACZ;AAAA,IACA,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV;AAAA,EACN,IAAQ,OACJ,QAAQ,8BAA8B,OAAO,SAAS;AACxD,QAAM,aAAa,SAAS,CAAE,GAAE,OAAO;AAAA,IACrC;AAAA,IACA;AAAA,IACA;AAAA,IACA,aAAa,QAAQ,MAAM,QAAQ;AAAA,EACvC,CAAG;AACD,QAAM,UAAU,kBAAkB,UAAU;AAC5C,SAAoBC,oBAAK,cAAc,SAAS;AAAA,IAC9C,IAAI;AAAA,IACJ;AAAA,IACA,WAAW,KAAK,QAAQ,MAAM,SAAS;AAAA,IACvC;AAAA,EACD,GAAE,OAAO;AAAA,IACR,OAAO,SAAS;AAAA,MACd;AAAA,MACA;AAAA,IACN,GAAO,KAAK;AAAA,EACZ,CAAG,CAAC;AACJ,CAAC;AACDH,UAAQ,IAAI,aAAa,eAAe,SAAS,YAAmC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUlF,WAAW,UAAU,MAAM,CAAC,SAAS,QAAQ,KAAK,CAAC;AAAA;AAAA;AAAA;AAAA,EAInD,UAAU,UAAU;AAAA;AAAA;AAAA;AAAA,EAIpB,SAAS,UAAU;AAAA;AAAA;AAAA;AAAA,EAInB,WAAW,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAKrB,WAAW,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAKrB,QAAQ,UAAU,UAAU,CAAC,UAAU,QAAQ,UAAU,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA,EAIhE,OAAO,UAAU;AAAA;AAAA;AAAA;AAAA,EAIjB,IAAI,UAAU,UAAU,CAAC,UAAU,QAAQ,UAAU,UAAU,CAAC,UAAU,MAAM,UAAU,QAAQ,UAAU,IAAI,CAAC,CAAC,GAAG,UAAU,MAAM,UAAU,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtJ,SAAS,UAAgD,UAAU,CAAC,UAAU,MAAM,CAAC,YAAY,eAAe,WAAW,MAAM,CAAC,GAAG,UAAU,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtJ,OAAO,UAAU,UAAU,CAAC,UAAU,QAAQ,UAAU,MAAM,CAAC;AACjE,IAAI;ACzNoB,SAAA,UAAU,EAAC,QAAM;AAC9B,SAAA,qBAAC,OAAI,EAAA,OAAM,MAAK,QAAO,MAAK,SAAQ,aAAY,MAAK,QAAO,OAAM,8BACzE,UAAA;AAAA,IAAA,oBAAC,UAAK,GAAE,gGAA+F,QAAQ,MAAM,kBAAe,SAAO;AAAA,IAC1I,oBAAA,QAAA,EAAK,GAAE,8XAA6X,KAAW,CAAA;AAAA,EAAA,GAChZ;AACJ;","x_google_ignoreList":[0,1,2,3]}

package/dist/sortDown-cDA6MpOw.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sortDown-cDA6MpOw.js","sources":["../src/Components/Svg/sortUp.js","../src/Components/Svg/sortDown.js"],"sourcesContent":["export default function SortUp({ isSelected, fill }) {\n  return (\n    <svg\n      width=\"7\"\n      height=\"7\"\n      viewBox=\"0 0 5 5\"\n      fill=\"none\"\n      xmlns=\"http://www.w3.org/2000/svg\"\n    >\n      <path\n        d=\"M2.69528 0.665039L4.91444 4.50874H0.476118L2.69528 0.665039Z\"\n        fill={fill}\n        fill-opacity={isSelected ? \"1\" : \"0.2\"}\n      />\n    </svg>\n  );\n}\n","export default function SortDown({ isSelected, fill }) {\n  return (\n    <svg\n      width=\"7\"\n      height=\"7\"\n      viewBox=\"0 0 5 5\"\n      fill=\"none\"\n      xmlns=\"http://www.w3.org/2000/svg\"\n    >\n      <path\n        d=\"M2.69535 4.04883L0.476187 0.20513L4.91451 0.20513L2.69535 4.04883Z\"\n        fill={fill}\n        fill-opacity={isSelected ? \"1\" : \"0.2\"}\n      />\n    </svg>\n  );\n}\n"],"names":[],"mappings":";AAAA,SAAwB,OAAO,EAAE,YAAY,QAAQ;AAEjD,SAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,OAAM;AAAA,MACN,QAAO;AAAA,MACP,SAAQ;AAAA,MACR,MAAK;AAAA,MACL,OAAM;AAAA,MAEN,UAAA;AAAA,QAAC;AAAA,QAAA;AAAA,UACC,GAAE;AAAA,UACF;AAAA,UACA,gBAAc,aAAa,MAAM;AAAA,QAAA;AAAA,MAAA;AAAA,IACnC;AAAA,EACF;AAEJ;AChBA,SAAwB,SAAS,EAAE,YAAY,QAAQ;AAEnD,SAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,OAAM;AAAA,MACN,QAAO;AAAA,MACP,SAAQ;AAAA,MACR,MAAK;AAAA,MACL,OAAM;AAAA,MAEN,UAAA;AAAA,QAAC;AAAA,QAAA;AAAA,UACC,GAAE;AAAA,UACF;AAAA,UACA,gBAAc,aAAa,MAAM;AAAA,QAAA;AAAA,MAAA;AAAA,IACnC;AAAA,EACF;AAEJ;"}

package/dist/swapHorizontal-BI2PzZwN.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swapHorizontal-BI2PzZwN.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/swapHorizontal.js"],"sourcesContent":["import { svg } from 'lit';\nexport const swapHorizontalSvg = svg `<svg fill=\"none\" viewBox=\"0 0 20 20\">\n  <path\n    fill=\"currentColor\"\n    fill-rule=\"evenodd\"\n    d=\"M6.76.3a1 1 0 0 1 0 1.4L4.07 4.4h9a1 1 0 1 1 0 2h-9l2.69 2.68a1 1 0 1 1-1.42 1.42L.95 6.09a1 1 0 0 1 0-1.4l4.4-4.4a1 1 0 0 1 1.4 0Zm6.49 9.21a1 1 0 0 1 1.41 0l4.39 4.4a1 1 0 0 1 0 1.4l-4.39 4.4a1 1 0 0 1-1.41-1.42l2.68-2.68h-9a1 1 0 0 1 0-2h9l-2.68-2.68a1 1 0 0 1 0-1.42Z\"\n    clip-rule=\"evenodd\"\n  />\n</svg>`;\n//# sourceMappingURL=swapHorizontal.js.map"],"names":["svg"],"mappings":";AACO,MAAM,oBAAoBA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/swapHorizontalBold-CWlwK-F6.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swapHorizontalBold-CWlwK-F6.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/swapHorizontalBold.js"],"sourcesContent":["import { svg } from 'lit';\nexport const swapHorizontalBoldSvg = svg `<svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\">\n  <path\n    fill=\"currentColor\"\n    fill-rule=\"evenodd\"\n    d=\"M3.77986 0.566631C4.0589 0.845577 4.0589 1.29784 3.77986 1.57678L3.08261 2.2738H6.34184C6.73647 2.2738 7.05637 2.5936 7.05637 2.98808C7.05637 3.38257 6.73647 3.70237 6.34184 3.70237H3.08261L3.77986 4.39938C4.0589 4.67833 4.0589 5.13059 3.77986 5.40954C3.50082 5.68848 3.04841 5.68848 2.76937 5.40954L0.852346 3.49316C0.573306 3.21421 0.573306 2.76195 0.852346 2.48301L2.76937 0.566631C3.04841 0.287685 3.50082 0.287685 3.77986 0.566631ZM6.22 4.59102C6.49904 4.31208 6.95145 4.31208 7.23049 4.59102L9.14751 6.5074C9.42655 6.78634 9.42655 7.23861 9.14751 7.51755L7.23049 9.43393C6.95145 9.71287 6.49904 9.71287 6.22 9.43393C5.94096 9.15498 5.94096 8.70272 6.22 8.42377L6.91725 7.72676L3.65802 7.72676C3.26339 7.72676 2.94349 7.40696 2.94349 7.01247C2.94349 6.61798 3.26339 6.29819 3.65802 6.29819L6.91725 6.29819L6.22 5.60117C5.94096 5.32223 5.94096 4.86997 6.22 4.59102Z\"\n    clip-rule=\"evenodd\"\n  />\n</svg>`;\n//# sourceMappingURL=swapHorizontalBold.js.map"],"names":["svg"],"mappings":";AACO,MAAM,wBAAwBA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/swapHorizontalMedium-BmLVJu35.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swapHorizontalMedium-BmLVJu35.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/swapHorizontalMedium.js"],"sourcesContent":["import { svg } from 'lit';\nexport const swapHorizontalMediumSvg = svg `<svg\n  width=\"14\"\n  height=\"14\"\n  viewBox=\"0 0 14 14\"\n  fill=\"none\"\n  xmlns=\"http://www.w3.org/2000/svg\"\n>\n  <path\n    fill-rule=\"evenodd\"\n    clip-rule=\"evenodd\"\n    d=\"M13.7306 3.24213C14.0725 3.58384 14.0725 4.13786 13.7306 4.47957L10.7418 7.46737C10.4 7.80908 9.84581 7.80908 9.50399 7.46737C9.16216 7.12567 9.16216 6.57165 9.50399 6.22994L10.9986 4.73585H5.34082C4.85741 4.73585 4.46553 4.3441 4.46553 3.86085C4.46553 3.3776 4.85741 2.98585 5.34082 2.98585L10.9986 2.98585L9.50399 1.49177C9.16216 1.15006 9.16216 0.596037 9.50399 0.254328C9.84581 -0.0873803 10.4 -0.0873803 10.7418 0.254328L13.7306 3.24213ZM9.52515 10.1352C9.52515 10.6185 9.13327 11.0102 8.64986 11.0102L2.9921 11.0102L4.48669 12.5043C4.82852 12.846 4.82852 13.4001 4.48669 13.7418C4.14487 14.0835 3.59066 14.0835 3.24884 13.7418L0.26003 10.754C0.0958806 10.5899 0.0036621 10.3673 0.00366211 10.1352C0.00366212 9.90318 0.0958806 9.68062 0.26003 9.51652L3.24884 6.52872C3.59066 6.18701 4.14487 6.18701 4.48669 6.52872C4.82851 6.87043 4.82851 7.42445 4.48669 7.76616L2.9921 9.26024L8.64986 9.26024C9.13327 9.26024 9.52515 9.65199 9.52515 10.1352Z\"\n    fill=\"currentColor\"\n  />\n</svg>\n\n`;\n//# sourceMappingURL=swapHorizontalMedium.js.map"],"names":["svg"],"mappings":";AACO,MAAM,0BAA0BA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/swapHorizontalRoundedBold-Bu7b_4Tq.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swapHorizontalRoundedBold-Bu7b_4Tq.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/swapHorizontalRoundedBold.js"],"sourcesContent":["import { svg } from 'lit';\nexport const swapHorizontalRoundedBoldSvg = svg `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\n  <path \n    fill=\"currentColor\"\n    fill-rule=\"evenodd\" \n    clip-rule=\"evenodd\" \n    d=\"M8.3071 0.292893C8.69763 0.683417 8.69763 1.31658 8.3071 1.70711L6.41421 3.6H11.3404C13.8368 3.6 16.0533 5.1975 16.8427 7.56588L16.9487 7.88377C17.1233 8.40772 16.8402 8.97404 16.3162 9.14868C15.7923 9.32333 15.226 9.04017 15.0513 8.51623L14.9453 8.19834C14.4281 6.64664 12.976 5.6 11.3404 5.6H6.41421L8.3071 7.49289C8.69763 7.88342 8.69763 8.51658 8.3071 8.90711C7.91658 9.29763 7.28341 9.29763 6.89289 8.90711L3.29289 5.30711C2.90236 4.91658 2.90236 4.28342 3.29289 3.89289L6.89289 0.292893C7.28341 -0.0976311 7.91658 -0.0976311 8.3071 0.292893ZM3.68377 10.8513C4.20771 10.6767 4.77403 10.9598 4.94868 11.4838L5.05464 11.8017C5.57188 13.3534 7.024 14.4 8.65964 14.4L13.5858 14.4L11.6929 12.5071C11.3024 12.1166 11.3024 11.4834 11.6929 11.0929C12.0834 10.7024 12.7166 10.7024 13.1071 11.0929L16.7071 14.6929C17.0976 15.0834 17.0976 15.7166 16.7071 16.1071L13.1071 19.7071C12.7166 20.0976 12.0834 20.0976 11.6929 19.7071C11.3024 19.3166 11.3024 18.6834 11.6929 18.2929L13.5858 16.4L8.65964 16.4C6.16314 16.4 3.94674 14.8025 3.15728 12.4341L3.05131 12.1162C2.87667 11.5923 3.15983 11.026 3.68377 10.8513Z\" \n  />\n</svg>`;\n//# sourceMappingURL=swapHorizontalRoundedBold.js.map"],"names":["svg"],"mappings":";AACO,MAAM,+BAA+BA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/swapVertical-9yVsysvS.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swapVertical-9yVsysvS.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/swapVertical.js"],"sourcesContent":["import { svg } from 'lit';\nexport const swapVerticalSvg = svg `<svg fill=\"none\" viewBox=\"0 0 14 14\">\n  <path\n    fill=\"currentColor\"\n    fill-rule=\"evenodd\"\n    d=\"M3.48 2.18a1 1 0 0 1 1.41 0l2.68 2.68a1 1 0 1 1-1.41 1.42l-.98-.98v4.56a1 1 0 0 1-2 0V5.3l-.97.98A1 1 0 0 1 .79 4.86l2.69-2.68Zm6.34 2.93a1 1 0 0 1 1 1v4.56l.97-.98a1 1 0 1 1 1.42 1.42l-2.69 2.68a1 1 0 0 1-1.41 0l-2.68-2.68a1 1 0 0 1 1.41-1.42l.98.98V6.1a1 1 0 0 1 1-1Z\"\n    clip-rule=\"evenodd\"\n  />\n</svg>`;\n//# sourceMappingURL=swapVertical.js.map"],"names":["svg"],"mappings":";AACO,MAAM,kBAAkBA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/telegram-0bWPCnom.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"telegram-0bWPCnom.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/telegram.js"],"sourcesContent":["import { svg } from 'lit';\nexport const telegramSvg = svg `<svg width=\"32\" height=\"32\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\">\n  <g clip-path=\"url(#a)\">\n    <path fill=\"url(#b)\" d=\"M0 0h32v32H0z\"/>\n    <path fill-rule=\"evenodd\" clip-rule=\"evenodd\" d=\"M7.034 15.252c4.975-2.167 8.293-3.596 9.953-4.287 4.74-1.971 5.725-2.314 6.366-2.325.142-.002.457.033.662.198.172.14.22.33.243.463.022.132.05.435.028.671-.257 2.7-1.368 9.248-1.933 12.27-.24 1.28-.71 1.708-1.167 1.75-.99.091-1.743-.655-2.703-1.284-1.502-.985-2.351-1.598-3.81-2.558-1.684-1.11-.592-1.721.368-2.718.252-.261 4.619-4.233 4.703-4.594.01-.045.02-.213-.08-.301-.1-.09-.246-.059-.353-.035-.15.034-2.55 1.62-7.198 4.758-.682.468-1.298.696-1.851.684-.61-.013-1.782-.344-2.653-.628-1.069-.347-1.918-.53-1.845-1.12.039-.308.462-.623 1.27-.944Z\" fill=\"#fff\"/>\n  </g>\n  <path d=\"M.5 16C.5 7.44 7.44.5 16 .5 24.56.5 31.5 7.44 31.5 16c0 8.56-6.94 15.5-15.5 15.5C7.44 31.5.5 24.56.5 16Z\" stroke=\"#141414\" stroke-opacity=\".05\"/>\n  <defs>\n    <linearGradient id=\"b\" x1=\"1600\" y1=\"0\" x2=\"1600\" y2=\"3176.27\" gradientUnits=\"userSpaceOnUse\">\n      <stop stop-color=\"#2AABEE\"/>\n      <stop offset=\"1\" stop-color=\"#229ED9\"/>\n    </linearGradient>\n    <clipPath id=\"a\">\n      <path d=\"M0 16C0 7.163 7.163 0 16 0s16 7.163 16 16-7.163 16-16 16S0 24.837 0 16Z\" fill=\"#fff\"/>\n    </clipPath>\n  </defs>\n</svg>`;\n//# sourceMappingURL=telegram.js.map"],"names":["svg"],"mappings":";AACO,MAAM,cAAcA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/three-dots-V6GJeVIa.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"three-dots-V6GJeVIa.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/three-dots.js"],"sourcesContent":["import { svg } from 'lit';\nexport const threeDotsSvg = svg `<svg width=\"14\" height=\"15\" viewBox=\"0 0 14 15\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n  <path d=\"M7 3.71875C6.0335 3.71875 5.25 2.93525 5.25 1.96875C5.25 1.00225 6.0335 0.21875 7 0.21875C7.9665 0.21875 8.75 1.00225 8.75 1.96875C8.75 2.93525 7.9665 3.71875 7 3.71875Z\" fill=\"#949E9E\"/>\n  <path d=\"M7 8.96875C6.0335 8.96875 5.25 8.18525 5.25 7.21875C5.25 6.25225 6.0335 5.46875 7 5.46875C7.9665 5.46875 8.75 6.25225 8.75 7.21875C8.75 8.18525 7.9665 8.96875 7 8.96875Z\" fill=\"#949E9E\"/>\n  <path d=\"M5.25 12.4688C5.25 13.4352 6.0335 14.2187 7 14.2187C7.9665 14.2187 8.75 13.4352 8.75 12.4688C8.75 11.5023 7.9665 10.7188 7 10.7188C6.0335 10.7188 5.25 11.5023 5.25 12.4688Z\" fill=\"#949E9E\"/>\n</svg>`;\n//# sourceMappingURL=three-dots.js.map"],"names":["svg"],"mappings":";AACO,MAAM,eAAeA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/truncate-DSxFWEga.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"truncate-DSxFWEga.js","sources":["../src/utils/truncate.js"],"sourcesContent":["export default function truncate(number, decimal) {\n  let pow = Math.pow(10, decimal);\n  return Math.trunc(number * pow) / pow;\n}\n"],"names":[],"mappings":"AAAwB,SAAA,SAAS,QAAQ,SAAS;AAChD,MAAI,MAAM,KAAK,IAAI,IAAI,OAAO;AAC9B,SAAO,KAAK,MAAM,SAAS,GAAG,IAAI;AACpC;"}

package/dist/twitch-BnXJxO5H.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"twitch-BnXJxO5H.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/twitch.js"],"sourcesContent":["import { svg } from 'lit';\nexport const twitchSvg = svg `<svg fill=\"none\" viewBox=\"0 0 40 40\">\n  <g clip-path=\"url(#a)\">\n    <g clip-path=\"url(#b)\">\n      <circle cx=\"20\" cy=\"19.89\" r=\"20\" fill=\"#5A3E85\" />\n      <g clip-path=\"url(#c)\">\n        <path\n          fill=\"#fff\"\n          d=\"M18.22 25.7 20 23.91h3.34l2.1-2.1v-6.68H15.4v8.78h2.82v1.77Zm3.87-8.16h1.25v3.66H22.1v-3.66Zm-3.34 0H20v3.66h-1.25v-3.66ZM20 7.9a12 12 0 1 0 0 24 12 12 0 0 0 0-24Zm6.69 14.56-3.66 3.66h-2.72l-1.77 1.78h-1.88V26.1H13.3v-9.82l.94-2.4H26.7v8.56Z\"\n        />\n      </g>\n    </g>\n  </g>\n  <defs>\n    <clipPath id=\"a\"><rect width=\"40\" height=\"40\" fill=\"#fff\" rx=\"20\" /></clipPath>\n    <clipPath id=\"b\"><path fill=\"#fff\" d=\"M0 0h40v40H0z\" /></clipPath>\n    <clipPath id=\"c\"><path fill=\"#fff\" d=\"M8 7.89h24v24H8z\" /></clipPath>\n  </defs>\n</svg>`;\n//# sourceMappingURL=twitch.js.map"],"names":["svg"],"mappings":";AACO,MAAM,YAAYA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/twitterIcon-DKgyPicl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"twitterIcon-DKgyPicl.js","sources":["../node_modules/@reown/appkit-ui/dist/esm/src/assets/svg/twitterIcon.js"],"sourcesContent":["import { svg } from 'lit';\nexport const twitterIconSvg = svg `<svg fill=\"none\" viewBox=\"0 0 16 16\">\n  <path\n    fill=\"currentColor\"\n    d=\"m14.36 4.74.01.42c0 4.34-3.3 9.34-9.34 9.34A9.3 9.3 0 0 1 0 13.03a6.6 6.6 0 0 0 4.86-1.36 3.29 3.29 0 0 1-3.07-2.28c.5.1 1 .07 1.48-.06A3.28 3.28 0 0 1 .64 6.11v-.04c.46.26.97.4 1.49.41A3.29 3.29 0 0 1 1.11 2.1a9.32 9.32 0 0 0 6.77 3.43 3.28 3.28 0 0 1 5.6-3 6.59 6.59 0 0 0 2.08-.8 3.3 3.3 0 0 1-1.45 1.82A6.53 6.53 0 0 0 16 3.04c-.44.66-1 1.23-1.64 1.7Z\"\n  />\n</svg>`;\n//# sourceMappingURL=twitterIcon.js.map"],"names":["svg"],"mappings":";AACO,MAAM,iBAAiBA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;","x_google_ignoreList":[0]}

package/dist/unsupportedProp-DvjrBqjA.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unsupportedProp-DvjrBqjA.js","sources":["../node_modules/@mui/utils/esm/unsupportedProp/unsupportedProp.js"],"sourcesContent":["export default function unsupportedProp(props, propName, componentName, location, propFullName) {\n  if (process.env.NODE_ENV === 'production') {\n    return null;\n  }\n  const propFullNameSafe = propFullName || propName;\n  if (typeof props[propName] !== 'undefined') {\n    return new Error(`The prop \\`${propFullNameSafe}\\` is not supported. Please remove it.`);\n  }\n  return null;\n}"],"names":["process"],"mappings":";AAAe,SAAS,gBAAgB,OAAO,UAAU,eAAe,UAAU,cAAc;AAC9F,MAAIA,UAAQ,IAAI,aAAa,cAAc;AACzC,WAAO;AAAA,EACX;AACE,QAAM,mBAAmB,gBAAgB;AACzC,MAAI,OAAO,MAAM,QAAQ,MAAM,aAAa;AAC1C,WAAO,IAAI,MAAM,cAAc,gBAAgB,wCAAwC;AAAA,EAC3F;AACE,SAAO;AACT;","x_google_ignoreList":[0]}