superstack-wallet-sdk 0.4.4 → 0.4.7

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Hex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hex.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Hex.js"],"sourcesContent":["import { equalBytes } from '@noble/curves/abstract/utils';\nimport * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as internal_bytes from './internal/bytes.js';\nimport * as internal from './internal/hex.js';\nimport * as Json from './Json.js';\nconst encoder = /*#__PURE__*/ new TextEncoder();\nconst hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));\n/**\n * Asserts if the given value is {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.assert('abc')\n * // @error: InvalidHexValueTypeError:\n * // @error: Value `\"abc\"` of type `string` is an invalid hex type.\n * // @error: Hex types must be represented as `\"0x\\${string}\"`.\n * ```\n *\n * @param value - The value to assert.\n * @param options - Options.\n */\nexport function assert(value, options = {}) {\n    const { strict = false } = options;\n    if (!value)\n        throw new InvalidHexTypeError(value);\n    if (typeof value !== 'string')\n        throw new InvalidHexTypeError(value);\n    if (strict) {\n        if (!/^0x[0-9a-fA-F]*$/.test(value))\n            throw new InvalidHexValueError(value);\n    }\n    if (!value.startsWith('0x'))\n        throw new InvalidHexValueError(value);\n}\n/**\n * Concatenates two or more {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.concat('0x123', '0x456')\n * // @log: '0x123456'\n * ```\n *\n * @param values - The {@link ox#Hex.Hex} values to concatenate.\n * @returns The concatenated {@link ox#Hex.Hex} value.\n */\nexport function concat(...values) {\n    return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;\n}\n/**\n * Instantiates a {@link ox#Hex.Hex} value from a hex string or {@link ox#Bytes.Bytes} value.\n *\n * :::tip\n *\n * To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:\n *\n * - `Hex.fromBoolean`\n *\n * - `Hex.fromString`\n *\n * - `Hex.fromNumber`\n *\n * :::\n *\n * @example\n * ```ts twoslash\n * import { Bytes, Hex } from 'ox'\n *\n * Hex.from('0x48656c6c6f20576f726c6421')\n * // @log: '0x48656c6c6f20576f726c6421'\n *\n * Hex.from(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // @log: '0x48656c6c6f20576f726c6421'\n * ```\n *\n * @param value - The {@link ox#Bytes.Bytes} value to encode.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function from(value) {\n    if (value instanceof Uint8Array)\n        return fromBytes(value);\n    if (Array.isArray(value))\n        return fromBytes(new Uint8Array(value));\n    return value;\n}\n/**\n * Encodes a boolean into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromBoolean(true)\n * // @log: '0x1'\n *\n * Hex.fromBoolean(false)\n * // @log: '0x0'\n *\n * Hex.fromBoolean(true, { size: 32 })\n * // @log: '0x0000000000000000000000000000000000000000000000000000000000000001'\n * ```\n *\n * @param value - The boolean value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromBoolean(value, options = {}) {\n    const hex = `0x${Number(value)}`;\n    if (typeof options.size === 'number') {\n        internal.assertSize(hex, options.size);\n        return padLeft(hex, options.size);\n    }\n    return hex;\n}\n/**\n * Encodes a {@link ox#Bytes.Bytes} value into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Bytes, Hex } from 'ox'\n *\n * Hex.fromBytes(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // @log: '0x48656c6c6f20576f726c6421'\n * ```\n *\n * @param value - The {@link ox#Bytes.Bytes} value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromBytes(value, options = {}) {\n    let string = '';\n    for (let i = 0; i < value.length; i++)\n        string += hexes[value[i]];\n    const hex = `0x${string}`;\n    if (typeof options.size === 'number') {\n        internal.assertSize(hex, options.size);\n        return padRight(hex, options.size);\n    }\n    return hex;\n}\n/**\n * Encodes a number or bigint into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromNumber(420)\n * // @log: '0x1a4'\n *\n * Hex.fromNumber(420, { size: 32 })\n * // @log: '0x00000000000000000000000000000000000000000000000000000000000001a4'\n * ```\n *\n * @param value - The number or bigint value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromNumber(value, options = {}) {\n    const { signed, size } = options;\n    const value_ = BigInt(value);\n    let maxValue;\n    if (size) {\n        if (signed)\n            maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;\n        else\n            maxValue = 2n ** (BigInt(size) * 8n) - 1n;\n    }\n    else if (typeof value === 'number') {\n        maxValue = BigInt(Number.MAX_SAFE_INTEGER);\n    }\n    const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0;\n    if ((maxValue && value_ > maxValue) || value_ < minValue) {\n        const suffix = typeof value === 'bigint' ? 'n' : '';\n        throw new IntegerOutOfRangeError({\n            max: maxValue ? `${maxValue}${suffix}` : undefined,\n            min: `${minValue}${suffix}`,\n            signed,\n            size,\n            value: `${value}${suffix}`,\n        });\n    }\n    const stringValue = (signed && value_ < 0 ? (1n << BigInt(size * 8)) + BigInt(value_) : value_).toString(16);\n    const hex = `0x${stringValue}`;\n    if (size)\n        return padLeft(hex, size);\n    return hex;\n}\n/**\n * Encodes a string into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n * Hex.fromString('Hello World!')\n * // '0x48656c6c6f20576f726c6421'\n *\n * Hex.fromString('Hello World!', { size: 32 })\n * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'\n * ```\n *\n * @param value - The string value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromString(value, options = {}) {\n    return fromBytes(encoder.encode(value), options);\n}\n/**\n * Checks if two {@link ox#Hex.Hex} values are equal.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.isEqual('0xdeadbeef', '0xdeadbeef')\n * // @log: true\n *\n * Hex.isEqual('0xda', '0xba')\n * // @log: false\n * ```\n *\n * @param hexA - The first {@link ox#Hex.Hex} value.\n * @param hexB - The second {@link ox#Hex.Hex} value.\n * @returns `true` if the two {@link ox#Hex.Hex} values are equal, `false` otherwise.\n */\nexport function isEqual(hexA, hexB) {\n    return equalBytes(Bytes.fromHex(hexA), Bytes.fromHex(hexB));\n}\n/**\n * Pads a {@link ox#Hex.Hex} value to the left with zero bytes until it reaches the given `size` (default: 32 bytes).\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.padLeft('0x1234', 4)\n * // @log: '0x00001234'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to pad.\n * @param size - The size (in bytes) of the output hex value.\n * @returns The padded {@link ox#Hex.Hex} value.\n */\nexport function padLeft(value, size) {\n    return internal.pad(value, { dir: 'left', size });\n}\n/**\n * Pads a {@link ox#Hex.Hex} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).\n *\n * @example\n * ```ts\n * import { Hex } from 'ox'\n *\n * Hex.padRight('0x1234', 4)\n * // @log: '0x12340000'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to pad.\n * @param size - The size (in bytes) of the output hex value.\n * @returns The padded {@link ox#Hex.Hex} value.\n */\nexport function padRight(value, size) {\n    return internal.pad(value, { dir: 'right', size });\n}\n/**\n * Generates a random {@link ox#Hex.Hex} value of the specified length.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * const hex = Hex.random(32)\n * // @log: '0x...'\n * ```\n *\n * @returns Random {@link ox#Hex.Hex} value.\n */\nexport function random(length) {\n    return fromBytes(Bytes.random(length));\n}\n/**\n * Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.slice('0x0123456789', 1, 4)\n * // @log: '0x234567'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to slice.\n * @param start - The start offset (in bytes).\n * @param end - The end offset (in bytes).\n * @param options - Options.\n * @returns The sliced {@link ox#Hex.Hex} value.\n */\nexport function slice(value, start, end, options = {}) {\n    const { strict } = options;\n    internal.assertStartOffset(value, start);\n    const value_ = `0x${value\n        .replace('0x', '')\n        .slice((start ?? 0) * 2, (end ?? value.length) * 2)}`;\n    if (strict)\n        internal.assertEndOffset(value_, start, end);\n    return value_;\n}\n/**\n * Retrieves the size of a {@link ox#Hex.Hex} value (in bytes).\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.size('0xdeadbeef')\n * // @log: 4\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to get the size of.\n * @returns The size of the {@link ox#Hex.Hex} value (in bytes).\n */\nexport function size(value) {\n    return Math.ceil((value.length - 2) / 2);\n}\n/**\n * Trims leading zeros from a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.trimLeft('0x00000000deadbeef')\n * // @log: '0xdeadbeef'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to trim.\n * @returns The trimmed {@link ox#Hex.Hex} value.\n */\nexport function trimLeft(value) {\n    return internal.trim(value, { dir: 'left' });\n}\n/**\n * Trims trailing zeros from a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.trimRight('0xdeadbeef00000000')\n * // @log: '0xdeadbeef'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to trim.\n * @returns The trimmed {@link ox#Hex.Hex} value.\n */\nexport function trimRight(value) {\n    return internal.trim(value, { dir: 'right' });\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a BigInt.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toBigInt('0x1a4')\n * // @log: 420n\n *\n * Hex.toBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })\n * // @log: 420n\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded BigInt.\n */\nexport function toBigInt(hex, options = {}) {\n    const { signed } = options;\n    if (options.size)\n        internal.assertSize(hex, options.size);\n    const value = BigInt(hex);\n    if (!signed)\n        return value;\n    const size = (hex.length - 2) / 2;\n    const max_unsigned = (1n << (BigInt(size) * 8n)) - 1n;\n    const max_signed = max_unsigned >> 1n;\n    if (value <= max_signed)\n        return value;\n    return value - max_unsigned - 1n;\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a boolean.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toBoolean('0x01')\n * // @log: true\n *\n * Hex.toBoolean('0x0000000000000000000000000000000000000000000000000000000000000001', { size: 32 })\n * // @log: true\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded boolean.\n */\nexport function toBoolean(hex, options = {}) {\n    if (options.size)\n        internal.assertSize(hex, options.size);\n    const hex_ = trimLeft(hex);\n    if (hex_ === '0x')\n        return false;\n    if (hex_ === '0x1')\n        return true;\n    throw new InvalidHexBooleanError(hex);\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * const data = Hex.toBytes('0x48656c6c6f20776f726c6421')\n * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded {@link ox#Bytes.Bytes}.\n */\nexport function toBytes(hex, options = {}) {\n    return Bytes.fromHex(hex, options);\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a number.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toNumber('0x1a4')\n * // @log: 420\n *\n * Hex.toNumber('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })\n * // @log: 420\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded number.\n */\nexport function toNumber(hex, options = {}) {\n    const { signed, size } = options;\n    if (!signed && !size)\n        return Number(hex);\n    return Number(toBigInt(hex, options));\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a string.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toString('0x48656c6c6f20576f726c6421')\n * // @log: 'Hello world!'\n *\n * Hex.toString('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {\n *  size: 32,\n * })\n * // @log: 'Hello world'\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded string.\n */\nexport function toString(hex, options = {}) {\n    const { size } = options;\n    let bytes = Bytes.fromHex(hex);\n    if (size) {\n        internal_bytes.assertSize(bytes, size);\n        bytes = Bytes.trimRight(bytes);\n    }\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Checks if the given value is {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes, Hex } from 'ox'\n *\n * Hex.validate('0xdeadbeef')\n * // @log: true\n *\n * Hex.validate(Bytes.from([1, 2, 3]))\n * // @log: false\n * ```\n *\n * @param value - The value to check.\n * @param options - Options.\n * @returns `true` if the value is a {@link ox#Hex.Hex}, `false` otherwise.\n */\nexport function validate(value, options = {}) {\n    const { strict = false } = options;\n    try {\n        assert(value, { strict });\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Thrown when the provided integer is out of range, and cannot be represented as a hex value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromNumber(420182738912731283712937129)\n * // @error: Hex.IntegerOutOfRangeError: Number \\`4.2018273891273126e+26\\` is not in safe unsigned integer range (`0` to `9007199254740991`)\n * ```\n */\nexport class IntegerOutOfRangeError extends Errors.BaseError {\n    constructor({ max, min, signed, size, value, }) {\n        super(`Number \\`${value}\\` is not in safe${size ? ` ${size * 8}-bit` : ''}${signed ? ' signed' : ' unsigned'} integer range ${max ? `(\\`${min}\\` to \\`${max}\\`)` : `(above \\`${min}\\`)`}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.IntegerOutOfRangeError'\n        });\n    }\n}\n/**\n * Thrown when the provided hex value cannot be represented as a boolean.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toBoolean('0xa')\n * // @error: Hex.InvalidHexBooleanError: Hex value `\"0xa\"` is not a valid boolean.\n * // @error: The hex value must be `\"0x0\"` (false) or `\"0x1\"` (true).\n * ```\n */\nexport class InvalidHexBooleanError extends Errors.BaseError {\n    constructor(hex) {\n        super(`Hex value \\`\"${hex}\"\\` is not a valid boolean.`, {\n            metaMessages: [\n                'The hex value must be `\"0x0\"` (false) or `\"0x1\"` (true).',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidHexBooleanError'\n        });\n    }\n}\n/**\n * Thrown when the provided value is not a valid hex type.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.assert(1)\n * // @error: Hex.InvalidHexTypeError: Value `1` of type `number` is an invalid hex type.\n * ```\n */\nexport class InvalidHexTypeError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${typeof value === 'object' ? Json.stringify(value) : value}\\` of type \\`${typeof value}\\` is an invalid hex type.`, {\n            metaMessages: ['Hex types must be represented as `\"0x${string}\"`.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidHexTypeError'\n        });\n    }\n}\n/**\n * Thrown when the provided hex value is invalid.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.assert('0x0123456789abcdefg')\n * // @error: Hex.InvalidHexValueError: Value `0x0123456789abcdefg` is an invalid hex value.\n * // @error: Hex values must start with `\"0x\"` and contain only hexadecimal characters (0-9, a-f, A-F).\n * ```\n */\nexport class InvalidHexValueError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${value}\\` is an invalid hex value.`, {\n            metaMessages: [\n                'Hex values must start with `\"0x\"` and contain only hexadecimal characters (0-9, a-f, A-F).',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidHexValueError'\n        });\n    }\n}\n/**\n * Thrown when the provided hex value is an odd length.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.fromHex('0xabcde')\n * // @error: Hex.InvalidLengthError: Hex value `\"0xabcde\"` is an odd length (5 nibbles).\n * ```\n */\nexport class InvalidLengthError extends Errors.BaseError {\n    constructor(value) {\n        super(`Hex value \\`\"${value}\"\\` is an odd length (${value.length - 2} nibbles).`, {\n            metaMessages: ['It must be an even length.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidLengthError'\n        });\n    }\n}\n/**\n * Thrown when the size of the value exceeds the expected max size.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromString('Hello World!', { size: 8 })\n * // @error: Hex.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.\n * ```\n */\nexport class SizeOverflowError extends Errors.BaseError {\n    constructor({ givenSize, maxSize }) {\n        super(`Size cannot exceed \\`${maxSize}\\` bytes. Given size: \\`${givenSize}\\` bytes.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.SizeOverflowError'\n        });\n    }\n}\n/**\n * Thrown when the slice offset exceeds the bounds of the value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.slice('0x0123456789', 6)\n * // @error: Hex.SliceOffsetOutOfBoundsError: Slice starting at offset `6` is out-of-bounds (size: `5`).\n * ```\n */\nexport class SliceOffsetOutOfBoundsError extends Errors.BaseError {\n    constructor({ offset, position, size, }) {\n        super(`Slice ${position === 'start' ? 'starting' : 'ending'} at offset \\`${offset}\\` is out-of-bounds (size: \\`${size}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.SliceOffsetOutOfBoundsError'\n        });\n    }\n}\n/**\n * Thrown when the size of the value exceeds the pad size.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.padLeft('0x1a4e12a45a21323123aaa87a897a897a898a6567a578a867a98778a667a85a875a87a6a787a65a675a6a9', 32)\n * // @error: Hex.SizeExceedsPaddingSizeError: Hex size (`43`) exceeds padding size (`32`).\n * ```\n */\nexport class SizeExceedsPaddingSizeError extends Errors.BaseError {\n    constructor({ size, targetSize, type, }) {\n        super(`${type.charAt(0).toUpperCase()}${type\n            .slice(1)\n            .toLowerCase()} size (\\`${size}\\`) exceeds padding size (\\`${targetSize}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.SizeExceedsPaddingSizeError'\n        });\n    }\n}\n//# sourceMappingURL=Hex.js.map"],"names":["encoder","TextEncoder","hexes","Array","from","length","_v","i","toString","padStart","assert","value","options","strict","InvalidHexTypeError","test","InvalidHexValueError","startsWith","concat","values","reduce","acc","x","replace","Uint8Array","fromBytes","isArray","fromBoolean","hex","Number","size","internal.assertSize","padLeft","string","padRight","fromNumber","signed","value_","BigInt","maxValue","MAX_SAFE_INTEGER","minValue","suffix","IntegerOutOfRangeError","max","undefined","min","fromString","encode","internal.pad","dir","slice","start","end","internal.assertStartOffset","internal.assertEndOffset","Math","ceil","toBigInt","max_unsigned","toNumber","validate","Errors.BaseError","constructor","super","Object","defineProperty","this","enumerable","configurable","writable","Json.stringify","metaMessages","SizeOverflowError","givenSize","maxSize","SliceOffsetOutOfBoundsError","offset","position","SizeExceedsPaddingSizeError","targetSize","type","charAt","toUpperCase","toLowerCase"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Json.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Json.js"],"sourcesContent":["const bigIntSuffix = '#__bigint';\n/**\n * Parses a JSON string, with support for `bigint`.\n *\n * @example\n * ```ts twoslash\n * import { Json } from 'ox'\n *\n * const json = Json.parse('{\"foo\":\"bar\",\"baz\":\"69420694206942069420694206942069420694206942069420#__bigint\"}')\n * // @log: {\n * // @log:   foo: 'bar',\n * // @log:   baz: 69420694206942069420694206942069420694206942069420n\n * // @log: }\n * ```\n *\n * @param string - The value to parse.\n * @param reviver - A function that transforms the results.\n * @returns The parsed value.\n */\nexport function parse(string, reviver) {\n    return JSON.parse(string, (key, value_) => {\n        const value = value_;\n        if (typeof value === 'string' && value.endsWith(bigIntSuffix))\n            return BigInt(value.slice(0, -bigIntSuffix.length));\n        return typeof reviver === 'function' ? reviver(key, value) : value;\n    });\n}\n/**\n * Stringifies a value to its JSON representation, with support for `bigint`.\n *\n * @example\n * ```ts twoslash\n * import { Json } from 'ox'\n *\n * const json = Json.stringify({\n *   foo: 'bar',\n *   baz: 69420694206942069420694206942069420694206942069420n,\n * })\n * // @log: '{\"foo\":\"bar\",\"baz\":\"69420694206942069420694206942069420694206942069420#__bigint\"}'\n * ```\n *\n * @param value - The value to stringify.\n * @param replacer - A function that transforms the results. It is passed the key and value of the property, and must return the value to be used in the JSON string. If this function returns `undefined`, the property is not included in the resulting JSON string.\n * @param space - A string or number that determines the indentation of the JSON string. If it is a number, it indicates the number of spaces to use as indentation; if it is a string (e.g. `'\\t'`), it uses the string as the indentation character.\n * @returns The JSON string.\n */\nexport function stringify(value, replacer, space) {\n    return JSON.stringify(value, (key, value) => {\n        if (typeof replacer === 'function')\n            return replacer(key, value);\n        if (typeof value === 'bigint')\n            return value.toString() + bigIntSuffix;\n        return value;\n    }, space);\n}\n//# sourceMappingURL=Json.js.map"],"names":["stringify","value","replacer","space","JSON","key","toString"],"mappings":"AA8CO,SAASA,EAAUC,EAAOC,EAAUC,GACvC,OAAOC,KAAKJ,UAAUC,EAAO,CAACI,EAAKJ,IAGV,iBAAVA,EACAA,EAAMK,WAnDJ,YAoDNL,EACRE,EACP","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Signature.js"],"sourcesContent":["import { secp256k1 } from '@noble/curves/secp256k1';\nimport * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as Json from './Json.js';\nimport * as Solidity from './Solidity.js';\n/**\n * Asserts that a Signature is valid.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * Signature.assert({\n *   r: -49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1,\n * })\n * // @error: InvalidSignatureRError:\n * // @error: Value `-549...n` is an invalid r value.\n * // @error: r must be a positive integer less than 2^256.\n * ```\n *\n * @param signature - The signature object to assert.\n */\nexport function assert(signature, options = {}) {\n    const { recovered } = options;\n    if (typeof signature.r === 'undefined')\n        throw new MissingPropertiesError({ signature });\n    if (typeof signature.s === 'undefined')\n        throw new MissingPropertiesError({ signature });\n    if (recovered && typeof signature.yParity === 'undefined')\n        throw new MissingPropertiesError({ signature });\n    if (signature.r < 0n || signature.r > Solidity.maxUint256)\n        throw new InvalidRError({ value: signature.r });\n    if (signature.s < 0n || signature.s > Solidity.maxUint256)\n        throw new InvalidSError({ value: signature.s });\n    if (typeof signature.yParity === 'number' &&\n        signature.yParity !== 0 &&\n        signature.yParity !== 1)\n        throw new InvalidYParityError({ value: signature.yParity });\n}\n/**\n * Deserializes a {@link ox#Bytes.Bytes} signature into a structured {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Signature } from 'ox'\n *\n * Signature.fromBytes(new Uint8Array([128, 3, 131, ...]))\n * // @log: { r: 5231...n, s: 3522...n, yParity: 0 }\n * ```\n *\n * @param signature - The serialized signature.\n * @returns The deserialized {@link ox#Signature.Signature}.\n */\nexport function fromBytes(signature) {\n    return fromHex(Hex.fromBytes(signature));\n}\n/**\n * Deserializes a {@link ox#Hex.Hex} signature into a structured {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * Signature.fromHex('0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c')\n * // @log: { r: 5231...n, s: 3522...n, yParity: 0 }\n * ```\n *\n * @param serialized - The serialized signature.\n * @returns The deserialized {@link ox#Signature.Signature}.\n */\nexport function fromHex(signature) {\n    if (signature.length !== 130 && signature.length !== 132)\n        throw new InvalidSerializedSizeError({ signature });\n    const r = BigInt(Hex.slice(signature, 0, 32));\n    const s = BigInt(Hex.slice(signature, 32, 64));\n    const yParity = (() => {\n        const yParity = Number(`0x${signature.slice(130)}`);\n        if (Number.isNaN(yParity))\n            return undefined;\n        try {\n            return vToYParity(yParity);\n        }\n        catch {\n            throw new InvalidYParityError({ value: yParity });\n        }\n    })();\n    if (typeof yParity === 'undefined')\n        return {\n            r,\n            s,\n        };\n    return {\n        r,\n        s,\n        yParity,\n    };\n}\n/**\n * Extracts a {@link ox#Signature.Signature} from an arbitrary object that may include signature properties.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Signature } from 'ox'\n *\n * Signature.extract({\n *   baz: 'barry',\n *   foo: 'bar',\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1,\n *   zebra: 'stripes',\n * })\n * // @log: {\n * // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * // @log:   yParity: 1\n * // @log: }\n * ```\n *\n * @param value - The arbitrary object to extract the signature from.\n * @returns The extracted {@link ox#Signature.Signature}.\n */\nexport function extract(value) {\n    if (typeof value.r === 'undefined')\n        return undefined;\n    if (typeof value.s === 'undefined')\n        return undefined;\n    return from(value);\n}\n/**\n * Instantiates a typed {@link ox#Signature.Signature} object from a {@link ox#Signature.Signature}, {@link ox#Signature.Legacy}, {@link ox#Bytes.Bytes}, or {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * Signature.from({\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1,\n * })\n * // @log: {\n * // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * // @log:   yParity: 1\n * // @log: }\n * ```\n *\n * @example\n * ### From Serialized\n *\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * Signature.from('0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db801')\n * // @log: {\n * // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * // @log:   yParity: 1,\n * // @log: }\n * ```\n *\n * @example\n * ### From Legacy\n *\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * Signature.from({\n *   r: 47323457007453657207889730243826965761922296599680473886588287015755652701072n,\n *   s: 57228803202727131502949358313456071280488184270258293674242124340113824882788n,\n *   v: 27,\n * })\n * // @log: {\n * // @log:   r: 47323457007453657207889730243826965761922296599680473886588287015755652701072n,\n * // @log:   s: 57228803202727131502949358313456071280488184270258293674242124340113824882788n,\n * // @log:   yParity: 0\n * // @log: }\n * ```\n *\n * @param signature - The signature value to instantiate.\n * @returns The instantiated {@link ox#Signature.Signature}.\n */\nexport function from(signature) {\n    const signature_ = (() => {\n        if (typeof signature === 'string')\n            return fromHex(signature);\n        if (signature instanceof Uint8Array)\n            return fromBytes(signature);\n        if (typeof signature.r === 'string')\n            return fromRpc(signature);\n        if (signature.v)\n            return fromLegacy(signature);\n        return {\n            r: signature.r,\n            s: signature.s,\n            ...(typeof signature.yParity !== 'undefined'\n                ? { yParity: signature.yParity }\n                : {}),\n        };\n    })();\n    assert(signature_);\n    return signature_;\n}\n/**\n * Converts a DER-encoded signature to a {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Signature } from 'ox'\n *\n * const signature = Signature.fromDerBytes(new Uint8Array([132, 51, 23, ...]))\n * // @log: {\n * // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * // @log: }\n * ```\n *\n * @param signature - The DER-encoded signature to convert.\n * @returns The {@link ox#Signature.Signature}.\n */\nexport function fromDerBytes(signature) {\n    return fromDerHex(Hex.fromBytes(signature));\n}\n/**\n * Converts a DER-encoded signature to a {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.fromDerHex('0x304402206e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf02204a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8')\n * // @log: {\n * // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * // @log: }\n * ```\n *\n * @param signature - The DER-encoded signature to convert.\n * @returns The {@link ox#Signature.Signature}.\n */\nexport function fromDerHex(signature) {\n    const { r, s } = secp256k1.Signature.fromDER(Hex.from(signature).slice(2));\n    return { r, s };\n}\n/**\n * Converts a {@link ox#Signature.Legacy} into a {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const legacy = Signature.fromLegacy({ r: 1n, s: 2n, v: 28 })\n * // @log: { r: 1n, s: 2n, yParity: 1 }\n * ```\n *\n * @param signature - The {@link ox#Signature.Legacy} to convert.\n * @returns The converted {@link ox#Signature.Signature}.\n */\nexport function fromLegacy(signature) {\n    return {\n        r: signature.r,\n        s: signature.s,\n        yParity: vToYParity(signature.v),\n    };\n}\n/**\n * Converts a {@link ox#Signature.Rpc} into a {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.fromRpc({\n *   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',\n *   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',\n *   yParity: '0x0',\n * })\n * ```\n *\n * @param signature - The {@link ox#Signature.Rpc} to convert.\n * @returns The converted {@link ox#Signature.Signature}.\n */\nexport function fromRpc(signature) {\n    const yParity = (() => {\n        const v = signature.v ? Number(signature.v) : undefined;\n        let yParity = signature.yParity ? Number(signature.yParity) : undefined;\n        if (typeof v === 'number' && typeof yParity !== 'number')\n            yParity = vToYParity(v);\n        if (typeof yParity !== 'number')\n            throw new InvalidYParityError({ value: signature.yParity });\n        return yParity;\n    })();\n    return {\n        r: BigInt(signature.r),\n        s: BigInt(signature.s),\n        yParity,\n    };\n}\n/**\n * Converts a {@link ox#Signature.Tuple} to a {@link ox#Signature.Signature}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.fromTuple(['0x01', '0x7b', '0x1c8'])\n * // @log: {\n * // @log:   r: 123n,\n * // @log:   s: 456n,\n * // @log:   yParity: 1,\n * // @log: }\n * ```\n *\n * @param tuple - The {@link ox#Signature.Tuple} to convert.\n * @returns The {@link ox#Signature.Signature}.\n */\nexport function fromTuple(tuple) {\n    const [yParity, r, s] = tuple;\n    return from({\n        r: r === '0x' ? 0n : BigInt(r),\n        s: s === '0x' ? 0n : BigInt(s),\n        yParity: yParity === '0x' ? 0 : Number(yParity),\n    });\n}\n/**\n * Serializes a {@link ox#Signature.Signature} to {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.toBytes({\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1\n * })\n * // @log: Uint8Array [102, 16, 10, ...]\n * ```\n *\n * @param signature - The signature to serialize.\n * @returns The serialized signature.\n */\nexport function toBytes(signature) {\n    return Bytes.fromHex(toHex(signature));\n}\n/**\n * Serializes a {@link ox#Signature.Signature} to {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.toHex({\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1\n * })\n * // @log: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c'\n * ```\n *\n * @param signature - The signature to serialize.\n * @returns The serialized signature.\n */\nexport function toHex(signature) {\n    assert(signature);\n    const r = signature.r;\n    const s = signature.s;\n    const signature_ = Hex.concat(Hex.fromNumber(r, { size: 32 }), Hex.fromNumber(s, { size: 32 }), \n    // If the signature is recovered, add the recovery byte to the signature.\n    typeof signature.yParity === 'number'\n        ? Hex.fromNumber(yParityToV(signature.yParity), { size: 1 })\n        : '0x');\n    return signature_;\n}\n/**\n * Converts a {@link ox#Signature.Signature} to DER-encoded format.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.from({\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * })\n *\n * const signature_der = Signature.toDerBytes(signature)\n * // @log: Uint8Array [132, 51, 23, ...]\n * ```\n *\n * @param signature - The signature to convert.\n * @returns The DER-encoded signature.\n */\nexport function toDerBytes(signature) {\n    const sig = new secp256k1.Signature(signature.r, signature.s);\n    return sig.toDERRawBytes();\n}\n/**\n * Converts a {@link ox#Signature.Signature} to DER-encoded format.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.from({\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n * })\n *\n * const signature_der = Signature.toDerHex(signature)\n * // @log: '0x304402206e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf02204a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8'\n * ```\n *\n * @param signature - The signature to convert.\n * @returns The DER-encoded signature.\n */\nexport function toDerHex(signature) {\n    const sig = new secp256k1.Signature(signature.r, signature.s);\n    return `0x${sig.toDERHex()}`;\n}\n/**\n * Converts a {@link ox#Signature.Signature} into a {@link ox#Signature.Legacy}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const legacy = Signature.toLegacy({ r: 1n, s: 2n, yParity: 1 })\n * // @log: { r: 1n, s: 2n, v: 28 }\n * ```\n *\n * @param signature - The {@link ox#Signature.Signature} to convert.\n * @returns The converted {@link ox#Signature.Legacy}.\n */\nexport function toLegacy(signature) {\n    return {\n        r: signature.r,\n        s: signature.s,\n        v: yParityToV(signature.yParity),\n    };\n}\n/**\n * Converts a {@link ox#Signature.Signature} into a {@link ox#Signature.Rpc}.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signature = Signature.toRpc({\n *   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1\n * })\n * ```\n *\n * @param signature - The {@link ox#Signature.Signature} to convert.\n * @returns The converted {@link ox#Signature.Rpc}.\n */\nexport function toRpc(signature) {\n    const { r, s, yParity } = signature;\n    return {\n        r: Hex.fromNumber(r, { size: 32 }),\n        s: Hex.fromNumber(s, { size: 32 }),\n        yParity: yParity === 0 ? '0x0' : '0x1',\n    };\n}\n/**\n * Converts a {@link ox#Signature.Signature} to a serialized {@link ox#Signature.Tuple} to be used for signatures in Transaction Envelopes, EIP-7702 Authorization Lists, etc.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const signatureTuple = Signature.toTuple({\n *   r: 123n,\n *   s: 456n,\n *   yParity: 1,\n * })\n * // @log: [yParity: '0x01', r: '0x7b', s: '0x1c8']\n * ```\n *\n * @param signature - The {@link ox#Signature.Signature} to convert.\n * @returns The {@link ox#Signature.Tuple}.\n */\nexport function toTuple(signature) {\n    const { r, s, yParity } = signature;\n    return [\n        yParity ? '0x01' : '0x',\n        r === 0n ? '0x' : Hex.trimLeft(Hex.fromNumber(r)),\n        s === 0n ? '0x' : Hex.trimLeft(Hex.fromNumber(s)),\n    ];\n}\n/**\n * Validates a Signature. Returns `true` if the signature is valid, `false` otherwise.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const valid = Signature.validate({\n *   r: -49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n *   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,\n *   yParity: 1,\n * })\n * // @log: false\n * ```\n *\n * @param signature - The signature object to assert.\n */\nexport function validate(signature, options = {}) {\n    try {\n        assert(signature, options);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Converts a ECDSA `v` value to a `yParity` value.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const yParity = Signature.vToYParity(28)\n * // @log: 1\n * ```\n *\n * @param v - The ECDSA `v` value to convert.\n * @returns The `yParity` value.\n */\nexport function vToYParity(v) {\n    if (v === 0 || v === 27)\n        return 0;\n    if (v === 1 || v === 28)\n        return 1;\n    if (v >= 35)\n        return v % 2 === 0 ? 1 : 0;\n    throw new InvalidVError({ value: v });\n}\n/**\n * Converts a ECDSA `v` value to a `yParity` value.\n *\n * @example\n * ```ts twoslash\n * import { Signature } from 'ox'\n *\n * const v = Signature.yParityToV(1)\n * // @log: 28\n * ```\n *\n * @param yParity - The ECDSA `yParity` value to convert.\n * @returns The `v` value.\n */\nexport function yParityToV(yParity) {\n    if (yParity === 0)\n        return 27;\n    if (yParity === 1)\n        return 28;\n    throw new InvalidYParityError({ value: yParity });\n}\n/** Thrown when the serialized signature is of an invalid size. */\nexport class InvalidSerializedSizeError extends Errors.BaseError {\n    constructor({ signature }) {\n        super(`Value \\`${signature}\\` is an invalid signature size.`, {\n            metaMessages: [\n                'Expected: 64 bytes or 65 bytes.',\n                `Received ${Hex.size(Hex.from(signature))} bytes.`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Signature.InvalidSerializedSizeError'\n        });\n    }\n}\n/** Thrown when the signature is missing either an `r`, `s`, or `yParity` property. */\nexport class MissingPropertiesError extends Errors.BaseError {\n    constructor({ signature }) {\n        super(`Signature \\`${Json.stringify(signature)}\\` is missing either an \\`r\\`, \\`s\\`, or \\`yParity\\` property.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Signature.MissingPropertiesError'\n        });\n    }\n}\n/** Thrown when the signature has an invalid `r` value. */\nexport class InvalidRError extends Errors.BaseError {\n    constructor({ value }) {\n        super(`Value \\`${value}\\` is an invalid r value. r must be a positive integer less than 2^256.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Signature.InvalidRError'\n        });\n    }\n}\n/** Thrown when the signature has an invalid `s` value. */\nexport class InvalidSError extends Errors.BaseError {\n    constructor({ value }) {\n        super(`Value \\`${value}\\` is an invalid s value. s must be a positive integer less than 2^256.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Signature.InvalidSError'\n        });\n    }\n}\n/** Thrown when the signature has an invalid `yParity` value. */\nexport class InvalidYParityError extends Errors.BaseError {\n    constructor({ value }) {\n        super(`Value \\`${value}\\` is an invalid y-parity value. Y-parity must be 0 or 1.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Signature.InvalidYParityError'\n        });\n    }\n}\n/** Thrown when the signature has an invalid `v` value. */\nexport class InvalidVError extends Errors.BaseError {\n    constructor({ value }) {\n        super(`Value \\`${value}\\` is an invalid v value. v must be 27, 28 or >=35.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Signature.InvalidVError'\n        });\n    }\n}\n//# sourceMappingURL=Signature.js.map"],"names":["assert","signature","options","recovered","r","MissingPropertiesError","s","yParity","Solidity.maxUint256","InvalidRError","value","InvalidSError","InvalidYParityError","fromBytes","fromHex","Hex.fromBytes","length","InvalidSerializedSizeError","BigInt","Hex.slice","Number","slice","isNaN","vToYParity","extract","from","signature_","Uint8Array","fromRpc","v","fromLegacy","undefined","InvalidVError","Errors.BaseError","constructor","super","metaMessages","Hex.size","Hex.from","Object","defineProperty","this","enumerable","configurable","writable","Json.stringify"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Solidity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Solidity.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Solidity.js"],"sourcesContent":["export const arrayRegex = /^(.*)\\[([0-9]*)\\]$/;\n// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`\n// https://regexr.com/6va55\nexport const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;\n// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`\n// https://regexr.com/6v8hp\nexport const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;\nexport const maxInt8 = 2n ** (8n - 1n) - 1n;\nexport const maxInt16 = 2n ** (16n - 1n) - 1n;\nexport const maxInt24 = 2n ** (24n - 1n) - 1n;\nexport const maxInt32 = 2n ** (32n - 1n) - 1n;\nexport const maxInt40 = 2n ** (40n - 1n) - 1n;\nexport const maxInt48 = 2n ** (48n - 1n) - 1n;\nexport const maxInt56 = 2n ** (56n - 1n) - 1n;\nexport const maxInt64 = 2n ** (64n - 1n) - 1n;\nexport const maxInt72 = 2n ** (72n - 1n) - 1n;\nexport const maxInt80 = 2n ** (80n - 1n) - 1n;\nexport const maxInt88 = 2n ** (88n - 1n) - 1n;\nexport const maxInt96 = 2n ** (96n - 1n) - 1n;\nexport const maxInt104 = 2n ** (104n - 1n) - 1n;\nexport const maxInt112 = 2n ** (112n - 1n) - 1n;\nexport const maxInt120 = 2n ** (120n - 1n) - 1n;\nexport const maxInt128 = 2n ** (128n - 1n) - 1n;\nexport const maxInt136 = 2n ** (136n - 1n) - 1n;\nexport const maxInt144 = 2n ** (144n - 1n) - 1n;\nexport const maxInt152 = 2n ** (152n - 1n) - 1n;\nexport const maxInt160 = 2n ** (160n - 1n) - 1n;\nexport const maxInt168 = 2n ** (168n - 1n) - 1n;\nexport const maxInt176 = 2n ** (176n - 1n) - 1n;\nexport const maxInt184 = 2n ** (184n - 1n) - 1n;\nexport const maxInt192 = 2n ** (192n - 1n) - 1n;\nexport const maxInt200 = 2n ** (200n - 1n) - 1n;\nexport const maxInt208 = 2n ** (208n - 1n) - 1n;\nexport const maxInt216 = 2n ** (216n - 1n) - 1n;\nexport const maxInt224 = 2n ** (224n - 1n) - 1n;\nexport const maxInt232 = 2n ** (232n - 1n) - 1n;\nexport const maxInt240 = 2n ** (240n - 1n) - 1n;\nexport const maxInt248 = 2n ** (248n - 1n) - 1n;\nexport const maxInt256 = 2n ** (256n - 1n) - 1n;\nexport const minInt8 = -(2n ** (8n - 1n));\nexport const minInt16 = -(2n ** (16n - 1n));\nexport const minInt24 = -(2n ** (24n - 1n));\nexport const minInt32 = -(2n ** (32n - 1n));\nexport const minInt40 = -(2n ** (40n - 1n));\nexport const minInt48 = -(2n ** (48n - 1n));\nexport const minInt56 = -(2n ** (56n - 1n));\nexport const minInt64 = -(2n ** (64n - 1n));\nexport const minInt72 = -(2n ** (72n - 1n));\nexport const minInt80 = -(2n ** (80n - 1n));\nexport const minInt88 = -(2n ** (88n - 1n));\nexport const minInt96 = -(2n ** (96n - 1n));\nexport const minInt104 = -(2n ** (104n - 1n));\nexport const minInt112 = -(2n ** (112n - 1n));\nexport const minInt120 = -(2n ** (120n - 1n));\nexport const minInt128 = -(2n ** (128n - 1n));\nexport const minInt136 = -(2n ** (136n - 1n));\nexport const minInt144 = -(2n ** (144n - 1n));\nexport const minInt152 = -(2n ** (152n - 1n));\nexport const minInt160 = -(2n ** (160n - 1n));\nexport const minInt168 = -(2n ** (168n - 1n));\nexport const minInt176 = -(2n ** (176n - 1n));\nexport const minInt184 = -(2n ** (184n - 1n));\nexport const minInt192 = -(2n ** (192n - 1n));\nexport const minInt200 = -(2n ** (200n - 1n));\nexport const minInt208 = -(2n ** (208n - 1n));\nexport const minInt216 = -(2n ** (216n - 1n));\nexport const minInt224 = -(2n ** (224n - 1n));\nexport const minInt232 = -(2n ** (232n - 1n));\nexport const minInt240 = -(2n ** (240n - 1n));\nexport const minInt248 = -(2n ** (248n - 1n));\nexport const minInt256 = -(2n ** (256n - 1n));\nexport const maxUint8 = 2n ** 8n - 1n;\nexport const maxUint16 = 2n ** 16n - 1n;\nexport const maxUint24 = 2n ** 24n - 1n;\nexport const maxUint32 = 2n ** 32n - 1n;\nexport const maxUint40 = 2n ** 40n - 1n;\nexport const maxUint48 = 2n ** 48n - 1n;\nexport const maxUint56 = 2n ** 56n - 1n;\nexport const maxUint64 = 2n ** 64n - 1n;\nexport const maxUint72 = 2n ** 72n - 1n;\nexport const maxUint80 = 2n ** 80n - 1n;\nexport const maxUint88 = 2n ** 88n - 1n;\nexport const maxUint96 = 2n ** 96n - 1n;\nexport const maxUint104 = 2n ** 104n - 1n;\nexport const maxUint112 = 2n ** 112n - 1n;\nexport const maxUint120 = 2n ** 120n - 1n;\nexport const maxUint128 = 2n ** 128n - 1n;\nexport const maxUint136 = 2n ** 136n - 1n;\nexport const maxUint144 = 2n ** 144n - 1n;\nexport const maxUint152 = 2n ** 152n - 1n;\nexport const maxUint160 = 2n ** 160n - 1n;\nexport const maxUint168 = 2n ** 168n - 1n;\nexport const maxUint176 = 2n ** 176n - 1n;\nexport const maxUint184 = 2n ** 184n - 1n;\nexport const maxUint192 = 2n ** 192n - 1n;\nexport const maxUint200 = 2n ** 200n - 1n;\nexport const maxUint208 = 2n ** 208n - 1n;\nexport const maxUint216 = 2n ** 216n - 1n;\nexport const maxUint224 = 2n ** 224n - 1n;\nexport const maxUint232 = 2n ** 232n - 1n;\nexport const maxUint240 = 2n ** 240n - 1n;\nexport const maxUint248 = 2n ** 248n - 1n;\nexport const maxUint256 = 2n ** 256n - 1n;\n//# sourceMappingURL=Solidity.js.map"],"names":["arrayRegex","bytesRegex","integerRegex","maxUint256"],"mappings":"AAAY,MAACA,EAAa,qBAGbC,EAAa,uCAGbC,EAAe,iIAgGfC,EAAa,IAAM,KAAO","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Withdrawal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Withdrawal.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/Withdrawal.js"],"sourcesContent":["import * as Hex from './Hex.js';\n/**\n * Converts a {@link ox#Withdrawal.Rpc} to an {@link ox#Withdrawal.Withdrawal}.\n *\n * @example\n * ```ts twoslash\n * import { Withdrawal } from 'ox'\n *\n * const withdrawal = Withdrawal.fromRpc({\n *   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n *   amount: '0x620323',\n *   index: '0x0',\n *   validatorIndex: '0x1',\n * })\n * // @log: {\n * // @log:   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n * // @log:   amount: 6423331n,\n * // @log:   index: 0,\n * // @log:   validatorIndex: 1\n * // @log: }\n * ```\n *\n * @param withdrawal - The RPC withdrawal to convert.\n * @returns An instantiated {@link ox#Withdrawal.Withdrawal}.\n */\nexport function fromRpc(withdrawal) {\n    return {\n        ...withdrawal,\n        amount: BigInt(withdrawal.amount),\n        index: Number(withdrawal.index),\n        validatorIndex: Number(withdrawal.validatorIndex),\n    };\n}\n/**\n * Converts a {@link ox#Withdrawal.Withdrawal} to an {@link ox#Withdrawal.Rpc}.\n *\n * @example\n * ```ts twoslash\n * import { Withdrawal } from 'ox'\n *\n * const withdrawal = Withdrawal.toRpc({\n *   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n *   amount: 6423331n,\n *   index: 0,\n *   validatorIndex: 1,\n * })\n * // @log: {\n * // @log:   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n * // @log:   amount: '0x620323',\n * // @log:   index: '0x0',\n * // @log:   validatorIndex: '0x1',\n * // @log: }\n * ```\n *\n * @param withdrawal - The Withdrawal to convert.\n * @returns An RPC Withdrawal.\n */\nexport function toRpc(withdrawal) {\n    return {\n        address: withdrawal.address,\n        amount: Hex.fromNumber(withdrawal.amount),\n        index: Hex.fromNumber(withdrawal.index),\n        validatorIndex: Hex.fromNumber(withdrawal.validatorIndex),\n    };\n}\n//# sourceMappingURL=Withdrawal.js.map"],"names":["toRpc","withdrawal","address","amount","Hex.fromNumber","index","validatorIndex"],"mappings":"sCAyDO,SAASA,EAAMC,GAClB,MAAO,CACHC,QAASD,EAAWC,QACpBC,OAAQC,EAAeH,EAAWE,QAClCE,MAAOD,EAAeH,EAAWI,OACjCC,eAAgBF,EAAeH,EAAWK,gBAElD","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/abiItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abiItem.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/abiItem.js"],"sourcesContent":["import * as Address from '../Address.js';\nimport * as Errors from '../Errors.js';\n/** @internal */\nexport function normalizeSignature(signature) {\n    let active = true;\n    let current = '';\n    let level = 0;\n    let result = '';\n    let valid = false;\n    for (let i = 0; i < signature.length; i++) {\n        const char = signature[i];\n        // If the character is a separator, we want to reactivate.\n        if (['(', ')', ','].includes(char))\n            active = true;\n        // If the character is a \"level\" token, we want to increment/decrement.\n        if (char === '(')\n            level++;\n        if (char === ')')\n            level--;\n        // If we aren't active, we don't want to mutate the result.\n        if (!active)\n            continue;\n        // If level === 0, we are at the definition level.\n        if (level === 0) {\n            if (char === ' ' && ['event', 'function', 'error', ''].includes(result))\n                result = '';\n            else {\n                result += char;\n                // If we are at the end of the definition, we must be finished.\n                if (char === ')') {\n                    valid = true;\n                    break;\n                }\n            }\n            continue;\n        }\n        // Ignore spaces\n        if (char === ' ') {\n            // If the previous character is a separator, and the current section isn't empty, we want to deactivate.\n            if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {\n                current = '';\n                active = false;\n            }\n            continue;\n        }\n        result += char;\n        current += char;\n    }\n    if (!valid)\n        throw new Errors.BaseError('Unable to normalize signature.');\n    return result;\n}\n/** @internal */\nexport function isArgOfType(arg, abiParameter) {\n    const argType = typeof arg;\n    const abiParameterType = abiParameter.type;\n    switch (abiParameterType) {\n        case 'address':\n            return Address.validate(arg, { strict: false });\n        case 'bool':\n            return argType === 'boolean';\n        case 'function':\n            return argType === 'string';\n        case 'string':\n            return argType === 'string';\n        default: {\n            if (abiParameterType === 'tuple' && 'components' in abiParameter)\n                return Object.values(abiParameter.components).every((component, index) => {\n                    return isArgOfType(Object.values(arg)[index], component);\n                });\n            // `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`\n            // https://regexr.com/6v8hp\n            if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))\n                return argType === 'number' || argType === 'bigint';\n            // `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`\n            // https://regexr.com/6va55\n            if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))\n                return argType === 'string' || arg instanceof Uint8Array;\n            // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays\n            // https://regexr.com/6va6i\n            if (/[a-z]+[1-9]{0,3}(\\[[0-9]{0,}\\])+$/.test(abiParameterType)) {\n                return (Array.isArray(arg) &&\n                    arg.every((x) => isArgOfType(x, {\n                        ...abiParameter,\n                        // Pop off `[]` or `[M]` from end of type\n                        type: abiParameterType.replace(/(\\[[0-9]{0,}\\])$/, ''),\n                    })));\n            }\n            return false;\n        }\n    }\n}\n/** @internal */\nexport function getAmbiguousTypes(sourceParameters, targetParameters, args) {\n    for (const parameterIndex in sourceParameters) {\n        const sourceParameter = sourceParameters[parameterIndex];\n        const targetParameter = targetParameters[parameterIndex];\n        if (sourceParameter.type === 'tuple' &&\n            targetParameter.type === 'tuple' &&\n            'components' in sourceParameter &&\n            'components' in targetParameter)\n            return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);\n        const types = [sourceParameter.type, targetParameter.type];\n        const ambiguous = (() => {\n            if (types.includes('address') && types.includes('bytes20'))\n                return true;\n            if (types.includes('address') && types.includes('string'))\n                return Address.validate(args[parameterIndex], {\n                    strict: false,\n                });\n            if (types.includes('address') && types.includes('bytes'))\n                return Address.validate(args[parameterIndex], {\n                    strict: false,\n                });\n            return false;\n        })();\n        if (ambiguous)\n            return types;\n    }\n    return;\n}\n//# sourceMappingURL=abiItem.js.map"],"names":["normalizeSignature","signature","active","current","level","result","valid","i","length","char","includes","Errors.BaseError","isArgOfType","arg","abiParameter","argType","abiParameterType","type","Address.validate","strict","Object","values","components","every","component","index","test","Uint8Array","Array","isArray","x","replace","getAmbiguousTypes","sourceParameters","targetParameters","args","parameterIndex","sourceParameter","targetParameter","types"],"mappings":"kFAGO,SAASA,EAAmBC,GAC/B,IAAIC,GAAS,EACTC,EAAU,GACVC,EAAQ,EACRC,EAAS,GACTC,GAAQ,EACZ,IAAK,IAAIC,EAAI,EAAGA,EAAIN,EAAUO,OAAQD,IAAK,CACvC,MAAME,EAAOR,EAAUM,GAUvB,GARI,CAAC,IAAK,IAAK,KAAKG,SAASD,KACzBP,GAAS,GAEA,MAATO,GACAL,IACS,MAATK,GACAL,IAECF,EAGL,GAAc,IAAVE,EAcS,MAATK,GAQJJ,GAAUI,EACVN,GAAWM,GAPkB,MAArBR,EAAUM,EAAI,IAA0B,MAAZJ,GAA+B,OAAZA,IAC/CA,EAAU,GACVD,GAAS,QAjBb,GAAa,MAATO,GAAgB,CAAC,QAAS,WAAY,QAAS,IAAIC,SAASL,GAC5DA,EAAS,QAIT,GAFAA,GAAUI,EAEG,MAATA,EAAc,CACdH,GAAQ,EACR,KACJ,CAeZ,CACA,IAAKA,EACD,MAAM,IAAIK,EAAiB,kCAC/B,OAAON,CACX,CAEO,SAASO,EAAYC,EAAKC,GAC7B,MAAMC,SAAiBF,EACjBG,EAAmBF,EAAaG,KACtC,OAAQD,GACJ,IAAK,UACD,OAAOE,EAAiBL,EAAK,CAAEM,QAAQ,IAC3C,IAAK,OACD,MAAmB,YAAZJ,EACX,IAAK,WAEL,IAAK,SACD,MAAmB,WAAZA,EACX,QACI,MAAyB,UAArBC,GAAgC,eAAgBF,EACzCM,OAAOC,OAAOP,EAAaQ,YAAYC,MAAM,CAACC,EAAWC,IACrDb,EAAYQ,OAAOC,OAAOR,GAAKY,GAAQD,IAIlD,+HAA+HE,KAAKV,GACjH,WAAZD,GAAoC,WAAZA,EAG/B,uCAAuCW,KAAKV,GACzB,WAAZD,GAAwBF,aAAec,aAG9C,oCAAoCD,KAAKV,KACjCY,MAAMC,QAAQhB,IAClBA,EAAIU,MAAOO,GAAMlB,EAAYkB,EAAG,IACzBhB,EAEHG,KAAMD,EAAiBe,QAAQ,mBAAoB,QAM3E,CAEO,SAASC,EAAkBC,EAAkBC,EAAkBC,GAClE,IAAK,MAAMC,KAAkBH,EAAkB,CAC3C,MAAMI,EAAkBJ,EAAiBG,GACnCE,EAAkBJ,EAAiBE,GACzC,GAA6B,UAAzBC,EAAgBpB,MACS,UAAzBqB,EAAgBrB,MAChB,eAAgBoB,GAChB,eAAgBC,EAChB,OAAON,EAAkBK,EAAgBf,WAAYgB,EAAgBhB,WAAYa,EAAKC,IAC1F,MAAMG,EAAQ,CAACF,EAAgBpB,KAAMqB,EAAgBrB,MAcrD,GAbkB,QACVsB,EAAM7B,SAAS,aAAc6B,EAAM7B,SAAS,cAE5C6B,EAAM7B,SAAS,YAAc6B,EAAM7B,SAAS,cAI5C6B,EAAM7B,SAAS,aAAc6B,EAAM7B,SAAS,YAHrCQ,EAAiBiB,EAAKC,GAAiB,CAC1CjB,QAAQ,IALF,GAcd,OAAOoB,CACf,CAEJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/abiParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abiParameters.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/abiParameters.js"],"sourcesContent":["import * as AbiParameters from '../AbiParameters.js';\nimport * as Address from '../Address.js';\nimport * as Bytes from '../Bytes.js';\nimport * as Errors from '../Errors.js';\nimport * as Hex from '../Hex.js';\nimport { integerRegex } from '../Solidity.js';\n/** @internal */\nexport function decodeParameter(cursor, param, options) {\n    const { checksumAddress, staticPosition } = options;\n    const arrayComponents = getArrayComponents(param.type);\n    if (arrayComponents) {\n        const [length, type] = arrayComponents;\n        return decodeArray(cursor, { ...param, type }, { checksumAddress, length, staticPosition });\n    }\n    if (param.type === 'tuple')\n        return decodeTuple(cursor, param, {\n            checksumAddress,\n            staticPosition,\n        });\n    if (param.type === 'address')\n        return decodeAddress(cursor, { checksum: checksumAddress });\n    if (param.type === 'bool')\n        return decodeBool(cursor);\n    if (param.type.startsWith('bytes'))\n        return decodeBytes(cursor, param, { staticPosition });\n    if (param.type.startsWith('uint') || param.type.startsWith('int'))\n        return decodeNumber(cursor, param);\n    if (param.type === 'string')\n        return decodeString(cursor, { staticPosition });\n    throw new AbiParameters.InvalidTypeError(param.type);\n}\nconst sizeOfLength = 32;\nconst sizeOfOffset = 32;\n/** @internal */\nexport function decodeAddress(cursor, options = {}) {\n    const { checksum = false } = options;\n    const value = cursor.readBytes(32);\n    const wrap = (address) => checksum ? Address.checksum(address) : address;\n    return [wrap(Hex.fromBytes(Bytes.slice(value, -20))), 32];\n}\n/** @internal */\nexport function decodeArray(cursor, param, options) {\n    const { checksumAddress, length, staticPosition } = options;\n    // If the length of the array is not known in advance (dynamic array),\n    // this means we will need to wonder off to the pointer and decode.\n    if (!length) {\n        // Dealing with a dynamic type, so get the offset of the array data.\n        const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset));\n        // Start is the static position of current slot + offset.\n        const start = staticPosition + offset;\n        const startOfData = start + sizeOfLength;\n        // Get the length of the array from the offset.\n        cursor.setPosition(start);\n        const length = Bytes.toNumber(cursor.readBytes(sizeOfLength));\n        // Check if the array has any dynamic children.\n        const dynamicChild = hasDynamicChild(param);\n        let consumed = 0;\n        const value = [];\n        for (let i = 0; i < length; ++i) {\n            // If any of the children is dynamic, then all elements will be offset pointer, thus size of one slot (32 bytes).\n            // Otherwise, elements will be the size of their encoding (consumed bytes).\n            cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed));\n            const [data, consumed_] = decodeParameter(cursor, param, {\n                checksumAddress,\n                staticPosition: startOfData,\n            });\n            consumed += consumed_;\n            value.push(data);\n        }\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [value, 32];\n    }\n    // If the length of the array is known in advance,\n    // and the length of an element deeply nested in the array is not known,\n    // we need to decode the offset of the array data.\n    if (hasDynamicChild(param)) {\n        // Dealing with dynamic types, so get the offset of the array data.\n        const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset));\n        // Start is the static position of current slot + offset.\n        const start = staticPosition + offset;\n        const value = [];\n        for (let i = 0; i < length; ++i) {\n            // Move cursor along to the next slot (next offset pointer).\n            cursor.setPosition(start + i * 32);\n            const [data] = decodeParameter(cursor, param, {\n                checksumAddress,\n                staticPosition: start,\n            });\n            value.push(data);\n        }\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [value, 32];\n    }\n    // If the length of the array is known in advance and the array is deeply static,\n    // then we can just decode each element in sequence.\n    let consumed = 0;\n    const value = [];\n    for (let i = 0; i < length; ++i) {\n        const [data, consumed_] = decodeParameter(cursor, param, {\n            checksumAddress,\n            staticPosition: staticPosition + consumed,\n        });\n        consumed += consumed_;\n        value.push(data);\n    }\n    return [value, consumed];\n}\n/** @internal */\nexport function decodeBool(cursor) {\n    return [Bytes.toBoolean(cursor.readBytes(32), { size: 32 }), 32];\n}\n/** @internal */\nexport function decodeBytes(cursor, param, { staticPosition }) {\n    const [_, size] = param.type.split('bytes');\n    if (!size) {\n        // Dealing with dynamic types, so get the offset of the bytes data.\n        const offset = Bytes.toNumber(cursor.readBytes(32));\n        // Set position of the cursor to start of bytes data.\n        cursor.setPosition(staticPosition + offset);\n        const length = Bytes.toNumber(cursor.readBytes(32));\n        // If there is no length, we have zero data.\n        if (length === 0) {\n            // As we have gone wondering, restore to the original position + next slot.\n            cursor.setPosition(staticPosition + 32);\n            return ['0x', 32];\n        }\n        const data = cursor.readBytes(length);\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [Hex.fromBytes(data), 32];\n    }\n    const value = Hex.fromBytes(cursor.readBytes(Number.parseInt(size, 10), 32));\n    return [value, 32];\n}\n/** @internal */\nexport function decodeNumber(cursor, param) {\n    const signed = param.type.startsWith('int');\n    const size = Number.parseInt(param.type.split('int')[1] || '256', 10);\n    const value = cursor.readBytes(32);\n    return [\n        size > 48\n            ? Bytes.toBigInt(value, { signed })\n            : Bytes.toNumber(value, { signed }),\n        32,\n    ];\n}\n/** @internal */\nexport function decodeTuple(cursor, param, options) {\n    const { checksumAddress, staticPosition } = options;\n    // Tuples can have unnamed components (i.e. they are arrays), so we must\n    // determine whether the tuple is named or unnamed. In the case of a named\n    // tuple, the value will be an object where each property is the name of the\n    // component. In the case of an unnamed tuple, the value will be an array.\n    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);\n    // Initialize the value to an object or an array, depending on whether the\n    // tuple is named or unnamed.\n    const value = hasUnnamedChild ? [] : {};\n    let consumed = 0;\n    // If the tuple has a dynamic child, we must first decode the offset to the\n    // tuple data.\n    if (hasDynamicChild(param)) {\n        // Dealing with dynamic types, so get the offset of the tuple data.\n        const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset));\n        // Start is the static position of referencing slot + offset.\n        const start = staticPosition + offset;\n        for (let i = 0; i < param.components.length; ++i) {\n            const component = param.components[i];\n            cursor.setPosition(start + consumed);\n            const [data, consumed_] = decodeParameter(cursor, component, {\n                checksumAddress,\n                staticPosition: start,\n            });\n            consumed += consumed_;\n            value[hasUnnamedChild ? i : component?.name] = data;\n        }\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [value, 32];\n    }\n    // If the tuple has static children, we can just decode each component\n    // in sequence.\n    for (let i = 0; i < param.components.length; ++i) {\n        const component = param.components[i];\n        const [data, consumed_] = decodeParameter(cursor, component, {\n            checksumAddress,\n            staticPosition,\n        });\n        value[hasUnnamedChild ? i : component?.name] = data;\n        consumed += consumed_;\n    }\n    return [value, consumed];\n}\n/** @internal */\nexport function decodeString(cursor, { staticPosition }) {\n    // Get offset to start of string data.\n    const offset = Bytes.toNumber(cursor.readBytes(32));\n    // Start is the static position of current slot + offset.\n    const start = staticPosition + offset;\n    cursor.setPosition(start);\n    const length = Bytes.toNumber(cursor.readBytes(32));\n    // If there is no length, we have zero data (empty string).\n    if (length === 0) {\n        cursor.setPosition(staticPosition + 32);\n        return ['', 32];\n    }\n    const data = cursor.readBytes(length, 32);\n    const value = Bytes.toString(Bytes.trimLeft(data));\n    // As we have gone wondering, restore to the original position + next slot.\n    cursor.setPosition(staticPosition + 32);\n    return [value, 32];\n}\n/** @internal */\nexport function prepareParameters({ checksumAddress, parameters, values, }) {\n    const preparedParameters = [];\n    for (let i = 0; i < parameters.length; i++) {\n        preparedParameters.push(prepareParameter({\n            checksumAddress,\n            parameter: parameters[i],\n            value: values[i],\n        }));\n    }\n    return preparedParameters;\n}\n/** @internal */\nexport function prepareParameter({ checksumAddress = false, parameter: parameter_, value, }) {\n    const parameter = parameter_;\n    const arrayComponents = getArrayComponents(parameter.type);\n    if (arrayComponents) {\n        const [length, type] = arrayComponents;\n        return encodeArray(value, {\n            checksumAddress,\n            length,\n            parameter: {\n                ...parameter,\n                type,\n            },\n        });\n    }\n    if (parameter.type === 'tuple') {\n        return encodeTuple(value, {\n            checksumAddress,\n            parameter: parameter,\n        });\n    }\n    if (parameter.type === 'address') {\n        return encodeAddress(value, {\n            checksum: checksumAddress,\n        });\n    }\n    if (parameter.type === 'bool') {\n        return encodeBoolean(value);\n    }\n    if (parameter.type.startsWith('uint') || parameter.type.startsWith('int')) {\n        const signed = parameter.type.startsWith('int');\n        const [, , size = '256'] = integerRegex.exec(parameter.type) ?? [];\n        return encodeNumber(value, {\n            signed,\n            size: Number(size),\n        });\n    }\n    if (parameter.type.startsWith('bytes')) {\n        return encodeBytes(value, { type: parameter.type });\n    }\n    if (parameter.type === 'string') {\n        return encodeString(value);\n    }\n    throw new AbiParameters.InvalidTypeError(parameter.type);\n}\n/** @internal */\nexport function encode(preparedParameters) {\n    // 1. Compute the size of the static part of the parameters.\n    let staticSize = 0;\n    for (let i = 0; i < preparedParameters.length; i++) {\n        const { dynamic, encoded } = preparedParameters[i];\n        if (dynamic)\n            staticSize += 32;\n        else\n            staticSize += Hex.size(encoded);\n    }\n    // 2. Split the parameters into static and dynamic parts.\n    const staticParameters = [];\n    const dynamicParameters = [];\n    let dynamicSize = 0;\n    for (let i = 0; i < preparedParameters.length; i++) {\n        const { dynamic, encoded } = preparedParameters[i];\n        if (dynamic) {\n            staticParameters.push(Hex.fromNumber(staticSize + dynamicSize, { size: 32 }));\n            dynamicParameters.push(encoded);\n            dynamicSize += Hex.size(encoded);\n        }\n        else {\n            staticParameters.push(encoded);\n        }\n    }\n    // 3. Concatenate static and dynamic parts.\n    return Hex.concat(...staticParameters, ...dynamicParameters);\n}\n/** @internal */\nexport function encodeAddress(value, options) {\n    const { checksum = false } = options;\n    Address.assert(value, { strict: checksum });\n    return {\n        dynamic: false,\n        encoded: Hex.padLeft(value.toLowerCase()),\n    };\n}\n/** @internal */\nexport function encodeArray(value, options) {\n    const { checksumAddress, length, parameter } = options;\n    const dynamic = length === null;\n    if (!Array.isArray(value))\n        throw new AbiParameters.InvalidArrayError(value);\n    if (!dynamic && value.length !== length)\n        throw new AbiParameters.ArrayLengthMismatchError({\n            expectedLength: length,\n            givenLength: value.length,\n            type: `${parameter.type}[${length}]`,\n        });\n    let dynamicChild = false;\n    const preparedParameters = [];\n    for (let i = 0; i < value.length; i++) {\n        const preparedParam = prepareParameter({\n            checksumAddress,\n            parameter,\n            value: value[i],\n        });\n        if (preparedParam.dynamic)\n            dynamicChild = true;\n        preparedParameters.push(preparedParam);\n    }\n    if (dynamic || dynamicChild) {\n        const data = encode(preparedParameters);\n        if (dynamic) {\n            const length = Hex.fromNumber(preparedParameters.length, { size: 32 });\n            return {\n                dynamic: true,\n                encoded: preparedParameters.length > 0 ? Hex.concat(length, data) : length,\n            };\n        }\n        if (dynamicChild)\n            return { dynamic: true, encoded: data };\n    }\n    return {\n        dynamic: false,\n        encoded: Hex.concat(...preparedParameters.map(({ encoded }) => encoded)),\n    };\n}\n/** @internal */\nexport function encodeBytes(value, { type }) {\n    const [, parametersize] = type.split('bytes');\n    const bytesSize = Hex.size(value);\n    if (!parametersize) {\n        let value_ = value;\n        // If the size is not divisible by 32 bytes, pad the end\n        // with empty bytes to the ceiling 32 bytes.\n        if (bytesSize % 32 !== 0)\n            value_ = Hex.padRight(value_, Math.ceil((value.length - 2) / 2 / 32) * 32);\n        return {\n            dynamic: true,\n            encoded: Hex.concat(Hex.padLeft(Hex.fromNumber(bytesSize, { size: 32 })), value_),\n        };\n    }\n    if (bytesSize !== Number.parseInt(parametersize, 10))\n        throw new AbiParameters.BytesSizeMismatchError({\n            expectedSize: Number.parseInt(parametersize, 10),\n            value,\n        });\n    return { dynamic: false, encoded: Hex.padRight(value) };\n}\n/** @internal */\nexport function encodeBoolean(value) {\n    if (typeof value !== 'boolean')\n        throw new Errors.BaseError(`Invalid boolean value: \"${value}\" (type: ${typeof value}). Expected: \\`true\\` or \\`false\\`.`);\n    return { dynamic: false, encoded: Hex.padLeft(Hex.fromBoolean(value)) };\n}\n/** @internal */\nexport function encodeNumber(value, { signed, size }) {\n    if (typeof size === 'number') {\n        const max = 2n ** (BigInt(size) - (signed ? 1n : 0n)) - 1n;\n        const min = signed ? -max - 1n : 0n;\n        if (value > max || value < min)\n            throw new Hex.IntegerOutOfRangeError({\n                max: max.toString(),\n                min: min.toString(),\n                signed,\n                size: size / 8,\n                value: value.toString(),\n            });\n    }\n    return {\n        dynamic: false,\n        encoded: Hex.fromNumber(value, {\n            size: 32,\n            signed,\n        }),\n    };\n}\n/** @internal */\nexport function encodeString(value) {\n    const hexValue = Hex.fromString(value);\n    const partsLength = Math.ceil(Hex.size(hexValue) / 32);\n    const parts = [];\n    for (let i = 0; i < partsLength; i++) {\n        parts.push(Hex.padRight(Hex.slice(hexValue, i * 32, (i + 1) * 32)));\n    }\n    return {\n        dynamic: true,\n        encoded: Hex.concat(Hex.padRight(Hex.fromNumber(Hex.size(hexValue), { size: 32 })), ...parts),\n    };\n}\n/** @internal */\nexport function encodeTuple(value, options) {\n    const { checksumAddress, parameter } = options;\n    let dynamic = false;\n    const preparedParameters = [];\n    for (let i = 0; i < parameter.components.length; i++) {\n        const param_ = parameter.components[i];\n        const index = Array.isArray(value) ? i : param_.name;\n        const preparedParam = prepareParameter({\n            checksumAddress,\n            parameter: param_,\n            value: value[index],\n        });\n        preparedParameters.push(preparedParam);\n        if (preparedParam.dynamic)\n            dynamic = true;\n    }\n    return {\n        dynamic,\n        encoded: dynamic\n            ? encode(preparedParameters)\n            : Hex.concat(...preparedParameters.map(({ encoded }) => encoded)),\n    };\n}\n/** @internal */\nexport function getArrayComponents(type) {\n    const matches = type.match(/^(.*)\\[(\\d+)?\\]$/);\n    return matches\n        ? // Return `null` if the array is dynamic.\n            [matches[2] ? Number(matches[2]) : null, matches[1]]\n        : undefined;\n}\n/** @internal */\nexport function hasDynamicChild(param) {\n    const { type } = param;\n    if (type === 'string')\n        return true;\n    if (type === 'bytes')\n        return true;\n    if (type.endsWith('[]'))\n        return true;\n    if (type === 'tuple')\n        return param.components?.some(hasDynamicChild);\n    const arrayComponents = getArrayComponents(param.type);\n    if (arrayComponents &&\n        hasDynamicChild({\n            ...param,\n            type: arrayComponents[1],\n        }))\n        return true;\n    return false;\n}\n//# sourceMappingURL=abiParameters.js.map"],"names":["decodeParameter","cursor","param","options","checksumAddress","staticPosition","arrayComponents","getArrayComponents","type","length","decodeArray","decodeTuple","decodeAddress","checksum","decodeBool","startsWith","decodeBytes","decodeNumber","decodeString","AbiParameters.InvalidTypeError","sizeOfLength","sizeOfOffset","value","readBytes","address","Hex.fromBytes","Bytes.slice","Address.checksum","start","Bytes.toNumber","startOfData","setPosition","dynamicChild","hasDynamicChild","consumed","i","data","consumed_","push","Bytes.toBoolean","size","_","split","offset","Number","parseInt","signed","Bytes.toBigInt","hasUnnamedChild","components","some","name","component","Bytes.toString","Bytes.trimLeft","prepareParameters","parameters","values","preparedParameters","prepareParameter","parameter","parameter_","encodeArray","encodeTuple","encodeAddress","encodeBoolean","integerRegex","exec","encodeNumber","encodeBytes","encodeString","encode","staticSize","dynamic","encoded","Hex.size","staticParameters","dynamicParameters","dynamicSize","Hex.fromNumber","Hex.concat","Address.assert","strict","Hex.padLeft","toLowerCase","Array","isArray","AbiParameters.InvalidArrayError","AbiParameters.ArrayLengthMismatchError","expectedLength","givenLength","preparedParam","map","parametersize","bytesSize","value_","Hex.padRight","Math","ceil","AbiParameters.BytesSizeMismatchError","expectedSize","Errors.BaseError","Hex.fromBoolean","max","BigInt","min","Hex.IntegerOutOfRangeError","toString","hexValue","Hex.fromString","partsLength","parts","Hex.slice","param_","matches","match","undefined","endsWith"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/bytes.js"],"sourcesContent":["import * as Bytes from '../Bytes.js';\n/** @internal */\nexport function assertSize(bytes, size_) {\n    if (Bytes.size(bytes) > size_)\n        throw new Bytes.SizeOverflowError({\n            givenSize: Bytes.size(bytes),\n            maxSize: size_,\n        });\n}\n/** @internal */\nexport function assertStartOffset(value, start) {\n    if (typeof start === 'number' && start > 0 && start > Bytes.size(value) - 1)\n        throw new Bytes.SliceOffsetOutOfBoundsError({\n            offset: start,\n            position: 'start',\n            size: Bytes.size(value),\n        });\n}\n/** @internal */\nexport function assertEndOffset(value, start, end) {\n    if (typeof start === 'number' &&\n        typeof end === 'number' &&\n        Bytes.size(value) !== end - start) {\n        throw new Bytes.SliceOffsetOutOfBoundsError({\n            offset: end,\n            position: 'end',\n            size: Bytes.size(value),\n        });\n    }\n}\n/** @internal */\nexport const charCodeMap = {\n    zero: 48,\n    nine: 57,\n    A: 65,\n    F: 70,\n    a: 97,\n    f: 102,\n};\n/** @internal */\nexport function charCodeToBase16(char) {\n    if (char >= charCodeMap.zero && char <= charCodeMap.nine)\n        return char - charCodeMap.zero;\n    if (char >= charCodeMap.A && char <= charCodeMap.F)\n        return char - (charCodeMap.A - 10);\n    if (char >= charCodeMap.a && char <= charCodeMap.f)\n        return char - (charCodeMap.a - 10);\n    return undefined;\n}\n/** @internal */\nexport function pad(bytes, options = {}) {\n    const { dir, size = 32 } = options;\n    if (size === 0)\n        return bytes;\n    if (bytes.length > size)\n        throw new Bytes.SizeExceedsPaddingSizeError({\n            size: bytes.length,\n            targetSize: size,\n            type: 'Bytes',\n        });\n    const paddedBytes = new Uint8Array(size);\n    for (let i = 0; i < size; i++) {\n        const padEnd = dir === 'right';\n        paddedBytes[padEnd ? i : size - i - 1] =\n            bytes[padEnd ? i : bytes.length - i - 1];\n    }\n    return paddedBytes;\n}\n/** @internal */\nexport function trim(value, options = {}) {\n    const { dir = 'left' } = options;\n    let data = value;\n    let sliceLength = 0;\n    for (let i = 0; i < data.length - 1; i++) {\n        if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')\n            sliceLength++;\n        else\n            break;\n    }\n    data =\n        dir === 'left'\n            ? data.slice(sliceLength)\n            : data.slice(0, data.length - sliceLength);\n    return data;\n}\n//# sourceMappingURL=bytes.js.map"],"names":["assertSize","bytes","size_","Bytes.size","Bytes.SizeOverflowError","givenSize","maxSize","charCodeMap","zero","nine","A","F","a","f","charCodeToBase16","char","pad","options","dir","size","length","Bytes.SizeExceedsPaddingSizeError","targetSize","type","paddedBytes","Uint8Array","i","padEnd","trim","value","data","sliceLength","toString","slice"],"mappings":"2FAEO,SAASA,EAAWC,EAAOC,GAC9B,GAAIC,EAAWF,GAASC,EACpB,MAAM,IAAIE,EAAwB,CAC9BC,UAAWF,EAAWF,GACtBK,QAASJ,GAErB,CAuBY,MAACK,EAAc,CACvBC,KAAM,GACNC,KAAM,GACNC,EAAG,GACHC,EAAG,GACHC,EAAG,GACHC,EAAG,KAGA,SAASC,EAAiBC,GAC7B,OAAIA,GAAQR,EAAYC,MAAQO,GAAQR,EAAYE,KACzCM,EAAOR,EAAYC,KAC1BO,GAAQR,EAAYG,GAAKK,GAAQR,EAAYI,EACtCI,GAAQR,EAAYG,EAAI,IAC/BK,GAAQR,EAAYK,GAAKG,GAAQR,EAAYM,EACtCE,GAAQR,EAAYK,EAAI,SADnC,CAGJ,CAEO,SAASI,EAAIf,EAAOgB,EAAU,IACjC,MAAMC,IAAEA,EAAGC,KAAEA,EAAO,IAAOF,EAC3B,GAAa,IAATE,EACA,OAAOlB,EACX,GAAIA,EAAMmB,OAASD,EACf,MAAM,IAAIE,EAAkC,CACxCF,KAAMlB,EAAMmB,OACZE,WAAYH,EACZI,KAAM,UAEd,MAAMC,EAAc,IAAIC,WAAWN,GACnC,IAAK,IAAIO,EAAI,EAAGA,EAAIP,EAAMO,IAAK,CAC3B,MAAMC,EAAiB,UAART,EACfM,EAAYG,EAASD,EAAIP,EAAOO,EAAI,GAChCzB,EAAM0B,EAASD,EAAIzB,EAAMmB,OAASM,EAAI,EAC9C,CACA,OAAOF,CACX,CAEO,SAASI,EAAKC,EAAOZ,EAAU,IAClC,MAAMC,IAAEA,EAAM,QAAWD,EACzB,IAAIa,EAAOD,EACPE,EAAc,EAClB,IAAK,IAAIL,EAAI,EAAGA,EAAII,EAAKV,OAAS,GACoC,MAA9DU,EAAa,SAARZ,EAAiBQ,EAAII,EAAKV,OAASM,EAAI,GAAGM,WADlBN,IAE7BK,IAQR,OAJAD,EACY,SAARZ,EACMY,EAAKG,MAAMF,GACXD,EAAKG,MAAM,EAAGH,EAAKV,OAASW,GAC/BD,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/cursor.js"],"sourcesContent":["import * as Errors from '../Errors.js';\nconst staticCursor = {\n    bytes: new Uint8Array(),\n    dataView: new DataView(new ArrayBuffer(0)),\n    position: 0,\n    positionReadCount: new Map(),\n    recursiveReadCount: 0,\n    recursiveReadLimit: Number.POSITIVE_INFINITY,\n    assertReadLimit() {\n        if (this.recursiveReadCount >= this.recursiveReadLimit)\n            throw new RecursiveReadLimitExceededError({\n                count: this.recursiveReadCount + 1,\n                limit: this.recursiveReadLimit,\n            });\n    },\n    assertPosition(position) {\n        if (position < 0 || position > this.bytes.length - 1)\n            throw new PositionOutOfBoundsError({\n                length: this.bytes.length,\n                position,\n            });\n    },\n    decrementPosition(offset) {\n        if (offset < 0)\n            throw new NegativeOffsetError({ offset });\n        const position = this.position - offset;\n        this.assertPosition(position);\n        this.position = position;\n    },\n    getReadCount(position) {\n        return this.positionReadCount.get(position || this.position) || 0;\n    },\n    incrementPosition(offset) {\n        if (offset < 0)\n            throw new NegativeOffsetError({ offset });\n        const position = this.position + offset;\n        this.assertPosition(position);\n        this.position = position;\n    },\n    inspectByte(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position);\n        return this.bytes[position];\n    },\n    inspectBytes(length, position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + length - 1);\n        return this.bytes.subarray(position, position + length);\n    },\n    inspectUint8(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position);\n        return this.bytes[position];\n    },\n    inspectUint16(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + 1);\n        return this.dataView.getUint16(position);\n    },\n    inspectUint24(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + 2);\n        return ((this.dataView.getUint16(position) << 8) +\n            this.dataView.getUint8(position + 2));\n    },\n    inspectUint32(position_) {\n        const position = position_ ?? this.position;\n        this.assertPosition(position + 3);\n        return this.dataView.getUint32(position);\n    },\n    pushByte(byte) {\n        this.assertPosition(this.position);\n        this.bytes[this.position] = byte;\n        this.position++;\n    },\n    pushBytes(bytes) {\n        this.assertPosition(this.position + bytes.length - 1);\n        this.bytes.set(bytes, this.position);\n        this.position += bytes.length;\n    },\n    pushUint8(value) {\n        this.assertPosition(this.position);\n        this.bytes[this.position] = value;\n        this.position++;\n    },\n    pushUint16(value) {\n        this.assertPosition(this.position + 1);\n        this.dataView.setUint16(this.position, value);\n        this.position += 2;\n    },\n    pushUint24(value) {\n        this.assertPosition(this.position + 2);\n        this.dataView.setUint16(this.position, value >> 8);\n        this.dataView.setUint8(this.position + 2, value & ~4294967040);\n        this.position += 3;\n    },\n    pushUint32(value) {\n        this.assertPosition(this.position + 3);\n        this.dataView.setUint32(this.position, value);\n        this.position += 4;\n    },\n    readByte() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectByte();\n        this.position++;\n        return value;\n    },\n    readBytes(length, size) {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectBytes(length);\n        this.position += size ?? length;\n        return value;\n    },\n    readUint8() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint8();\n        this.position += 1;\n        return value;\n    },\n    readUint16() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint16();\n        this.position += 2;\n        return value;\n    },\n    readUint24() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint24();\n        this.position += 3;\n        return value;\n    },\n    readUint32() {\n        this.assertReadLimit();\n        this._touch();\n        const value = this.inspectUint32();\n        this.position += 4;\n        return value;\n    },\n    get remaining() {\n        return this.bytes.length - this.position;\n    },\n    setPosition(position) {\n        const oldPosition = this.position;\n        this.assertPosition(position);\n        this.position = position;\n        return () => (this.position = oldPosition);\n    },\n    _touch() {\n        if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)\n            return;\n        const count = this.getReadCount();\n        this.positionReadCount.set(this.position, count + 1);\n        if (count > 0)\n            this.recursiveReadCount++;\n    },\n};\n/** @internal */\nexport function create(bytes, { recursiveReadLimit = 8_192 } = {}) {\n    const cursor = Object.create(staticCursor);\n    cursor.bytes = bytes;\n    cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    cursor.positionReadCount = new Map();\n    cursor.recursiveReadLimit = recursiveReadLimit;\n    return cursor;\n}\n/** @internal */\nexport class NegativeOffsetError extends Errors.BaseError {\n    constructor({ offset }) {\n        super(`Offset \\`${offset}\\` cannot be negative.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cursor.NegativeOffsetError'\n        });\n    }\n}\n/** @internal */\nexport class PositionOutOfBoundsError extends Errors.BaseError {\n    constructor({ length, position }) {\n        super(`Position \\`${position}\\` is out of bounds (\\`0 < position < ${length}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cursor.PositionOutOfBoundsError'\n        });\n    }\n}\n/** @internal */\nexport class RecursiveReadLimitExceededError extends Errors.BaseError {\n    constructor({ count, limit }) {\n        super(`Recursive read limit of \\`${limit}\\` exceeded (recursive read count: \\`${count}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cursor.RecursiveReadLimitExceededError'\n        });\n    }\n}\n//# sourceMappingURL=cursor.js.map"],"names":["staticCursor","bytes","Uint8Array","dataView","DataView","ArrayBuffer","position","positionReadCount","Map","recursiveReadCount","recursiveReadLimit","Number","POSITIVE_INFINITY","assertReadLimit","this","RecursiveReadLimitExceededError","count","limit","assertPosition","length","PositionOutOfBoundsError","decrementPosition","offset","NegativeOffsetError","getReadCount","get","incrementPosition","inspectByte","position_","inspectBytes","subarray","inspectUint8","inspectUint16","getUint16","inspectUint24","getUint8","inspectUint32","getUint32","pushByte","byte","pushBytes","set","pushUint8","value","pushUint16","setUint16","pushUint24","setUint8","pushUint32","setUint32","readByte","_touch","readBytes","size","readUint8","readUint16","readUint24","readUint32","remaining","setPosition","oldPosition","create","cursor","Object","buffer","byteOffset","byteLength","Errors.BaseError","constructor","super","defineProperty","enumerable","configurable","writable"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/errors.js"],"sourcesContent":["import { version } from '../version.js';\n/** @internal */\nexport function getUrl(url) {\n    return url;\n}\n/** @internal */\nexport function getVersion() {\n    return version;\n}\n/** @internal */\nexport function prettyPrint(args) {\n    if (!args)\n        return '';\n    const entries = Object.entries(args)\n        .map(([key, value]) => {\n        if (value === undefined || value === false)\n            return null;\n        return [key, value];\n    })\n        .filter(Boolean);\n    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);\n    return entries\n        .map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`)\n        .join('\\n');\n}\n//# sourceMappingURL=errors.js.map"],"names":["getVersion","version"],"mappings":"wCAMO,SAASA,IACZ,OAAOC,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/hex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/hex.js"],"sourcesContent":["import * as Hex from '../Hex.js';\n/** @internal */\nexport function assertSize(hex, size_) {\n    if (Hex.size(hex) > size_)\n        throw new Hex.SizeOverflowError({\n            givenSize: Hex.size(hex),\n            maxSize: size_,\n        });\n}\n/** @internal */\nexport function assertStartOffset(value, start) {\n    if (typeof start === 'number' && start > 0 && start > Hex.size(value) - 1)\n        throw new Hex.SliceOffsetOutOfBoundsError({\n            offset: start,\n            position: 'start',\n            size: Hex.size(value),\n        });\n}\n/** @internal */\nexport function assertEndOffset(value, start, end) {\n    if (typeof start === 'number' &&\n        typeof end === 'number' &&\n        Hex.size(value) !== end - start) {\n        throw new Hex.SliceOffsetOutOfBoundsError({\n            offset: end,\n            position: 'end',\n            size: Hex.size(value),\n        });\n    }\n}\n/** @internal */\nexport function pad(hex_, options = {}) {\n    const { dir, size = 32 } = options;\n    if (size === 0)\n        return hex_;\n    const hex = hex_.replace('0x', '');\n    if (hex.length > size * 2)\n        throw new Hex.SizeExceedsPaddingSizeError({\n            size: Math.ceil(hex.length / 2),\n            targetSize: size,\n            type: 'Hex',\n        });\n    return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}`;\n}\n/** @internal */\nexport function trim(value, options = {}) {\n    const { dir = 'left' } = options;\n    let data = value.replace('0x', '');\n    let sliceLength = 0;\n    for (let i = 0; i < data.length - 1; i++) {\n        if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')\n            sliceLength++;\n        else\n            break;\n    }\n    data =\n        dir === 'left'\n            ? data.slice(sliceLength)\n            : data.slice(0, data.length - sliceLength);\n    if (data === '0')\n        return '0x';\n    if (dir === 'right' && data.length % 2 === 1)\n        return `0x${data}0`;\n    return `0x${data}`;\n}\n//# sourceMappingURL=hex.js.map"],"names":["assertSize","hex","size_","Hex.size","Hex.SizeOverflowError","givenSize","maxSize","assertStartOffset","value","start","Hex.SliceOffsetOutOfBoundsError","offset","position","size","assertEndOffset","end","pad","hex_","options","dir","replace","length","Hex.SizeExceedsPaddingSizeError","Math","ceil","targetSize","type"],"mappings":"0HAEO,SAASA,EAAWC,EAAKC,GAC5B,GAAIC,EAASF,GAAOC,EAChB,MAAM,IAAIE,EAAsB,CAC5BC,UAAWF,EAASF,GACpBK,QAASJ,GAErB,CAEO,SAASK,EAAkBC,EAAOC,GACrC,GAAqB,iBAAVA,GAAsBA,EAAQ,GAAKA,EAAQN,EAASK,GAAS,EACpE,MAAM,IAAIE,EAAgC,CACtCC,OAAQF,EACRG,SAAU,QACVC,KAAMV,EAASK,IAE3B,CAEO,SAASM,EAAgBN,EAAOC,EAAOM,GAC1C,GAAqB,iBAAVN,GACQ,iBAARM,GACPZ,EAASK,KAAWO,EAAMN,EAC1B,MAAM,IAAIC,EAAgC,CACtCC,OAAQI,EACRH,SAAU,MACVC,KAAMV,EAASK,IAG3B,CAEO,SAASQ,EAAIC,EAAMC,EAAU,IAChC,MAAMC,IAAEA,EAAGN,KAAEA,EAAO,IAAOK,EAC3B,GAAa,IAATL,EACA,OAAOI,EACX,MAAMhB,EAAMgB,EAAKG,QAAQ,KAAM,IAC/B,GAAInB,EAAIoB,OAAgB,EAAPR,EACb,MAAM,IAAIS,EAAgC,CACtCT,KAAMU,KAAKC,KAAKvB,EAAIoB,OAAS,GAC7BI,WAAYZ,EACZa,KAAM,QAEd,MAAO,KAAKzB,EAAY,UAARkB,EAAkB,SAAW,YAAmB,EAAPN,EAAU,MACvE","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/lru.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru.js","sources":["../../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/internal/lru.js"],"sourcesContent":["/**\n * @internal\n *\n * Map with a LRU (Least recently used) policy.\n * @see https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU\n */\nexport class LruMap extends Map {\n    constructor(size) {\n        super();\n        Object.defineProperty(this, \"maxSize\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        this.maxSize = size;\n    }\n    get(key) {\n        const value = super.get(key);\n        if (super.has(key) && value !== undefined) {\n            this.delete(key);\n            super.set(key, value);\n        }\n        return value;\n    }\n    set(key, value) {\n        super.set(key, value);\n        if (this.maxSize && this.size > this.maxSize) {\n            const firstKey = this.keys().next().value;\n            if (firstKey)\n                this.delete(firstKey);\n        }\n        return this;\n    }\n}\n//# sourceMappingURL=lru.js.map"],"names":["LruMap","Map","constructor","size","super","Object","defineProperty","this","enumerable","configurable","writable","value","maxSize","get","key","has","undefined","delete","set","firstKey","keys","next"],"mappings":"AAMO,MAAMA,UAAeC,IACxB,WAAAC,CAAYC,GACRC,QACAC,OAAOC,eAAeC,KAAM,UAAW,CACnCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVC,WAAO,IAEXJ,KAAKK,QAAUT,CACnB,CACA,GAAAU,CAAIC,GACA,MAAMH,EAAQP,MAAMS,IAAIC,GAKxB,OAJIV,MAAMW,IAAID,SAAkBE,IAAVL,IAClBJ,KAAKU,OAAOH,GACZV,MAAMc,IAAIJ,EAAKH,IAEZA,CACX,CACA,GAAAO,CAAIJ,EAAKH,GAEL,GADAP,MAAMc,IAAIJ,EAAKH,GACXJ,KAAKK,SAAWL,KAAKJ,KAAOI,KAAKK,QAAS,CAC1C,MAAMO,EAAWZ,KAAKa,OAAOC,OAAOV,MAChCQ,GACAZ,KAAKU,OAAOE,EACpB,CACA,OAAOZ,IACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/core/version.js"],"sourcesContent":["/** @internal */\nexport const version = '0.1.1';\n//# sourceMappingURL=version.js.map"],"names":["version"],"mappings":"AACY,MAACA,EAAU","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/erc6492/SignatureErc6492.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureErc6492.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/erc6492/SignatureErc6492.js"],"sourcesContent":["import * as AbiParameters from '../core/AbiParameters.js';\nimport * as Errors from '../core/Errors.js';\nimport * as Hex from '../core/Hex.js';\n/**\n * Magic bytes used to identify ERC-6492 wrapped signatures.\n */\nexport const magicBytes = '0x6492649264926492649264926492649264926492649264926492649264926492';\n/**\n * Deployless ERC-6492 signature verification bytecode.\n */\nexport const universalSignatureValidatorBytecode = '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';\n/**\n * ABI for the ERC-6492 universal deployless signature validator contract.\n *\n * Constructor return value is `0x1` (valid) or `0x0` (invalid).\n */\nexport const universalSignatureValidatorAbi = [\n    {\n        inputs: [\n            {\n                name: '_signer',\n                type: 'address',\n            },\n            {\n                name: '_hash',\n                type: 'bytes32',\n            },\n            {\n                name: '_signature',\n                type: 'bytes',\n            },\n        ],\n        stateMutability: 'nonpayable',\n        type: 'constructor',\n    },\n    {\n        inputs: [\n            {\n                name: '_signer',\n                type: 'address',\n            },\n            {\n                name: '_hash',\n                type: 'bytes32',\n            },\n            {\n                name: '_signature',\n                type: 'bytes',\n            },\n        ],\n        outputs: [\n            {\n                type: 'bool',\n            },\n        ],\n        stateMutability: 'nonpayable',\n        type: 'function',\n        name: 'isValidSig',\n    },\n];\n/**\n * Asserts that the wrapped signature is valid.\n *\n * @example\n * ```ts twoslash\n * import { SignatureErc6492 } from 'ox/erc6492'\n *\n * SignatureErc6492.assert('0xdeadbeef')\n * // @error: InvalidWrappedSignatureError: Value `0xdeadbeef` is an invalid ERC-6492 wrapped signature.\n * ```\n *\n * @param wrapped - The wrapped signature to assert.\n */\nexport function assert(wrapped) {\n    if (Hex.slice(wrapped, -32) !== magicBytes)\n        throw new InvalidWrappedSignatureError(wrapped);\n}\n/**\n * Parses an [ERC-6492 wrapped signature](https://eips.ethereum.org/EIPS/eip-6492#specification) into its constituent parts.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Secp256k1 } from 'ox'\n * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]\n *\n * const signature = Secp256k1.sign({\n *   payload: '0x...',\n *   privateKey: '0x...',\n * })\n *\n * // Instantiate from serialized format. // [!code focus]\n * const wrapped = SignatureErc6492.from('0x...') // [!code focus]\n * // @log: { data: '0x...', signature: { ... }, to: '0x...', } // [!code focus]\n *\n * // Instantiate from constituent parts. // [!code focus]\n * const wrapped = SignatureErc6492.from({ // [!code focus]\n *   data: '0x...', // [!code focus]\n *   signature, // [!code focus]\n *   to: '0x...', // [!code focus]\n * })\n * // @log: { data: '0x...', signature: { ... }, to: '0x...', }\n * ```\n *\n * @param wrapped - Wrapped signature to parse.\n * @returns Wrapped signature.\n */\nexport function from(wrapped) {\n    if (typeof wrapped === 'string')\n        return unwrap(wrapped);\n    return wrapped;\n}\n/**\n * Parses an [ERC-6492 wrapped signature](https://eips.ethereum.org/EIPS/eip-6492#specification) into its constituent parts.\n *\n * @example\n * ```ts twoslash\n * import { SignatureErc6492 } from 'ox/erc6492'\n *\n * const { data, signature, to } = SignatureErc6492.unwrap('0x...')\n * ```\n *\n * @param wrapped - Wrapped signature to parse.\n * @returns Wrapped signature.\n */\nexport function unwrap(wrapped) {\n    assert(wrapped);\n    const [to, data, signature] = AbiParameters.decode(AbiParameters.from('address, bytes, bytes'), wrapped);\n    return { data, signature, to };\n}\n/**\n * Serializes an [ERC-6492 wrapped signature](https://eips.ethereum.org/EIPS/eip-6492#specification).\n *\n * @example\n * ```ts twoslash\n * import { Secp256k1, Signature } from 'ox'\n * import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]\n *\n * const signature = Secp256k1.sign({\n *   payload: '0x...',\n *   privateKey: '0x...',\n * })\n *\n * const wrapped = SignatureErc6492.wrap({ // [!code focus]\n *   data: '0xdeadbeef', // [!code focus]\n *   signature: Signature.toHex(signature), // [!code focus]\n *   to: '0x00000000219ab540356cBB839Cbe05303d7705Fa', // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param value - Wrapped signature to serialize.\n * @returns Serialized wrapped signature.\n */\nexport function wrap(value) {\n    const { data, signature, to } = value;\n    return Hex.concat(AbiParameters.encode(AbiParameters.from('address, bytes, bytes'), [\n        to,\n        data,\n        signature,\n    ]), magicBytes);\n}\n/**\n * Validates a wrapped signature. Returns `true` if the wrapped signature is valid, `false` otherwise.\n *\n * @example\n * ```ts twoslash\n * import { SignatureErc6492 } from 'ox/erc6492'\n *\n * const valid = SignatureErc6492.validate('0xdeadbeef')\n * // @log: false\n * ```\n *\n * @param wrapped - The wrapped signature to validate.\n * @returns `true` if the wrapped signature is valid, `false` otherwise.\n */\nexport function validate(wrapped) {\n    try {\n        assert(wrapped);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/** Thrown when the ERC-6492 wrapped signature is invalid. */\nexport class InvalidWrappedSignatureError extends Errors.BaseError {\n    constructor(wrapped) {\n        super(`Value \\`${wrapped}\\` is an invalid ERC-6492 wrapped signature.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'SignatureErc6492.InvalidWrappedSignatureError'\n        });\n    }\n}\n//# sourceMappingURL=SignatureErc6492.js.map"],"names":["magicBytes","assert","wrapped","Hex.slice","InvalidWrappedSignatureError","wrap","value","data","signature","to","Hex.concat","AbiParameters.encode","AbiParameters.from","validate","Errors.BaseError","constructor","super","Object","defineProperty","this","enumerable","configurable","writable"],"mappings":"6JAMY,MAACA,EAAa,qEAmEnB,SAASC,EAAOC,GACnB,GAAIC,EAAUD,GAAS,MAASF,EAC5B,MAAM,IAAII,EAA6BF,EAC/C,CA6EO,SAASG,EAAKC,GACjB,MAAMC,KAAEA,EAAIC,UAAEA,EAASC,GAAEA,GAAOH,EAChC,OAAOI,EAAWC,EAAqBC,EAAmB,yBAA0B,CAChFH,EACAF,EACAC,IACAR,EACR,CAeO,SAASa,EAASX,GACrB,IAEI,OADAD,EAAOC,IACA,CACX,CACA,MACI,OAAO,CACX,CACJ,CAEO,MAAME,UAAqCU,EAC9C,WAAAC,CAAYb,GACRc,MAAM,WAAWd,iDACjBe,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVhB,MAAO,iDAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/erc8010/SignatureErc8010.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureErc8010.js","sources":["../../../../../../../../../node_modules/.pnpm/ox@0.9.6_typescript@5.9.2/node_modules/ox/_esm/erc8010/SignatureErc8010.js"],"sourcesContent":["import * as AbiParameters from '../core/AbiParameters.js';\nimport * as Authorization from '../core/Authorization.js';\nimport * as Errors from '../core/Errors.js';\nimport * as Hex from '../core/Hex.js';\nimport * as Secp256k1 from '../core/Secp256k1.js';\nimport * as Signature from '../core/Signature.js';\n/**\n * Magic bytes used to identify ERC-8010 wrapped signatures.\n */\nexport const magicBytes = '0x8010801080108010801080108010801080108010801080108010801080108010';\n/** Suffix ABI parameters for the ERC-8010 wrapped signature. */\nexport const suffixParameters = AbiParameters.from('(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data');\n/**\n * Asserts that the wrapped signature is valid.\n *\n * @example\n * ```ts twoslash\n * import { SignatureErc8010 } from 'ox/erc8010'\n *\n * SignatureErc8010.assert('0xdeadbeef')\n * // @error: InvalidWrappedSignatureError: Value `0xdeadbeef` is an invalid ERC-8010 wrapped signature.\n * ```\n *\n * @param value - The value to assert.\n */\nexport function assert(value) {\n    if (typeof value === 'string') {\n        if (Hex.slice(value, -32) !== magicBytes)\n            throw new InvalidWrappedSignatureError(value);\n    }\n    else\n        Signature.assert(value.authorization);\n}\n/**\n * Parses an [ERC-8010 wrapped signature](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md) into its constituent parts.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Secp256k1 } from 'ox'\n * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]\n *\n * const signature = Secp256k1.sign({\n *   payload: '0x...',\n *   privateKey: '0x...',\n * })\n *\n * // Instantiate from serialized format. // [!code focus]\n * const wrapped = SignatureErc8010.from('0x...') // [!code focus]\n * // @log: { authorization: { ... }, data: '0x...', signature: { ... } } // [!code focus]\n *\n * // Instantiate from constituent parts. // [!code focus]\n * const wrapped = SignatureErc8010.from({ // [!code focus]\n *   authorization: { ... }, // [!code focus]\n *   data: '0x...', // [!code focus]\n *   signature, // [!code focus]\n * })\n * // @log: { authorization: { ... }, data: '0x...', signature: { ... } }\n * ```\n *\n * @param value - Value to parse.\n * @returns Parsed value.\n */\nexport function from(value) {\n    if (typeof value === 'string')\n        return unwrap(value);\n    return value;\n}\n/**\n * Unwraps an [ERC-8010 wrapped signature](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md) into its constituent parts.\n *\n * @example\n * ```ts twoslash\n * import { SignatureErc8010 } from 'ox/erc8010'\n *\n * const { authorization, data, signature } = SignatureErc8010.unwrap('0x...')\n * ```\n *\n * @param wrapped - Wrapped signature to unwrap.\n * @returns Unwrapped signature.\n */\nexport function unwrap(wrapped) {\n    assert(wrapped);\n    const suffixLength = Hex.toNumber(Hex.slice(wrapped, -64, -32));\n    const suffix = Hex.slice(wrapped, -suffixLength - 64, -64);\n    const signature = Hex.slice(wrapped, 0, -suffixLength - 64);\n    const [auth, to, data] = AbiParameters.decode(suffixParameters, suffix);\n    const authorization = Authorization.from({\n        address: auth.delegation,\n        chainId: Number(auth.chainId),\n        nonce: auth.nonce,\n        yParity: auth.yParity,\n        r: auth.r,\n        s: auth.s,\n    });\n    return {\n        authorization,\n        signature,\n        ...(data && data !== '0x' ? { data, to } : {}),\n    };\n}\n/**\n * Wraps a signature into [ERC-8010 format](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md).\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Secp256k1, Signature } from 'ox'\n * import { SignatureErc8010 } from 'ox/erc8010' // [!code focus]\n *\n * const signature = Secp256k1.sign({\n *   payload: '0x...',\n *   privateKey: '0x...',\n * })\n *\n * const wrapped = SignatureErc8010.wrap({ // [!code focus]\n *   authorization: { ... }, // [!code focus]\n *   data: '0xdeadbeef', // [!code focus]\n *   signature: Signature.toHex(signature), // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param value - Values to wrap.\n * @returns Wrapped signature.\n */\nexport function wrap(value) {\n    const { data, signature } = value;\n    assert(value);\n    const self = Secp256k1.recoverAddress({\n        payload: Authorization.getSignPayload(value.authorization),\n        signature: Signature.from(value.authorization),\n    });\n    const suffix = AbiParameters.encode(suffixParameters, [\n        {\n            ...value.authorization,\n            delegation: value.authorization.address,\n            chainId: BigInt(value.authorization.chainId),\n        },\n        value.to ?? self,\n        data ?? '0x',\n    ]);\n    const suffixLength = Hex.fromNumber(Hex.size(suffix), { size: 32 });\n    return Hex.concat(signature, suffix, suffixLength, magicBytes);\n}\n/**\n * Validates a wrapped signature. Returns `true` if the wrapped signature is valid, `false` otherwise.\n *\n * @example\n * ```ts twoslash\n * import { SignatureErc8010 } from 'ox/erc8010'\n *\n * const valid = SignatureErc8010.validate('0xdeadbeef')\n * // @log: false\n * ```\n *\n * @param value - The value to validate.\n * @returns `true` if the value is valid, `false` otherwise.\n */\nexport function validate(value) {\n    try {\n        assert(value);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/** Thrown when the ERC-8010 wrapped signature is invalid. */\nexport class InvalidWrappedSignatureError extends Errors.BaseError {\n    constructor(wrapped) {\n        super(`Value \\`${wrapped}\\` is an invalid ERC-8010 wrapped signature.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'SignatureErc8010.InvalidWrappedSignatureError'\n        });\n    }\n}\n//# sourceMappingURL=SignatureErc8010.js.map"],"names":["magicBytes","suffixParameters","AbiParameters.from","assert","value","Hex.slice","InvalidWrappedSignatureError","Signature.assert","authorization","unwrap","wrapped","suffixLength","Hex.toNumber","suffix","signature","auth","to","data","AbiParameters.decode","Authorization.from","address","delegation","chainId","Number","nonce","yParity","r","s","validate","Errors.BaseError","constructor","super","Object","defineProperty","this","enumerable","configurable","writable"],"mappings":"6PASY,MAACA,EAAa,qEAEbC,EAAmBC,EAAmB,qHAc5C,SAASC,EAAOC,GACnB,GAAqB,iBAAVA,GACP,GAAIC,EAAUD,GAAO,MAASJ,EAC1B,MAAM,IAAIM,EAA6BF,QAG3CG,EAAiBH,EAAMI,cAC/B,CAiDO,SAASC,EAAOC,GACnBP,EAAOO,GACP,MAAMC,EAAeC,EAAaP,EAAUK,GAAS,IAAK,KACpDG,EAASR,EAAUK,GAAUC,EAAe,QAC5CG,EAAYT,EAAUK,EAAS,GAAIC,EAAe,KACjDI,EAAMC,EAAIC,GAAQC,EAAqBjB,EAAkBY,GAShE,MAAO,CACHL,cATkBW,EAAmB,CACrCC,QAASL,EAAKM,WACdC,QAASC,OAAOR,EAAKO,SACrBE,MAAOT,EAAKS,MACZC,QAASV,EAAKU,QACdC,EAAGX,EAAKW,EACRC,EAAGZ,EAAKY,IAIRb,eACIG,GAAiB,OAATA,EAAgB,CAAEA,OAAMD,MAAO,GAEnD,CA0DO,SAASY,EAASxB,GACrB,IAEI,OADAD,EAAOC,IACA,CACX,CACA,MACI,OAAO,CACX,CACJ,CAEO,MAAME,UAAqCuB,EAC9C,WAAAC,CAAYpB,GACRqB,MAAM,WAAWrB,iDACjBsB,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVjC,MAAO,iDAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/styled-components@6.1.19_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/styled-components/dist/styled-components.browser.esm.js

@@ -0,0 +1,2 @@
+import{__spreadArray as e,__assign as t}from"../../../../@rollup_plugin-typescript@11.1.6_rollup@4.52.2_tslib@2.8.1_typescript@5.9.2/node_modules/tslib/tslib.es6.js";import n from"../../../../@emotion_is-prop-valid@1.2.2/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js";import o,{useDebugValue as r,createElement as s,useRef as i,useContext as a}from"react";import c from"../../../../@emotion_unitless@0.8.1/node_modules/@emotion/unitless/dist/emotion-unitless.esm.js";import{RULESET as l}from"../../../../stylis@4.3.2/node_modules/stylis/src/Enum.js";import{prefixer as u,middleware as p,rulesheet as d}from"../../../../stylis@4.3.2/node_modules/stylis/src/Middleware.js";import{stringify as h,serialize as f}from"../../../../stylis@4.3.2/node_modules/stylis/src/Serializer.js";import{compile as m}from"../../../../stylis@4.3.2/node_modules/stylis/src/Parser.js";var y="undefined"!=typeof process&&void 0!==process.env&&(process.env.REACT_APP_SC_ATTR||process.env.SC_ATTR)||"data-styled",v="active",g="data-styled-version",S="6.1.19",w="/*!sc*/\n",b="undefined"!=typeof window&&"undefined"!=typeof document,E=Boolean("boolean"==typeof SC_DISABLE_SPEEDY?SC_DISABLE_SPEEDY:"undefined"!=typeof process&&void 0!==process.env&&void 0!==process.env.REACT_APP_SC_DISABLE_SPEEDY&&""!==process.env.REACT_APP_SC_DISABLE_SPEEDY?"false"!==process.env.REACT_APP_SC_DISABLE_SPEEDY&&process.env.REACT_APP_SC_DISABLE_SPEEDY:"undefined"!=typeof process&&void 0!==process.env&&void 0!==process.env.SC_DISABLE_SPEEDY&&""!==process.env.SC_DISABLE_SPEEDY?"false"!==process.env.SC_DISABLE_SPEEDY&&process.env.SC_DISABLE_SPEEDY:"production"!==process.env.NODE_ENV),N=/invalid hook call/i,_=new Set,C=function(t,n){if("production"!==process.env.NODE_ENV){var o=n?' with the id of "'.concat(n,'"'):"",r="The component ".concat(t).concat(o," has been created dynamically.\n")+"You may see this warning because you've called styled inside another component.\nTo resolve this only create new StyledComponents outside of any render method and function component.\nSee https://styled-components.com/docs/basics#define-styled-components-outside-of-the-render-method for more info.\n",s=console.error;try{var a=!0;console.error=function(t){for(var n=[],o=1;o<arguments.length;o++)n[o-1]=arguments[o];N.test(t)?(a=!1,_.delete(r)):s.apply(void 0,e([t],n,!1))},i(),a&&!_.has(r)&&(console.warn(r),_.add(r))}catch(e){N.test(e.message)&&_.delete(r)}finally{console.error=s}}},A=Object.freeze([]),P=Object.freeze({});var I=new Set(["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","big","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","keygen","label","legend","li","link","main","map","mark","menu","menuitem","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rp","rt","ruby","s","samp","script","section","select","small","source","span","strong","style","sub","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","track","u","ul","use","var","video","wbr","circle","clipPath","defs","ellipse","foreignObject","g","image","line","linearGradient","marker","mask","path","pattern","polygon","polyline","radialGradient","rect","stop","svg","text","tspan"]),D=/[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~-]+/g,R=/(^-|-$)/g;function O(e){return e.replace(D,"-").replace(R,"")}var T=/(a)(d)/gi,j=function(e){return String.fromCharCode(e+(e>25?39:97))};function k(e){var t,n="";for(t=Math.abs(e);t>52;t=t/52|0)n=j(t%52)+n;return(j(t%52)+n).replace(T,"$1-$2")}var x,z=function(e,t){for(var n=t.length;n;)e=33*e^t.charCodeAt(--n);return e},V=function(e){return z(5381,e)};function $(e){return k(V(e)>>>0)}function F(e){return"production"!==process.env.NODE_ENV&&"string"==typeof e&&e||e.displayName||e.name||"Component"}function B(e){return"string"==typeof e&&("production"===process.env.NODE_ENV||e.charAt(0)===e.charAt(0).toLowerCase())}var M="function"==typeof Symbol&&Symbol.for,L=M?Symbol.for("react.memo"):60115,G=M?Symbol.for("react.forward_ref"):60112,Y={childContextTypes:!0,contextType:!0,contextTypes:!0,defaultProps:!0,displayName:!0,getDefaultProps:!0,getDerivedStateFromError:!0,getDerivedStateFromProps:!0,mixins:!0,propTypes:!0,type:!0},q={name:!0,length:!0,prototype:!0,caller:!0,callee:!0,arguments:!0,arity:!0},H={$$typeof:!0,compare:!0,defaultProps:!0,displayName:!0,propTypes:!0,type:!0},W=((x={})[G]={$$typeof:!0,render:!0,defaultProps:!0,displayName:!0,propTypes:!0},x[L]=H,x);function U(e){return("type"in(t=e)&&t.type.$$typeof)===L?H:"$$typeof"in e?W[e.$$typeof]:Y;var t}var X=Object.defineProperty,Z=Object.getOwnPropertyNames,J=Object.getOwnPropertySymbols,K=Object.getOwnPropertyDescriptor,Q=Object.getPrototypeOf,ee=Object.prototype;function te(e,t,n){if("string"!=typeof t){if(ee){var o=Q(t);o&&o!==ee&&te(e,o,n)}var r=Z(t);J&&(r=r.concat(J(t)));for(var s=U(e),i=U(t),a=0;a<r.length;++a){var c=r[a];if(!(c in q||n&&n[c]||i&&c in i||s&&c in s)){var l=K(t,c);try{X(e,c,l)}catch(e){}}}}return e}function ne(e){return"function"==typeof e}function oe(e){return"object"==typeof e&&"styledComponentId"in e}function re(e,t){return e&&t?"".concat(e," ").concat(t):e||t||""}function se(e,t){if(0===e.length)return"";for(var n=e[0],o=1;o<e.length;o++)n+=e[o];return n}function ie(e){return null!==e&&"object"==typeof e&&e.constructor.name===Object.name&&!("props"in e&&e.$$typeof)}function ae(e,t,n){if(void 0===n&&(n=!1),!n&&!ie(e)&&!Array.isArray(e))return t;if(Array.isArray(t))for(var o=0;o<t.length;o++)e[o]=ae(e[o],t[o]);else if(ie(t))for(var o in t)e[o]=ae(e[o],t[o]);return e}function ce(e,t){Object.defineProperty(e,"toString",{value:t})}var le="production"!==process.env.NODE_ENV?{1:"Cannot create styled-component for component: %s.\n\n",2:"Can't collect styles once you've consumed a `ServerStyleSheet`'s styles! `ServerStyleSheet` is a one off instance for each server-side render cycle.\n\n- Are you trying to reuse it across renders?\n- Are you accidentally calling collectStyles twice?\n\n",3:"Streaming SSR is only supported in a Node.js environment; Please do not try to call this method in the browser.\n\n",4:"The `StyleSheetManager` expects a valid target or sheet prop!\n\n- Does this error occur on the client and is your target falsy?\n- Does this error occur on the server and is the sheet falsy?\n\n",5:"The clone method cannot be used on the client!\n\n- Are you running in a client-like environment on the server?\n- Are you trying to run SSR on the client?\n\n",6:"Trying to insert a new style tag, but the given Node is unmounted!\n\n- Are you using a custom target that isn't mounted?\n- Does your document not have a valid head element?\n- Have you accidentally removed a style tag manually?\n\n",7:'ThemeProvider: Please return an object from your "theme" prop function, e.g.\n\n```js\ntheme={() => ({})}\n```\n\n',8:'ThemeProvider: Please make your "theme" prop an object.\n\n',9:"Missing document `<head>`\n\n",10:"Cannot find a StyleSheet instance. Usually this happens if there are multiple copies of styled-components loaded at once. Check out this issue for how to troubleshoot and fix the common cases where this situation can happen: https://github.com/styled-components/styled-components/issues/1941#issuecomment-417862021\n\n",11:"_This error was replaced with a dev-time warning, it will be deleted for v4 final._ [createGlobalStyle] received children which will not be rendered. Please use the component without passing children elements.\n\n",12:"It seems you are interpolating a keyframe declaration (%s) into an untagged string. This was supported in styled-components v3, but is not longer supported in v4 as keyframes are now injected on-demand. Please wrap your string in the css\\`\\` helper which ensures the styles are injected correctly. See https://www.styled-components.com/docs/api#css\n\n",13:"%s is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.\n\n",14:'ThemeProvider: "theme" prop is required.\n\n',15:"A stylis plugin has been supplied that is not named. We need a name for each plugin to be able to prevent styling collisions between different stylis configurations within the same app. Before you pass your plugin to `<StyleSheetManager stylisPlugins={[]}>`, please make sure each plugin is uniquely-named, e.g.\n\n```js\nObject.defineProperty(importedPlugin, 'name', { value: 'some-unique-name' });\n```\n\n",16:"Reached the limit of how many styled components may be created at group %s.\nYou may only create up to 1,073,741,824 components. If you're creating components dynamically,\nas for instance in your render method then you may be running into this limitation.\n\n",17:"CSSStyleSheet could not be found on HTMLStyleElement.\nHas styled-components' style tag been unmounted or altered by another script?\n",18:"ThemeProvider: Please make sure your useTheme hook is within a `<ThemeProvider>`"}:{};function ue(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var n=e[0],o=[],r=1,s=e.length;r<s;r+=1)o.push(e[r]);return o.forEach(function(e){n=n.replace(/%[a-z]/,e)}),n}function pe(t){for(var n=[],o=1;o<arguments.length;o++)n[o-1]=arguments[o];return"production"===process.env.NODE_ENV?new Error("An error occurred. See https://github.com/styled-components/styled-components/blob/main/packages/styled-components/src/utils/errors.md#".concat(t," for more information.").concat(n.length>0?" Args: ".concat(n.join(", ")):"")):new Error(ue.apply(void 0,e([le[t]],n,!1)).trim())}var de=function(){function e(e){this.groupSizes=new Uint32Array(512),this.length=512,this.tag=e}return e.prototype.indexOfGroup=function(e){for(var t=0,n=0;n<e;n++)t+=this.groupSizes[n];return t},e.prototype.insertRules=function(e,t){if(e>=this.groupSizes.length){for(var n=this.groupSizes,o=n.length,r=o;e>=r;)if((r<<=1)<0)throw pe(16,"".concat(e));this.groupSizes=new Uint32Array(r),this.groupSizes.set(n),this.length=r;for(var s=o;s<r;s++)this.groupSizes[s]=0}for(var i=this.indexOfGroup(e+1),a=(s=0,t.length);s<a;s++)this.tag.insertRule(i,t[s])&&(this.groupSizes[e]++,i++)},e.prototype.clearGroup=function(e){if(e<this.length){var t=this.groupSizes[e],n=this.indexOfGroup(e),o=n+t;this.groupSizes[e]=0;for(var r=n;r<o;r++)this.tag.deleteRule(n)}},e.prototype.getGroup=function(e){var t="";if(e>=this.length||0===this.groupSizes[e])return t;for(var n=this.groupSizes[e],o=this.indexOfGroup(e),r=o+n,s=o;s<r;s++)t+="".concat(this.tag.getRule(s)).concat(w);return t},e}(),he=1<<30,fe=new Map,me=new Map,ye=1,ve=function(e){if(fe.has(e))return fe.get(e);for(;me.has(ye);)ye++;var t=ye++;if("production"!==process.env.NODE_ENV&&((0|t)<0||t>he))throw pe(16,"".concat(t));return fe.set(e,t),me.set(t,e),t},ge=function(e,t){ye=t+1,fe.set(e,t),me.set(t,e)},Se="style[".concat(y,"][").concat(g,'="').concat(S,'"]'),we=new RegExp("^".concat(y,'\\.g(\\d+)\\[id="([\\w\\d-]+)"\\].*?"([^"]*)')),be=function(e,t,n){for(var o,r=n.split(","),s=0,i=r.length;s<i;s++)(o=r[s])&&e.registerName(t,o)},Ee=function(e,t){for(var n,o=(null!==(n=t.textContent)&&void 0!==n?n:"").split(w),r=[],s=0,i=o.length;s<i;s++){var a=o[s].trim();if(a){var c=a.match(we);if(c){var l=0|parseInt(c[1],10),u=c[2];0!==l&&(ge(u,l),be(e,u,c[3]),e.getTag().insertRules(l,r)),r.length=0}else r.push(a)}}},Ne=function(e){for(var t=document.querySelectorAll(Se),n=0,o=t.length;n<o;n++){var r=t[n];r&&r.getAttribute(y)!==v&&(Ee(e,r),r.parentNode&&r.parentNode.removeChild(r))}};var _e=function(e){var t=document.head,n=e||t,o=document.createElement("style"),r=function(e){var t=Array.from(e.querySelectorAll("style[".concat(y,"]")));return t[t.length-1]}(n),s=void 0!==r?r.nextSibling:null;o.setAttribute(y,v),o.setAttribute(g,S);var i="undefined"!=typeof __webpack_nonce__?__webpack_nonce__:null;return i&&o.setAttribute("nonce",i),n.insertBefore(o,s),o},Ce=function(){function e(e){this.element=_e(e),this.element.appendChild(document.createTextNode("")),this.sheet=function(e){if(e.sheet)return e.sheet;for(var t=document.styleSheets,n=0,o=t.length;n<o;n++){var r=t[n];if(r.ownerNode===e)return r}throw pe(17)}(this.element),this.length=0}return e.prototype.insertRule=function(e,t){try{return this.sheet.insertRule(t,e),this.length++,!0}catch(e){return!1}},e.prototype.deleteRule=function(e){this.sheet.deleteRule(e),this.length--},e.prototype.getRule=function(e){var t=this.sheet.cssRules[e];return t&&t.cssText?t.cssText:""},e}(),Ae=function(){function e(e){this.element=_e(e),this.nodes=this.element.childNodes,this.length=0}return e.prototype.insertRule=function(e,t){if(e<=this.length&&e>=0){var n=document.createTextNode(t);return this.element.insertBefore(n,this.nodes[e]||null),this.length++,!0}return!1},e.prototype.deleteRule=function(e){this.element.removeChild(this.nodes[e]),this.length--},e.prototype.getRule=function(e){return e<this.length?this.nodes[e].textContent:""},e}(),Pe=function(){function e(e){this.rules=[],this.length=0}return e.prototype.insertRule=function(e,t){return e<=this.length&&(this.rules.splice(e,0,t),this.length++,!0)},e.prototype.deleteRule=function(e){this.rules.splice(e,1),this.length--},e.prototype.getRule=function(e){return e<this.length?this.rules[e]:""},e}(),Ie=b,De={isServer:!b,useCSSOMInjection:!E},Re=function(){function e(e,n,o){void 0===e&&(e=P),void 0===n&&(n={});var r=this;this.options=t(t({},De),e),this.gs=n,this.names=new Map(o),this.server=!!e.isServer,!this.server&&b&&Ie&&(Ie=!1,Ne(this)),ce(this,function(){return function(e){for(var t=e.getTag(),n=t.length,o="",r=function(n){var r=function(e){return me.get(e)}(n);if(void 0===r)return"continue";var s=e.names.get(r),i=t.getGroup(n);if(void 0===s||!s.size||0===i.length)return"continue";var a="".concat(y,".g").concat(n,'[id="').concat(r,'"]'),c="";void 0!==s&&s.forEach(function(e){e.length>0&&(c+="".concat(e,","))}),o+="".concat(i).concat(a,'{content:"').concat(c,'"}').concat(w)},s=0;s<n;s++)r(s);return o}(r)})}return e.registerId=function(e){return ve(e)},e.prototype.rehydrate=function(){!this.server&&b&&Ne(this)},e.prototype.reconstructWithOptions=function(n,o){return void 0===o&&(o=!0),new e(t(t({},this.options),n),this.gs,o&&this.names||void 0)},e.prototype.allocateGSInstance=function(e){return this.gs[e]=(this.gs[e]||0)+1},e.prototype.getTag=function(){return this.tag||(this.tag=(e=function(e){var t=e.useCSSOMInjection,n=e.target;return e.isServer?new Pe(n):t?new Ce(n):new Ae(n)}(this.options),new de(e)));var e},e.prototype.hasNameForId=function(e,t){return this.names.has(e)&&this.names.get(e).has(t)},e.prototype.registerName=function(e,t){if(ve(e),this.names.has(e))this.names.get(e).add(t);else{var n=new Set;n.add(t),this.names.set(e,n)}},e.prototype.insertRules=function(e,t,n){this.registerName(e,t),this.getTag().insertRules(ve(e),n)},e.prototype.clearNames=function(e){this.names.has(e)&&this.names.get(e).clear()},e.prototype.clearRules=function(e){this.getTag().clearGroup(ve(e)),this.clearNames(e)},e.prototype.clearTag=function(){this.tag=void 0},e}(),Oe=/&/g,Te=/^\s*\/\/.*$/gm;function je(e,t){return e.map(function(e){return"rule"===e.type&&(e.value="".concat(t," ").concat(e.value),e.value=e.value.replaceAll(",",",".concat(t," ")),e.props=e.props.map(function(e){return"".concat(t," ").concat(e)})),Array.isArray(e.children)&&"@keyframes"!==e.type&&(e.children=je(e.children,t)),e})}var ke=new Re,xe=function(){var e,t,n,o=P,r=o.options,s=void 0===r?P:r,i=o.plugins,a=void 0===i?A:i,c=function(n,o,r){return r.startsWith(t)&&r.endsWith(t)&&r.replaceAll(t,"").length>0?".".concat(e):n},y=a.slice();y.push(function(e){e.type===l&&e.value.includes("&")&&(e.props[0]=e.props[0].replace(Oe,t).replace(n,c))}),s.prefix&&y.push(u),y.push(h);var v=function(o,r,i,a){void 0===r&&(r=""),void 0===i&&(i=""),void 0===a&&(a="&"),e=a,t=r,n=new RegExp("\\".concat(t,"\\b"),"g");var c=o.replace(Te,""),l=m(i||r?"".concat(i," ").concat(r," { ").concat(c," }"):c);s.namespace&&(l=je(l,s.namespace));var u=[];return f(l,p(y.concat(d(function(e){return u.push(e)})))),u};return v.hash=a.length?a.reduce(function(e,t){return t.name||pe(15),z(e,t.name)},5381).toString():"",v}(),ze=o.createContext({shouldForwardProp:void 0,styleSheet:ke,stylis:xe});function Ve(){return a(ze)}ze.Consumer,o.createContext(void 0);var $e=function(){function e(e,t){var n=this;this.inject=function(e,t){void 0===t&&(t=xe);var o=n.name+t.hash;e.hasNameForId(n.id,o)||e.insertRules(n.id,o,t(n.rules,o,"@keyframes"))},this.name=e,this.id="sc-keyframes-".concat(e),this.rules=t,ce(this,function(){throw pe(12,String(n.name))})}return e.prototype.getName=function(e){return void 0===e&&(e=xe),this.name+e.hash},e}(),Fe=function(e){return e>="A"&&e<="Z"};function Be(e){for(var t="",n=0;n<e.length;n++){var o=e[n];if(1===n&&"-"===o&&"-"===e[0])return e;Fe(o)?t+="-"+o.toLowerCase():t+=o}return t.startsWith("ms-")?"-"+t:t}var Me=function(e){return null==e||!1===e||""===e},Le=function(t){var n,o,r=[];for(var s in t){var i=t[s];t.hasOwnProperty(s)&&!Me(i)&&(Array.isArray(i)&&i.isCss||ne(i)?r.push("".concat(Be(s),":"),i,";"):ie(i)?r.push.apply(r,e(e(["".concat(s," {")],Le(i),!1),["}"],!1)):r.push("".concat(Be(s),": ").concat((n=s,null==(o=i)||"boolean"==typeof o||""===o?"":"number"!=typeof o||0===o||n in c||n.startsWith("--")?String(o).trim():"".concat(o,"px")),";")))}return r};function Ge(e,t,n,o){if(Me(e))return[];if(oe(e))return[".".concat(e.styledComponentId)];if(ne(e)){if(!ne(s=e)||s.prototype&&s.prototype.isReactComponent||!t)return[e];var r=e(t);return"production"===process.env.NODE_ENV||"object"!=typeof r||Array.isArray(r)||r instanceof $e||ie(r)||null===r||console.error("".concat(F(e)," is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.")),Ge(r,t,n,o)}var s;return e instanceof $e?n?(e.inject(n,o),[e.getName(o)]):[e]:ie(e)?Le(e):Array.isArray(e)?Array.prototype.concat.apply(A,e.map(function(e){return Ge(e,t,n,o)})):[e.toString()]}var Ye=V(S),qe=function(){function e(e,t,n){this.rules=e,this.staticRulesId="",this.isStatic="production"===process.env.NODE_ENV&&(void 0===n||n.isStatic)&&function(e){for(var t=0;t<e.length;t+=1){var n=e[t];if(ne(n)&&!oe(n))return!1}return!0}(e),this.componentId=t,this.baseHash=z(Ye,t),this.baseStyle=n,Re.registerId(t)}return e.prototype.generateAndInjectStyles=function(e,t,n){var o=this.baseStyle?this.baseStyle.generateAndInjectStyles(e,t,n):"";if(this.isStatic&&!n.hash)if(this.staticRulesId&&t.hasNameForId(this.componentId,this.staticRulesId))o=re(o,this.staticRulesId);else{var r=se(Ge(this.rules,e,t,n)),s=k(z(this.baseHash,r)>>>0);if(!t.hasNameForId(this.componentId,s)){var i=n(r,".".concat(s),void 0,this.componentId);t.insertRules(this.componentId,s,i)}o=re(o,s),this.staticRulesId=s}else{for(var a=z(this.baseHash,n.hash),c="",l=0;l<this.rules.length;l++){var u=this.rules[l];if("string"==typeof u)c+=u,"production"!==process.env.NODE_ENV&&(a=z(a,u));else if(u){var p=se(Ge(u,e,t,n));a=z(a,p+l),c+=p}}if(c){var d=k(a>>>0);t.hasNameForId(this.componentId,d)||t.insertRules(this.componentId,d,n(c,".".concat(d),void 0,this.componentId)),o=re(o,d)}}return o},e}(),He=o.createContext(void 0);He.Consumer;var We={},Ue=new Set;function Xe(e,i,a){var c=oe(e),l=e,u=!B(e),p=i.attrs,d=void 0===p?A:p,h=i.componentId,f=void 0===h?function(e,t){var n="string"!=typeof e?"sc":O(e);We[n]=(We[n]||0)+1;var o="".concat(n,"-").concat($(S+n+We[n]));return t?"".concat(t,"-").concat(o):o}(i.displayName,i.parentComponentId):h,m=i.displayName,y=void 0===m?function(e){return B(e)?"styled.".concat(e):"Styled(".concat(F(e),")")}(e):m,v=i.displayName&&i.componentId?"".concat(O(i.displayName),"-").concat(i.componentId):i.componentId||f,g=c&&l.attrs?l.attrs.concat(d).filter(Boolean):d,w=i.shouldForwardProp;if(c&&l.shouldForwardProp){var b=l.shouldForwardProp;if(i.shouldForwardProp){var E=i.shouldForwardProp;w=function(e,t){return b(e,t)&&E(e,t)}}else w=b}var N=new qe(a,v,c?l.componentStyle:void 0);function _(e,i){return function(e,i,a){var c=e.attrs,l=e.componentStyle,u=e.defaultProps,p=e.foldedComponentIds,d=e.styledComponentId,h=e.target,f=o.useContext(He),m=Ve(),y=e.shouldForwardProp||m.shouldForwardProp;"production"!==process.env.NODE_ENV&&r(d);var v=function(e,t,n){return void 0===n&&(n=P),e.theme!==n.theme&&e.theme||t||n.theme}(i,f,u)||P,g=function(e,n,o){for(var r,s=t(t({},n),{className:void 0,theme:o}),i=0;i<e.length;i+=1){var a=ne(r=e[i])?r(s):r;for(var c in a)s[c]="className"===c?re(s[c],a[c]):"style"===c?t(t({},s[c]),a[c]):a[c]}return n.className&&(s.className=re(s.className,n.className)),s}(c,i,v),S=g.as||h,w={};for(var b in g)void 0===g[b]||"$"===b[0]||"as"===b||"theme"===b&&g.theme===v||("forwardedAs"===b?w.as=g.forwardedAs:y&&!y(b,S)||(w[b]=g[b],y||"development"!==process.env.NODE_ENV||n(b)||Ue.has(b)||!I.has(S)||(Ue.add(b),console.warn('styled-components: it looks like an unknown prop "'.concat(b,'" is being sent through to the DOM, which will likely trigger a React console error. If you would like automatic filtering of unknown props, you can opt-into that behavior via `<StyleSheetManager shouldForwardProp={...}>` (connect an API like `@emotion/is-prop-valid`) or consider using transient props (`$` prefix for automatic filtering.)')))));var E=function(e,t){var n=Ve(),o=e.generateAndInjectStyles(t,n.styleSheet,n.stylis);return"production"!==process.env.NODE_ENV&&r(o),o}(l,g);"production"!==process.env.NODE_ENV&&e.warnTooManyClasses&&e.warnTooManyClasses(E);var N=re(p,d);return E&&(N+=" "+E),g.className&&(N+=" "+g.className),w[B(S)&&!I.has(S)?"class":"className"]=N,a&&(w.ref=a),s(S,w)}(D,e,i)}_.displayName=y;var D=o.forwardRef(_);return D.attrs=g,D.componentStyle=N,D.displayName=y,D.shouldForwardProp=w,D.foldedComponentIds=c?re(l.foldedComponentIds,l.styledComponentId):"",D.styledComponentId=v,D.target=c?l.target:e,Object.defineProperty(D,"defaultProps",{get:function(){return this._foldedDefaultProps},set:function(e){this._foldedDefaultProps=c?function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];for(var o=0,r=t;o<r.length;o++)ae(e,r[o],!0);return e}({},l.defaultProps,e):e}}),"production"!==process.env.NODE_ENV&&(C(y,v),D.warnTooManyClasses=function(e,t){var n={},o=!1;return function(r){if(!o&&(n[r]=!0,Object.keys(n).length>=200)){var s=t?' with the id of "'.concat(t,'"'):"";console.warn("Over ".concat(200," classes were generated for component ").concat(e).concat(s,".\n")+"Consider using the attrs method, together with a style object for frequently changed styles.\nExample:\n  const Component = styled.div.attrs(props => ({\n    style: {\n      background: props.background,\n    },\n  }))`width: 100%;`\n\n  <Component />"),o=!0,n={}}}}(y,v)),ce(D,function(){return".".concat(D.styledComponentId)}),u&&te(D,e,{attrs:!0,componentStyle:!0,displayName:!0,foldedComponentIds:!0,shouldForwardProp:!0,styledComponentId:!0,target:!0}),D}function Ze(e,t){for(var n=[e[0]],o=0,r=t.length;o<r;o+=1)n.push(t[o],e[o+1]);return n}var Je=function(e){return Object.assign(e,{isCss:!0})};function Ke(t){for(var n=[],o=1;o<arguments.length;o++)n[o-1]=arguments[o];if(ne(t)||ie(t))return Je(Ge(Ze(A,e([t],n,!0))));var r=t;return 0===n.length&&1===r.length&&"string"==typeof r[0]?Ge(r):Je(Ge(Ze(r,n)))}function Qe(n,o,r){if(void 0===r&&(r=P),!o)throw pe(1,o);var s=function(t){for(var s=[],i=1;i<arguments.length;i++)s[i-1]=arguments[i];return n(o,r,Ke.apply(void 0,e([t],s,!1)))};return s.attrs=function(e){return Qe(n,o,t(t({},r),{attrs:Array.prototype.concat(r.attrs,e).filter(Boolean)}))},s.withConfig=function(e){return Qe(n,o,t(t({},r),e))},s}var et=function(e){return Qe(Xe,e)},tt=et;function nt(t){for(var n=[],o=1;o<arguments.length;o++)n[o-1]=arguments[o];"production"!==process.env.NODE_ENV&&"undefined"!=typeof navigator&&"ReactNative"===navigator.product&&console.warn("`keyframes` cannot be used on ReactNative, only on the web. To do animation in ReactNative please use Animated.");var r=se(Ke.apply(void 0,e([t],n,!1))),s=$(r);return new $e(s,r)}I.forEach(function(e){tt[e]=et(e)}),"production"!==process.env.NODE_ENV&&"undefined"!=typeof navigator&&"ReactNative"===navigator.product&&console.warn("It looks like you've imported 'styled-components' on React Native.\nPerhaps you're looking to import 'styled-components/native'?\nRead more about this at https://www.styled-components.com/docs/basics#react-native");var ot="__sc-".concat(y,"__");"production"!==process.env.NODE_ENV&&"test"!==process.env.NODE_ENV&&"undefined"!=typeof window&&(window[ot]||(window[ot]=0),1===window[ot]&&console.warn("It looks like there are several instances of 'styled-components' initialized in this application. This may cause dynamic styles to not render properly, errors during the rehydration process, a missing theme prop, and makes your application bigger without good reason.\n\nSee https://s-c.sh/2BAXzed for more info."),window[ot]+=1);export{ze as StyleSheetContext,He as ThemeContext,Ke as css,tt as default,oe as isStyledComponent,nt as keyframes,tt as styled,S as version};
+//# sourceMappingURL=styled-components.browser.esm.js.map