@tempoxyz/id 0.0.0-stage → 0.0.1

package/dist/app/server/assets/Authentication-BOkhlNQu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Authentication-BOkhlNQu.js","names":["sha256","sha256n","noble_keccak256","Bytes.from","Hex.fromBytes","noble_sha256","Hex.validate","assert","from","Hex.validate","fromHex","Bytes.validate","fromBytes","Hex.fromBytes","InvalidSerializedSizeError","Hex.slice","toBytes","Bytes.fromHex","toHex","Hex.concat","Hex.fromNumber","Errors.BaseError","Json.stringify","Hex.size","Hex.from","create","Errors.BaseError","Solidity.maxUint256","fromBytes","Hex.fromBytes","Hex.slice","Hex.from","toHex","Hex.concat","Hex.fromNumber","Hex.trimLeft","Errors.BaseError","Hex.size","Json.stringify","Bytes.fromString","Hex.fromBytes","Bytes.toString","Cursor.create","Hex.fromBytes","Hex.InvalidLengthError","Bytes.fromHex","Errors.BaseError","Bytes.fromString","Bytes.toString","PublicKey.toBytes","Cbor.encode","Cbor.decode","PublicKey.from","Errors.BaseError","p256","sha256","p256n","verify","Bytes.fromHex","PublicKey.toHex","Errors.BaseError","Bytes.fromString","Base64.fromBytes","Base64.toBytes","getOptions","internal.parseCredentialPublicKey","Bytes.fromHex","Base64.toBytes","Hash.keccak256","Bytes.fromString","serializeResponse","Base64.fromBytes","PublicKey.toHex","serializeOptions","Hex.fromBytes","deserializeOptions","verify","Bytes.toString","Cbor.decode","Hash.sha256","Hex.fromString","Bytes.isEqual","CoseKey.toPublicKey","CoseKey.fromPublicKey","Bytes.concat","Signature.fromDerBytes","P256.verify","Errors.BaseError","Registration.CreateFailedError","PublicKey.from","Bytes.fromHex","Base64.toBytes","Signature.from","Hex.fromBytes","Base64.fromBytes","Signature.toHex","internal.parseAsn1Signature","Errors.BaseError","Hash.sha256","Hex.fromString","Bytes.isEqual","Bytes.fromString","Bytes.concat","P256.verify","fromString$2","validate$1","stringify","keccak_256","size","trimLeft","BaseError","fromNumber","isEqual","toString$1","InvalidLengthError","fromString$1","slice","validate$2","from$2","fromHex$2","concat$1","concat","fromBytes$3","from$3","sha256$2","Field","sha384","createCurve","sha512","secp256k1","sha256$1","keccak256","value","options","bytes","as","sha256","validate","assert$1","publicKey","compressed","x","y","prefix","InvalidPrefixError","InvalidUncompressedPrefixError","InvalidCompressedPrefixError","InvalidError","from$1","fromHex$1","fromBytes$2","InvalidSerializedSizeError$1","toBytes$1","toHex$2","includePrefix","staticCursor","RecursiveReadLimitExceededError","position","PositionOutOfBoundsError","offset","NegativeOffsetError","position_","length","byte","oldPosition","count","create$1","cursor","recursiveReadLimit","limit","arrayRegex","bytesRegex","integerRegex","maxUint256","assert","signature","recovered","MissingPropertiesError","InvalidRError","InvalidSError","InvalidYParityError","fromBytes$1","fromHex","InvalidSerializedSizeError","r","s","yParity","vToYParity","extract","from","signature_","fromRpc","fromLegacy","fromDerBytes","fromDerHex","v","fromTuple","tuple","toHex$1","yParityToV","toRpc","toTuple","InvalidVError","encoder","decoder","integerToCharacter","i","a","characterToInteger","fromBytes","encoded","j","k","end","base64","pad","url","fromString","toBytes","decoded","decodedSize","toHex","toString","encode","encodable","getEncodable","data","decode","decodeCursor","InvalidMajorTypeError","majorType","InvalidAdditionalInfoError","additionalInfo","Unsupported64BitIntegerError","UnsupportedTagError","tag","InvalidIndefiniteLengthChunkError","type","InvalidSimpleValueError","UnsupportedBigIntError","UnexpectedTokenError","token","NumberTooLargeError","number","StringTooLargeError","ArrayTooLargeError","ObjectTooLargeError","ByteStringTooLargeError","float32","positiveNumber","string","array","items","item","bodyLength","acc","byteString","object","keys","entries","key","entry","map","initialByte","readLength","readUnsignedInteger","readNegativeInteger","readByteString","chunks","totalLength","chunk","result","readTextString","readArray","readMap","keyStr","readSimpleOrFloat","getFloat16","simpleValue","sign","bits","exponent","fraction","fromPublicKey","pkBytes","toPublicKey","coseKey","InvalidCoseKeyError","Fp256","p256_a","p256$1","Fp384","p384_a","Fp521","p521_a","p256","secp256r1","noble","verify$2","payload","hash","base64UrlOptions","responseKeys","bytesToArrayBuffer","bufferSourceToBytes","source","serializeExtensions","rest","extensions","prf","deserializeExtensions","createChallenge","create","opts","creationOptions","getOptions$1","credential","createFn","CreateFailedError","response","attestationObject","parseCredentialPublicKey","error","name_","name","user","challenge","excludeCredentialIds","id","serializeResponse$1","rawResponse","fn","serializeOptions$1","excludeCredentials","deserializeOptions$1","verify$1","clientDataJSONBytes","clientDataJSON","clientData","VerifyError","origin","attestation_","authData","rpIdHash","expectedRpIdHash","rpId","flags","up","uv","at","be","bs","userVerification","counter","credIdLen","credentialId","expectedId","ed","coseKeyBytes","coseKeyHex","coseKeyData","expectedCoseKeyLen","trailingBytes","clientDataHash","verificationData","fmt","attestation","sig","attStmt","alg","raw","parseAsn1Signature","publicKeyBuffer","publicKeyBytes","cryptoKey","findStart","coordinate","xStart","yStart","deserializeOptions","publicKeyRest","allowCredentials","deserializeResponse","getOptions","serializeOptions","_","serializeResponse","requestOptions","getFn","SignFailedError","authenticatorDataBytes","signatureBytes","challengeIndex","typeIndex","verify","metadata","authenticatorData","flag","userVerificationRequired","clientDataJSONHash"],"sources":["../../../../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/Hash.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/PublicKey.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/internal/cursor.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/Solidity.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/Signature.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/Base64.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/Cbor.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/CoseKey.js","../../../../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/nist.js","../../../../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/p256.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/P256.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/webauthn/internal/utils.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/webauthn/Registration.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/core/internal/webauthn.js","../../../../../node_modules/.pnpm/ox@0.14.59_typescript@7.0.2_zod@4.6.7/node_modules/ox/_esm/webauthn/Authentication.js"],"sourcesContent":["/**\n * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.\n *\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n *\n * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n * @deprecated\n */\nimport { SHA224 as SHA224n, sha224 as sha224n, SHA256 as SHA256n, sha256 as sha256n, } from \"./sha2.js\";\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA256 = SHA256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha256 = sha256n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const SHA224 = SHA224n;\n/** @deprecated Use import from `noble/hashes/sha2` module */\nexport const sha224 = sha224n;\n//# sourceMappingURL=sha256.js.map","import { hmac } from '@noble/hashes/hmac';\nimport { ripemd160 as noble_ripemd160 } from '@noble/hashes/ripemd160';\nimport { keccak_256 as noble_keccak256 } from '@noble/hashes/sha3';\nimport { sha256 as noble_sha256 } from '@noble/hashes/sha256';\nimport * as Bytes from './Bytes.js';\nimport * as Hex from './Hex.js';\n/**\n * Calculates the [Keccak256](https://en.wikipedia.org/wiki/SHA-3) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.keccak256('0xdeadbeef')\n * // @log: '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1'\n * ```\n *\n * @example\n * ### Calculate Hash of a String\n *\n * ```ts twoslash\n * import { Hash, Hex } from 'ox'\n *\n * Hash.keccak256(Hex.fromString('hello world'))\n * // @log: '0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0'\n * ```\n *\n * @example\n * ### Configure Return Type\n *\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.keccak256('0xdeadbeef', { as: 'Bytes' })\n * // @log: Uint8Array [...]\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns Keccak256 hash.\n */\nexport function keccak256(value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = noble_keccak256(Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Calculates the [HMAC-SHA256](https://en.wikipedia.org/wiki/HMAC) of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `hmac` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash, Hex } from 'ox'\n *\n * Hash.hmac256(Hex.fromString('key'), '0xdeadbeef')\n * // @log: '0x...'\n * ```\n *\n * @example\n * ### Configure Return Type\n *\n * ```ts twoslash\n * import { Hash, Hex } from 'ox'\n *\n * Hash.hmac256(Hex.fromString('key'), '0xdeadbeef', { as: 'Bytes' })\n * // @log: Uint8Array [...]\n * ```\n *\n * @param key - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} key.\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns HMAC-SHA256 hash.\n */\nexport function hmac256(key, value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = hmac(noble_sha256, Bytes.from(key), Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Calculates the [Ripemd160](https://en.wikipedia.org/wiki/RIPEMD) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `ripemd160` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.ripemd160('0xdeadbeef')\n * // '0x226821c2f5423e11fe9af68bd285c249db2e4b5a'\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns Ripemd160 hash.\n */\nexport function ripemd160(value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = noble_ripemd160(Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Calculates the [Sha256](https://en.wikipedia.org/wiki/SHA-256) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `sha256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.sha256('0xdeadbeef')\n * // '0x5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953'\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns Sha256 hash.\n */\nexport function sha256(value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = noble_sha256(Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Checks if a string is a valid hash value.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.validate('0x')\n * // @log: false\n *\n * Hash.validate('0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0')\n * // @log: true\n * ```\n *\n * @param value - Value to check.\n * @returns Whether the value is a valid hash.\n */\nexport function validate(value) {\n    return value.length === 66 && Hex.validate(value, { strict: true });\n}\n//# sourceMappingURL=Hash.js.map","import * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as Json from './Json.js';\n/**\n * Asserts that a {@link ox#PublicKey.PublicKey} is valid.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * PublicKey.assert({\n *   prefix: 4,\n *   y: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * })\n * // @error: PublicKey.InvalidError: Value \\`{\"y\":\"1\"}\\` is not a valid public key.\n * // @error: Public key must contain:\n * // @error: - an `x` and `prefix` value (compressed)\n * // @error: - an `x`, `y`, and `prefix` value (uncompressed)\n * ```\n *\n * @param publicKey - The public key object to assert.\n */\nexport function assert(publicKey, options = {}) {\n    const { compressed } = options;\n    const { prefix, x, y } = publicKey;\n    // Uncompressed\n    if (compressed === false ||\n        (typeof x === 'bigint' && typeof y === 'bigint')) {\n        if (prefix !== 4)\n            throw new InvalidPrefixError({\n                prefix,\n                cause: new InvalidUncompressedPrefixError(),\n            });\n        return;\n    }\n    // Compressed\n    if (compressed === true ||\n        (typeof x === 'bigint' && typeof y === 'undefined')) {\n        if (prefix !== 3 && prefix !== 2)\n            throw new InvalidPrefixError({\n                prefix,\n                cause: new InvalidCompressedPrefixError(),\n            });\n        return;\n    }\n    // Unknown/invalid\n    throw new InvalidError({ publicKey });\n}\n/**\n * Compresses a {@link ox#PublicKey.PublicKey}.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from({\n *   prefix: 4,\n *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * })\n *\n * const compressed = PublicKey.compress(publicKey) // [!code focus]\n * // @log: {\n * // @log:   prefix: 3,\n * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n * // @log: }\n * ```\n *\n * @param publicKey - The public key to compress.\n * @returns The compressed public key.\n */\nexport function compress(publicKey) {\n    const { x, y } = publicKey;\n    return {\n        prefix: y % 2n === 0n ? 2 : 3,\n        x,\n    };\n}\n/**\n * Instantiates a typed {@link ox#PublicKey.PublicKey} object from a {@link ox#PublicKey.PublicKey}, {@link ox#Bytes.Bytes}, or {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from({\n *   prefix: 4,\n *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * })\n * // @log: {\n * // @log:   prefix: 4,\n * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * // @log: }\n * ```\n *\n * @example\n * ### From Serialized\n *\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from('0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5')\n * // @log: {\n * // @log:   prefix: 4,\n * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * // @log: }\n * ```\n *\n * @param value - The public key value to instantiate.\n * @returns The instantiated {@link ox#PublicKey.PublicKey}.\n */\nexport function from(value) {\n    const publicKey = (() => {\n        if (Hex.validate(value))\n            return fromHex(value);\n        if (Bytes.validate(value))\n            return fromBytes(value);\n        const { prefix, x, y } = value;\n        if (typeof x === 'bigint' && typeof y === 'bigint')\n            return { prefix: prefix ?? 0x04, x, y };\n        return { prefix, x };\n    })();\n    assert(publicKey);\n    return publicKey;\n}\n/**\n * Deserializes a {@link ox#PublicKey.PublicKey} from a {@link ox#Bytes.Bytes} value.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.fromBytes(new Uint8Array([128, 3, 131, ...]))\n * // @log: {\n * // @log:   prefix: 4,\n * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * // @log: }\n * ```\n *\n * @param publicKey - The serialized public key.\n * @returns The deserialized public key.\n */\nexport function fromBytes(publicKey) {\n    return fromHex(Hex.fromBytes(publicKey));\n}\n/**\n * Deserializes a {@link ox#PublicKey.PublicKey} from a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.fromHex('0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5')\n * // @log: {\n * // @log:   prefix: 4,\n * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * // @log: }\n * ```\n *\n * @example\n * ### Deserializing a Compressed Public Key\n *\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.fromHex('0x038318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed75')\n * // @log: {\n * // @log:   prefix: 3,\n * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n * // @log: }\n * ```\n *\n * @param publicKey - The serialized public key.\n * @returns The deserialized public key.\n */\nexport function fromHex(publicKey) {\n    if (publicKey.length !== 132 &&\n        publicKey.length !== 130 &&\n        publicKey.length !== 68)\n        throw new InvalidSerializedSizeError({ publicKey });\n    if (publicKey.length === 130) {\n        const x = BigInt(Hex.slice(publicKey, 0, 32));\n        const y = BigInt(Hex.slice(publicKey, 32, 64));\n        return {\n            prefix: 4,\n            x,\n            y,\n        };\n    }\n    if (publicKey.length === 132) {\n        const prefix = Number(Hex.slice(publicKey, 0, 1));\n        const x = BigInt(Hex.slice(publicKey, 1, 33));\n        const y = BigInt(Hex.slice(publicKey, 33, 65));\n        return {\n            prefix,\n            x,\n            y,\n        };\n    }\n    const prefix = Number(Hex.slice(publicKey, 0, 1));\n    const x = BigInt(Hex.slice(publicKey, 1, 33));\n    return {\n        prefix,\n        x,\n    };\n}\n/**\n * Serializes a {@link ox#PublicKey.PublicKey} to {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from({\n *   prefix: 4,\n *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * })\n *\n * const bytes = PublicKey.toBytes(publicKey) // [!code focus]\n * // @log: Uint8Array [128, 3, 131, ...]\n * ```\n *\n * @param publicKey - The public key to serialize.\n * @returns The serialized public key.\n */\nexport function toBytes(publicKey, options = {}) {\n    return Bytes.fromHex(toHex(publicKey, options));\n}\n/**\n * Serializes a {@link ox#PublicKey.PublicKey} to {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from({\n *   prefix: 4,\n *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,\n *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,\n * })\n *\n * const hex = PublicKey.toHex(publicKey) // [!code focus]\n * // @log: '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5'\n * ```\n *\n * @param publicKey - The public key to serialize.\n * @returns The serialized public key.\n */\nexport function toHex(publicKey, options = {}) {\n    assert(publicKey);\n    const { prefix, x, y } = publicKey;\n    const { includePrefix = true } = options;\n    const publicKey_ = Hex.concat(includePrefix ? Hex.fromNumber(prefix, { size: 1 }) : '0x', Hex.fromNumber(x, { size: 32 }), \n    // If the public key is not compressed, add the y coordinate.\n    typeof y === 'bigint' ? Hex.fromNumber(y, { size: 32 }) : '0x');\n    return publicKey_;\n}\n/**\n * Validates a {@link ox#PublicKey.PublicKey}. Returns `true` if valid, `false` otherwise.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * const valid = PublicKey.validate({\n *   prefix: 4,\n *   y: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,\n * })\n * // @log: false\n * ```\n *\n * @param publicKey - The public key object to assert.\n */\nexport function validate(publicKey, options = {}) {\n    try {\n        assert(publicKey, options);\n        return true;\n    }\n    catch (_error) {\n        return false;\n    }\n}\n/**\n * Thrown when a public key is invalid.\n *\n * @example\n * ```ts twoslash\n * import { PublicKey } from 'ox'\n *\n * PublicKey.assert({ y: 1n })\n * // @error: PublicKey.InvalidError: Value `{\"y\":1n}` is not a valid public key.\n * // @error: Public key must contain:\n * // @error: - an `x` and `prefix` value (compressed)\n * // @error: - an `x`, `y`, and `prefix` value (uncompressed)\n * ```\n */\nexport class InvalidError extends Errors.BaseError {\n    constructor({ publicKey }) {\n        super(`Value \\`${Json.stringify(publicKey)}\\` is not a valid public key.`, {\n            metaMessages: [\n                'Public key must contain:',\n                '- an `x` and `prefix` value (compressed)',\n                '- an `x`, `y`, and `prefix` value (uncompressed)',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'PublicKey.InvalidError'\n        });\n    }\n}\n/** Thrown when a public key has an invalid prefix. */\nexport class InvalidPrefixError extends Errors.BaseError {\n    constructor({ prefix, cause }) {\n        super(`Prefix \"${prefix}\" is invalid.`, {\n            cause,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'PublicKey.InvalidPrefixError'\n        });\n    }\n}\n/** Thrown when the public key has an invalid prefix for a compressed public key. */\nexport class InvalidCompressedPrefixError extends Errors.BaseError {\n    constructor() {\n        super('Prefix must be 2 or 3 for compressed public keys.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'PublicKey.InvalidCompressedPrefixError'\n        });\n    }\n}\n/** Thrown when the public key has an invalid prefix for an uncompressed public key. */\nexport class InvalidUncompressedPrefixError extends Errors.BaseError {\n    constructor() {\n        super('Prefix must be 4 for uncompressed public keys.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'PublicKey.InvalidUncompressedPrefixError'\n        });\n    }\n}\n/** Thrown when the public key has an invalid serialized size. */\nexport class InvalidSerializedSizeError extends Errors.BaseError {\n    constructor({ publicKey }) {\n        super(`Value \\`${publicKey}\\` is an invalid public key size.`, {\n            metaMessages: [\n                'Expected: 33 bytes (compressed + prefix), 64 bytes (uncompressed) or 65 bytes (uncompressed + prefix).',\n                `Received ${Hex.size(Hex.from(publicKey))} bytes.`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'PublicKey.InvalidSerializedSizeError'\n        });\n    }\n}\n//# sourceMappingURL=PublicKey.js.map","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","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","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","import * as Bytes from './Bytes.js';\nimport * as Hex from './Hex.js';\nconst encoder = /*#__PURE__*/ new TextEncoder();\nconst decoder = /*#__PURE__*/ new TextDecoder();\nconst integerToCharacter = /*#__PURE__*/ Object.fromEntries(Array.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/').map((a, i) => [i, a.charCodeAt(0)]));\nconst characterToInteger = {\n    ...Object.fromEntries(Array.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/').map((a, i) => [a.charCodeAt(0), i])),\n    ['='.charCodeAt(0)]: 0,\n    ['-'.charCodeAt(0)]: 62,\n    ['_'.charCodeAt(0)]: 63,\n};\n/**\n * Encodes a {@link ox#Bytes.Bytes} to a Base64-encoded string (with optional padding and/or URL-safe characters).\n *\n * @example\n * ```ts twoslash\n * import { Base64, Bytes } from 'ox'\n *\n * const value = Base64.fromBytes(Bytes.fromString('hello world'))\n * // @log: 'aGVsbG8gd29ybGQ='\n * ```\n *\n * @example\n * ### No Padding\n *\n * Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:\n *\n * ```ts twoslash\n * import { Base64, Bytes } from 'ox'\n *\n * const value = Base64.fromBytes(Bytes.fromString('hello world'), { pad: false })\n * // @log: 'aGVsbG8gd29ybGQ'\n * ```\n *\n * ### URL-safe Encoding\n *\n * Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:\n *\n * ```ts twoslash\n * import { Base64, Bytes } from 'ox'\n *\n * const value = Base64.fromBytes(Bytes.fromString('hello wod'), { url: true })\n * // @log: 'aGVsbG8gd29_77-9ZA=='\n * ```\n *\n * @param value - The byte array to encode.\n * @param options - Encoding options.\n * @returns The Base64 encoded string.\n */\nexport function fromBytes(value, options = {}) {\n    const { pad = true, url = false } = options;\n    const encoded = new Uint8Array(Math.ceil(value.length / 3) * 4);\n    for (let i = 0, j = 0; j < value.length; i += 4, j += 3) {\n        const y = (value[j] << 16) + (value[j + 1] << 8) + (value[j + 2] | 0);\n        encoded[i] = integerToCharacter[y >> 18];\n        encoded[i + 1] = integerToCharacter[(y >> 12) & 0x3f];\n        encoded[i + 2] = integerToCharacter[(y >> 6) & 0x3f];\n        encoded[i + 3] = integerToCharacter[y & 0x3f];\n    }\n    const k = value.length % 3;\n    const end = Math.floor(value.length / 3) * 4 + (k && k + 1);\n    let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, end));\n    if (pad && k === 1)\n        base64 += '==';\n    if (pad && k === 2)\n        base64 += '=';\n    if (url)\n        base64 = base64.replaceAll('+', '-').replaceAll('/', '_');\n    return base64;\n}\n/**\n * Encodes a {@link ox#Hex.Hex} to a Base64-encoded string (with optional padding and/or URL-safe characters).\n *\n * @example\n * ```ts twoslash\n * import { Base64, Hex } from 'ox'\n *\n * const value = Base64.fromHex(Hex.fromString('hello world'))\n * // @log: 'aGVsbG8gd29ybGQ='\n * ```\n *\n * @example\n * ### No Padding\n *\n * Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:\n *\n * ```ts twoslash\n * import { Base64, Hex } from 'ox'\n *\n * const value = Base64.fromHex(Hex.fromString('hello world'), { pad: false })\n * // @log: 'aGVsbG8gd29ybGQ'\n * ```\n *\n * ### URL-safe Encoding\n *\n * Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:\n *\n * ```ts twoslash\n * import { Base64, Hex } from 'ox'\n *\n * const value = Base64.fromHex(Hex.fromString('hello wod'), { url: true })\n * // @log: 'aGVsbG8gd29_77-9ZA=='\n * ```\n *\n * @param value - The hex value to encode.\n * @param options - Encoding options.\n * @returns The Base64 encoded string.\n */\nexport function fromHex(value, options = {}) {\n    return fromBytes(Bytes.fromHex(value), options);\n}\n/**\n * Encodes a string to a Base64-encoded string (with optional padding and/or URL-safe characters).\n *\n * @example\n * ```ts twoslash\n * import { Base64 } from 'ox'\n *\n * const value = Base64.fromString('hello world')\n * // @log: 'aGVsbG8gd29ybGQ='\n * ```\n *\n * @example\n * ### No Padding\n *\n * Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:\n *\n * ```ts twoslash\n * import { Base64 } from 'ox'\n *\n * const value = Base64.fromString('hello world', { pad: false })\n * // @log: 'aGVsbG8gd29ybGQ'\n * ```\n *\n * ### URL-safe Encoding\n *\n * Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:\n *\n * ```ts twoslash\n * import { Base64 } from 'ox'\n *\n * const value = Base64.fromString('hello wod', { url: true })\n * // @log: 'aGVsbG8gd29_77-9ZA=='\n * ```\n *\n * @param value - The string to encode.\n * @param options - Encoding options.\n * @returns The Base64 encoded string.\n */\nexport function fromString(value, options = {}) {\n    return fromBytes(Bytes.fromString(value), options);\n}\n/**\n * Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Base64, Bytes } from 'ox'\n *\n * const value = Base64.toBytes('aGVsbG8gd29ybGQ=')\n * // @log: Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])\n * ```\n *\n * @param value - The string, hex value, or byte array to encode.\n * @returns The Base64 decoded {@link ox#Bytes.Bytes}.\n */\nexport function toBytes(value) {\n    const base64 = value.replace(/=+$/, '');\n    const size = base64.length;\n    const decoded = new Uint8Array(size + 3);\n    encoder.encodeInto(base64 + '===', decoded);\n    for (let i = 0, j = 0; i < base64.length; i += 4, j += 3) {\n        const x = (characterToInteger[decoded[i]] << 18) +\n            (characterToInteger[decoded[i + 1]] << 12) +\n            (characterToInteger[decoded[i + 2]] << 6) +\n            characterToInteger[decoded[i + 3]];\n        decoded[j] = x >> 16;\n        decoded[j + 1] = (x >> 8) & 0xff;\n        decoded[j + 2] = x & 0xff;\n    }\n    const decodedSize = (size >> 2) * 3 + (size % 4 && (size % 4) - 1);\n    return new Uint8Array(decoded.buffer, 0, decodedSize);\n}\n/**\n * Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Base64, Hex } from 'ox'\n *\n * const value = Base64.toHex('aGVsbG8gd29ybGQ=')\n * // @log: 0x68656c6c6f20776f726c64\n * ```\n *\n * @param value - The string, hex value, or byte array to encode.\n * @returns The Base64 decoded {@link ox#Hex.Hex}.\n */\nexport function toHex(value) {\n    return Hex.fromBytes(toBytes(value));\n}\n/**\n * Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to a string.\n *\n * @example\n * ```ts twoslash\n * import { Base64 } from 'ox'\n *\n * const value = Base64.toString('aGVsbG8gd29ybGQ=')\n * // @log: 'hello world'\n * ```\n *\n * @param value - The string, hex value, or byte array to encode.\n * @returns The Base64 decoded string.\n */\nexport function toString(value) {\n    return Bytes.toString(toBytes(value));\n}\n//# sourceMappingURL=Base64.js.map","import * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as Cursor from './internal/cursor.js';\n/**\n * Encodes a value into CBOR (Concise Binary Object Representation) format.\n *\n * @example\n * ```ts twoslash\n * import { Cbor } from 'ox'\n *\n * Cbor.encode([1, 2, 3])\n * // @log: '0x83010203'\n *\n * Cbor.encode({ foo: 'bar', baz: [1, 2, 3] })\n * // @log: '0xa263666f6f636261726362617a83010203'\n *\n * Cbor.encode('hello', { as: 'Bytes' })\n * // @log: Uint8Array(6) [ 101, 104, 101, 108, 108, 111 ]\n * ```\n *\n * @param data - The value to encode.\n * @param options - Encoding options.\n * @returns The CBOR-encoded value.\n */\nexport function encode(data, options = {}) {\n    const { as = 'Hex' } = options;\n    const encodable = getEncodable(data);\n    const cursor = Cursor.create(new Uint8Array(encodable.length));\n    encodable.encode(cursor);\n    if (as === 'Hex')\n        return Hex.fromBytes(cursor.bytes);\n    return cursor.bytes;\n}\n/**\n * Decodes CBOR (Concise Binary Object Representation) data into a JavaScript value.\n *\n * @example\n * ```ts twoslash\n * import { Cbor } from 'ox'\n *\n * Cbor.decode('0x83010203')\n * // @log: [1, 2, 3]\n *\n * Cbor.decode('0xa263666f6f636261726362617a83010203')\n * // @log: { foo: 'bar', baz: [1, 2, 3] }\n *\n * Cbor.decode(new Uint8Array([101, 104, 101, 108, 108, 111]))\n * // @log: 'hello'\n * ```\n *\n * @param data - The CBOR-encoded data to decode.\n * @param options - Decoding options.\n * @returns The decoded value.\n */\nexport function decode(data) {\n    const bytes = (() => {\n        if (typeof data === 'string') {\n            if (data.length > 3 && data.length % 2 !== 0)\n                throw new Hex.InvalidLengthError(data);\n            return Bytes.fromHex(data);\n        }\n        return data;\n    })();\n    const cursor = Cursor.create(bytes);\n    return decodeCursor(cursor);\n}\nexport class InvalidMajorTypeError extends Errors.BaseError {\n    constructor({ majorType }) {\n        super(`Invalid CBOR major type: ${majorType}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.InvalidMajorTypeError'\n        });\n    }\n}\nexport class InvalidAdditionalInfoError extends Errors.BaseError {\n    constructor({ additionalInfo }) {\n        super(`Invalid CBOR additional info: ${additionalInfo}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.InvalidAdditionalInfoError'\n        });\n    }\n}\nexport class Unsupported64BitIntegerError extends Errors.BaseError {\n    constructor() {\n        super('64-bit integers are not supported in CBOR decoding.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.Unsupported64BitIntegerError'\n        });\n    }\n}\nexport class UnsupportedTagError extends Errors.BaseError {\n    constructor({ tag }) {\n        super(`CBOR tagged data (tag ${tag}) is not yet supported.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.UnsupportedTagError'\n        });\n    }\n}\nexport class InvalidIndefiniteLengthChunkError extends Errors.BaseError {\n    constructor({ type }) {\n        super(`Invalid chunk type in indefinite-length ${type}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.InvalidIndefiniteLengthChunkError'\n        });\n    }\n}\nexport class InvalidSimpleValueError extends Errors.BaseError {\n    constructor({ value }) {\n        super(`Invalid CBOR simple value: ${value}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.InvalidSimpleValueError'\n        });\n    }\n}\nexport class UnsupportedBigIntError extends Errors.BaseError {\n    constructor() {\n        super('BigInt values are not supported in CBOR encoding.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.UnsupportedBigIntError'\n        });\n    }\n}\nexport class UnexpectedTokenError extends Errors.BaseError {\n    constructor({ token }) {\n        super(`Unexpected token: ${token}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.UnexpectedTokenError'\n        });\n    }\n}\nexport class NumberTooLargeError extends Errors.BaseError {\n    constructor({ number }) {\n        super(`Number exceeds maximum safe integer (${Number.MAX_SAFE_INTEGER}): ${number}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.NumberTooLargeError'\n        });\n    }\n}\nexport class StringTooLargeError extends Errors.BaseError {\n    constructor({ size }) {\n        super(`String length exceeds maximum (4294967295): ${size}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.StringTooLargeError'\n        });\n    }\n}\nexport class ArrayTooLargeError extends Errors.BaseError {\n    constructor({ size }) {\n        super(`Array length exceeds maximum (4294967295): ${size}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.ArrayTooLargeError'\n        });\n    }\n}\nexport class ObjectTooLargeError extends Errors.BaseError {\n    constructor({ size }) {\n        super(`Object size exceeds maximum (4294967295): ${size}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.ObjectTooLargeError'\n        });\n    }\n}\nexport class ByteStringTooLargeError extends Errors.BaseError {\n    constructor({ size }) {\n        super(`Byte string length exceeds maximum (4294967295): ${size}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Cbor.ByteStringTooLargeError'\n        });\n    }\n}\n/** @internal */\n// biome-ignore lint/correctness/noUnusedVariables: _\nfunction getEncodable(value) {\n    if (typeof value === 'undefined')\n        return { length: 1, encode: (cursor) => cursor.pushUint8(0xf7) };\n    if (value === null)\n        return { length: 1, encode: (cursor) => cursor.pushUint8(0xf6) };\n    if (typeof value === 'boolean')\n        return {\n            length: 1,\n            encode: (cursor) => cursor.pushUint8(value ? 0xf5 : 0xf4),\n        };\n    if (typeof value === 'number')\n        return getEncodable.number(value);\n    if (typeof value === 'bigint')\n        throw new UnsupportedBigIntError();\n    if (typeof value === 'string')\n        return getEncodable.string(value);\n    if (Array.isArray(value))\n        return getEncodable.array(value);\n    if (value instanceof Uint8Array)\n        return getEncodable.byteString(value);\n    if (value instanceof ArrayBuffer)\n        return getEncodable.byteString(new Uint8Array(value));\n    if (ArrayBuffer.isView(value))\n        return getEncodable.byteString(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));\n    if (value instanceof Map)\n        return getEncodable.map(value);\n    if (typeof value === 'object')\n        return getEncodable.object(value);\n    throw new UnexpectedTokenError({ token: String(value) });\n}\n/** @internal */\n(function (getEncodable) {\n    /** @internal */\n    function number(value) {\n        // Handle non-safe integers (floats, NaN, Infinity)\n        if (!Number.isSafeInteger(value)) {\n            // Use Float32 if the value can be represented without precision loss\n            // This creates smaller encodings when possible (5 bytes vs 9 bytes)\n            const float32 = Math.fround(value);\n            if (Number.isNaN(value) || value === float32)\n                return {\n                    length: 5, // 1 byte prefix + 4 bytes float32\n                    encode(cursor) {\n                        cursor.pushUint8(0xfa);\n                        cursor.dataView.setFloat32(cursor.position, value, false);\n                        cursor.position += 4;\n                    },\n                };\n            return {\n                length: 9, // 1 byte prefix + 8 bytes float64\n                encode(cursor) {\n                    cursor.pushUint8(0xfb);\n                    cursor.dataView.setFloat64(cursor.position, value, false);\n                    cursor.position += 8;\n                },\n            };\n        }\n        // Handle positive integers\n        if (value >= 0) {\n            if (value <= 0x17)\n                return { length: 1, encode: (cursor) => cursor.pushUint8(value) };\n            if (value <= 0xff)\n                return {\n                    length: 2, // 1 byte prefix + 1 byte uint8\n                    encode: (cursor) => {\n                        cursor.pushUint8(0x18);\n                        cursor.pushUint8(value);\n                    },\n                };\n            if (value <= 0xffff)\n                return {\n                    length: 3, // 1 byte prefix + 2 bytes uint16\n                    encode: (cursor) => {\n                        cursor.pushUint8(0x19);\n                        cursor.pushUint16(value);\n                    },\n                };\n            if (value <= 0xffffffff)\n                return {\n                    length: 5, // 1 byte prefix + 4 bytes uint32\n                    encode: (cursor) => {\n                        cursor.pushUint8(0x1a);\n                        cursor.pushUint32(value);\n                    },\n                };\n            throw new NumberTooLargeError({ number: value.toString(10) });\n        }\n        // Handle negative integers\n        // CBOR encodes -n as (n-1)\n        const positiveNumber = -1 - value;\n        if (value >= -24)\n            return {\n                length: 1,\n                encode: (cursor) => cursor.pushUint8(0x20 + positiveNumber),\n            };\n        if (positiveNumber <= 0xff)\n            return {\n                length: 2, // 1 byte prefix + 1 byte uint8\n                encode: (cursor) => {\n                    cursor.pushUint8(0x38);\n                    cursor.pushUint8(positiveNumber);\n                },\n            };\n        if (positiveNumber <= 0xffff)\n            return {\n                length: 3, // 1 byte prefix + 2 bytes uint16\n                encode: (cursor) => {\n                    cursor.pushUint8(0x39);\n                    cursor.pushUint16(positiveNumber);\n                },\n            };\n        if (positiveNumber <= 0xffffffff)\n            return {\n                length: 5, // 1 byte prefix + 4 bytes uint32\n                encode: (cursor) => {\n                    cursor.pushUint8(0x3a);\n                    cursor.pushUint32(positiveNumber);\n                },\n            };\n        throw new NumberTooLargeError({ number: value.toString(10) });\n    }\n    getEncodable.number = number;\n    /** @internal */\n    function string(value) {\n        const encoded = Bytes.fromString(value);\n        const size = encoded.length;\n        if (size <= 0x17)\n            return {\n                length: 1 + size, // 1 byte prefix + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x60 + size);\n                    if (size > 0)\n                        cursor.pushBytes(encoded);\n                },\n            };\n        if (size <= 0xff)\n            return {\n                length: 2 + size, // 1 byte prefix + 1 byte uint8 + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x78);\n                    cursor.pushUint8(size);\n                    cursor.pushBytes(encoded);\n                },\n            };\n        if (size <= 0xffff)\n            return {\n                length: 3 + size, // 1 byte prefix + 2 bytes uint16 + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x79);\n                    cursor.pushUint16(size);\n                    cursor.pushBytes(encoded);\n                },\n            };\n        if (size <= 0xffffffff)\n            return {\n                length: 5 + size, // 1 byte prefix + 4 bytes uint32 + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x7a);\n                    cursor.pushUint32(size);\n                    cursor.pushBytes(encoded);\n                },\n            };\n        throw new StringTooLargeError({ size });\n    }\n    getEncodable.string = string;\n    /** @internal */\n    function array(value) {\n        const items = value.map((item) => getEncodable(item));\n        const bodyLength = items.reduce((acc, item) => acc + item.length, 0);\n        const size = value.length;\n        if (size <= 0x17)\n            return {\n                length: 1 + bodyLength, // 1 byte prefix + body length\n                encode(cursor) {\n                    cursor.pushUint8(0x80 + size);\n                    for (const item of items)\n                        item.encode(cursor);\n                },\n            };\n        if (size <= 0xff)\n            return {\n                length: 2 + bodyLength, // 1 byte prefix + 1 byte uint8 + body length\n                encode(cursor) {\n                    cursor.pushUint8(0x98);\n                    cursor.pushUint8(size);\n                    for (const item of items)\n                        item.encode(cursor);\n                },\n            };\n        if (size <= 0xffff)\n            return {\n                length: 3 + bodyLength, // 1 byte prefix + 2 bytes uint16 + body length\n                encode(cursor) {\n                    cursor.pushUint8(0x99);\n                    cursor.pushUint16(size);\n                    for (const item of items)\n                        item.encode(cursor);\n                },\n            };\n        if (size <= 0xffffffff)\n            return {\n                length: 5 + bodyLength, // 1 byte prefix + 4 bytes uint32 + body length\n                encode(cursor) {\n                    cursor.pushUint8(0x9a);\n                    cursor.pushUint32(size);\n                    for (const item of items)\n                        item.encode(cursor);\n                },\n            };\n        throw new ArrayTooLargeError({ size });\n    }\n    getEncodable.array = array;\n    /** @internal */\n    function byteString(value) {\n        const size = value.byteLength;\n        if (size <= 0x17)\n            return {\n                length: 1 + size, // 1 byte prefix + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x40 + size);\n                    cursor.pushBytes(value);\n                },\n            };\n        if (size <= 0xff)\n            return {\n                length: 2 + size, // 1 byte prefix + 1 byte uint8 + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x58);\n                    cursor.pushUint8(size);\n                    cursor.pushBytes(value);\n                },\n            };\n        if (size <= 0xffff)\n            return {\n                length: 3 + size, // 1 byte prefix + 2 bytes uint16 + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x59);\n                    cursor.pushUint16(size);\n                    cursor.pushBytes(value);\n                },\n            };\n        if (size <= 0xffffffff)\n            return {\n                length: 5 + size, // 1 byte prefix + 4 bytes uint32 + size bytes\n                encode(cursor) {\n                    cursor.pushUint8(0x5a);\n                    cursor.pushUint32(size);\n                    cursor.pushBytes(value);\n                },\n            };\n        throw new ByteStringTooLargeError({ size });\n    }\n    getEncodable.byteString = byteString;\n    /** @internal */\n    function object(value) {\n        const keys = Object.keys(value);\n        const entries = keys.map((key) => ({\n            key: getEncodable(key),\n            value: getEncodable(value[key]),\n        }));\n        const bodyLength = entries.reduce((acc, entry) => acc + entry.key.length + entry.value.length, 0);\n        const size = keys.length;\n        if (size <= 0x17)\n            return {\n                length: 1 + bodyLength, // 1 byte prefix + body length\n                encode(cursor) {\n                    cursor.pushUint8(0xa0 + size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        if (size <= 0xff)\n            return {\n                length: 2 + bodyLength, // 1 byte prefix + 1 byte uint8 + body length\n                encode(cursor) {\n                    cursor.pushUint8(0xb8);\n                    cursor.pushUint8(size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        if (size <= 0xffff)\n            return {\n                length: 3 + bodyLength, // 1 byte prefix + 2 bytes uint16 + body length\n                encode(cursor) {\n                    cursor.pushUint8(0xb9);\n                    cursor.pushUint16(size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        if (size <= 0xffffffff)\n            return {\n                length: 5 + bodyLength, // 1 byte prefix + 4 bytes uint32 + body length\n                encode(cursor) {\n                    cursor.pushUint8(0xba);\n                    cursor.pushUint32(size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        throw new ObjectTooLargeError({ size });\n    }\n    getEncodable.object = object;\n    /** @internal */\n    function map(value) {\n        const entries = [];\n        for (const [k, v] of value)\n            entries.push({ key: getEncodable(k), value: getEncodable(v) });\n        const bodyLength = entries.reduce((acc, entry) => acc + entry.key.length + entry.value.length, 0);\n        const size = value.size;\n        if (size <= 0x17)\n            return {\n                length: 1 + bodyLength,\n                encode(cursor) {\n                    cursor.pushUint8(0xa0 + size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        if (size <= 0xff)\n            return {\n                length: 2 + bodyLength,\n                encode(cursor) {\n                    cursor.pushUint8(0xb8);\n                    cursor.pushUint8(size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        if (size <= 0xffff)\n            return {\n                length: 3 + bodyLength,\n                encode(cursor) {\n                    cursor.pushUint8(0xb9);\n                    cursor.pushUint16(size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        if (size <= 0xffffffff)\n            return {\n                length: 5 + bodyLength,\n                encode(cursor) {\n                    cursor.pushUint8(0xba);\n                    cursor.pushUint32(size);\n                    for (const entry of entries) {\n                        entry.key.encode(cursor);\n                        entry.value.encode(cursor);\n                    }\n                },\n            };\n        throw new ObjectTooLargeError({ size });\n    }\n    getEncodable.map = map;\n})(getEncodable || (getEncodable = {}));\n/** @internal */\n// biome-ignore lint/correctness/noUnusedVariables: _\nfunction decodeCursor(cursor) {\n    const initialByte = cursor.readUint8();\n    const majorType = initialByte >> 5;\n    const additionalInfo = initialByte & 0b00011111;\n    switch (majorType) {\n        // Major type 0: Unsigned integer\n        case 0:\n            return decodeCursor.readUnsignedInteger(cursor, additionalInfo);\n        // Major type 1: Negative integer\n        case 1:\n            return decodeCursor.readNegativeInteger(cursor, additionalInfo);\n        // Major type 2: Byte string\n        case 2:\n            return decodeCursor.readByteString(cursor, additionalInfo);\n        // Major type 3: Text string\n        case 3:\n            return decodeCursor.readTextString(cursor, additionalInfo);\n        // Major type 4: Array\n        case 4:\n            return decodeCursor.readArray(cursor, additionalInfo);\n        // Major type 5: Map\n        case 5:\n            return decodeCursor.readMap(cursor, additionalInfo);\n        // Major type 6: Tagged data (not yet supported)\n        case 6:\n            throw new UnsupportedTagError({ tag: additionalInfo });\n        // Major type 7: Simple values and floats\n        case 7:\n            return decodeCursor.readSimpleOrFloat(cursor, additionalInfo);\n        default:\n            throw new InvalidMajorTypeError({ majorType });\n    }\n}\n/** @internal */\n(function (decodeCursor) {\n    /** @internal */\n    // biome-ignore lint/correctness/noUnusedVariables: _\n    function readLength(cursor, additionalInfo) {\n        if (additionalInfo < 24)\n            return additionalInfo;\n        if (additionalInfo === 24)\n            return cursor.readUint8();\n        if (additionalInfo === 25)\n            return cursor.readUint16();\n        if (additionalInfo === 26)\n            return cursor.readUint32();\n        if (additionalInfo === 27)\n            throw new Unsupported64BitIntegerError();\n        throw new InvalidAdditionalInfoError({ additionalInfo });\n    }\n    /** @internal */\n    function readUnsignedInteger(cursor, additionalInfo) {\n        return readLength(cursor, additionalInfo);\n    }\n    decodeCursor.readUnsignedInteger = readUnsignedInteger;\n    /** @internal */\n    function readNegativeInteger(cursor, additionalInfo) {\n        const value = readLength(cursor, additionalInfo);\n        return -1 - value;\n    }\n    decodeCursor.readNegativeInteger = readNegativeInteger;\n    /** @internal */\n    function readByteString(cursor, additionalInfo) {\n        // Indefinite-length byte string\n        if (additionalInfo === 31) {\n            const chunks = [];\n            let totalLength = 0;\n            while (true) {\n                const byte = cursor.inspectUint8();\n                if (byte === 0xff) {\n                    cursor.readUint8(); // consume the break byte\n                    break;\n                }\n                const chunk = decodeCursor(cursor);\n                if (!(chunk instanceof Uint8Array))\n                    throw new InvalidIndefiniteLengthChunkError({ type: 'byte string' });\n                chunks.push(chunk);\n                totalLength += chunk.length;\n            }\n            // Concatenate chunks\n            const result = new Uint8Array(totalLength);\n            let offset = 0;\n            for (const chunk of chunks) {\n                result.set(chunk, offset);\n                offset += chunk.length;\n            }\n            return result;\n        }\n        const length = readLength(cursor, additionalInfo);\n        return cursor.readBytes(length);\n    }\n    decodeCursor.readByteString = readByteString;\n    /** @internal */\n    function readTextString(cursor, additionalInfo) {\n        // Indefinite-length text string\n        if (additionalInfo === 31) {\n            const chunks = [];\n            while (true) {\n                const byte = cursor.inspectUint8();\n                if (byte === 0xff) {\n                    cursor.readUint8(); // consume the break byte\n                    break;\n                }\n                const chunk = decodeCursor(cursor);\n                if (typeof chunk !== 'string')\n                    throw new InvalidIndefiniteLengthChunkError({ type: 'text string' });\n                chunks.push(chunk);\n            }\n            return chunks.join('');\n        }\n        const length = readLength(cursor, additionalInfo);\n        const bytes = cursor.readBytes(length);\n        return Bytes.toString(bytes);\n    }\n    decodeCursor.readTextString = readTextString;\n    /** @internal */\n    function readArray(cursor, additionalInfo) {\n        // Indefinite-length array\n        if (additionalInfo === 31) {\n            const result = [];\n            while (true) {\n                const byte = cursor.inspectUint8();\n                if (byte === 0xff) {\n                    cursor.readUint8(); // consume the break byte\n                    break;\n                }\n                result.push(decodeCursor(cursor));\n            }\n            return result;\n        }\n        const length = readLength(cursor, additionalInfo);\n        const result = [];\n        for (let i = 0; i < length; i++) {\n            result.push(decodeCursor(cursor));\n        }\n        return result;\n    }\n    decodeCursor.readArray = readArray;\n    /** @internal */\n    function readMap(cursor, additionalInfo) {\n        // Indefinite-length map\n        if (additionalInfo === 31) {\n            const result = {};\n            while (true) {\n                const byte = cursor.inspectUint8();\n                if (byte === 0xff) {\n                    cursor.readUint8(); // consume the break byte\n                    break;\n                }\n                const key = decodeCursor(cursor);\n                // Support both string and number keys (for COSE_Key with integer keys)\n                const keyStr = typeof key === 'string'\n                    ? key\n                    : typeof key === 'number'\n                        ? String(key)\n                        : String(key);\n                const value = decodeCursor(cursor);\n                result[keyStr] = value;\n            }\n            return result;\n        }\n        const length = readLength(cursor, additionalInfo);\n        const result = {};\n        for (let i = 0; i < length; i++) {\n            const key = decodeCursor(cursor);\n            // Support both string and number keys (for COSE_Key with integer keys)\n            const keyStr = typeof key === 'string'\n                ? key\n                : typeof key === 'number'\n                    ? String(key)\n                    : String(key);\n            const value = decodeCursor(cursor);\n            result[keyStr] = value;\n        }\n        return result;\n    }\n    decodeCursor.readMap = readMap;\n    /** @internal */\n    function readSimpleOrFloat(cursor, additionalInfo) {\n        // Simple values\n        if (additionalInfo === 20)\n            return false;\n        if (additionalInfo === 21)\n            return true;\n        if (additionalInfo === 22)\n            return null;\n        if (additionalInfo === 23)\n            return undefined;\n        // Float16 (half-precision)\n        if (additionalInfo === 25) {\n            const bits = cursor.readUint16();\n            return getFloat16(bits);\n        }\n        // Float32\n        if (additionalInfo === 26) {\n            const value = cursor.dataView.getFloat32(cursor.position, false);\n            cursor.position += 4;\n            return value;\n        }\n        // Float64\n        if (additionalInfo === 27) {\n            const value = cursor.dataView.getFloat64(cursor.position, false);\n            cursor.position += 8;\n            return value;\n        }\n        // Simple value (additional byte)\n        if (additionalInfo === 24) {\n            const simpleValue = cursor.readUint8();\n            // Simple values 0-19 are assigned, 20-23 are in the initial byte\n            // 24-31 are reserved, 32-255 are unassigned\n            if (simpleValue < 32)\n                throw new InvalidSimpleValueError({ value: simpleValue });\n            // For now, treat unassigned simple values as undefined\n            return undefined;\n        }\n        throw new InvalidAdditionalInfoError({ additionalInfo });\n    }\n    decodeCursor.readSimpleOrFloat = readSimpleOrFloat;\n    /** @internal */\n    function getFloat16(bits) {\n        // IEEE 754 half-precision (16-bit) float decoding\n        // Format: 1 sign bit, 5 exponent bits, 10 fraction bits\n        const sign = (bits >> 15) & 0x1;\n        const exponent = (bits >> 10) & 0x1f;\n        const fraction = bits & 0x3ff;\n        // Handle special cases\n        if (exponent === 0) {\n            // Subnormal numbers or zero\n            if (fraction === 0)\n                return sign ? -0 : 0;\n            // Subnormal: (-1)^sign × 2^(-14) × (0 + fraction/1024)\n            const value = 2 ** -14 * (fraction / 1024);\n            return sign ? -value : value;\n        }\n        if (exponent === 0x1f) {\n            // Infinity or NaN\n            if (fraction === 0)\n                return sign ? -Infinity : Infinity;\n            return NaN;\n        }\n        // Normal numbers: (-1)^sign × 2^(exponent-15) × (1 + fraction/1024)\n        const value = 2 ** (exponent - 15) * (1 + fraction / 1024);\n        return sign ? -value : value;\n    }\n})(decodeCursor || (decodeCursor = {}));\n//# sourceMappingURL=Cbor.js.map","import * as Cbor from './Cbor.js';\nimport * as Errors from './Errors.js';\nimport * as PublicKey from './PublicKey.js';\n/**\n * Converts a P256 {@link ox#PublicKey.PublicKey} to a CBOR-encoded COSE_Key.\n *\n * The COSE_Key uses integer map keys per [RFC 9053](https://datatracker.ietf.org/doc/html/rfc9053):\n * - `1` (kty): `2` (EC2)\n * - `3` (alg): `-7` (ES256)\n * - `-1` (crv): `1` (P-256)\n * - `-2` (x): x coordinate bytes\n * - `-3` (y): y coordinate bytes\n *\n * @example\n * ```ts twoslash\n * import { CoseKey, P256 } from 'ox'\n *\n * const { publicKey } = P256.createKeyPair()\n *\n * const coseKey = CoseKey.fromPublicKey(publicKey)\n * ```\n *\n * @param publicKey - The P256 public key to convert.\n * @returns The CBOR-encoded COSE_Key as a Hex string.\n */\nexport function fromPublicKey(publicKey) {\n    const pkBytes = PublicKey.toBytes(publicKey);\n    const x = pkBytes.slice(1, 33);\n    const y = pkBytes.slice(33, 65);\n    return Cbor.encode(new Map([\n        [1, 2], // kty: EC2\n        [3, -7], // alg: ES256\n        [-1, 1], // crv: P-256\n        [-2, x], // x coordinate\n        [-3, y], // y coordinate\n    ]));\n}\n/**\n * Converts a CBOR-encoded COSE_Key to a P256 {@link ox#PublicKey.PublicKey}.\n *\n * @example\n * ```ts twoslash\n * import { CoseKey, P256 } from 'ox'\n *\n * const { publicKey } = P256.createKeyPair()\n * const coseKey = CoseKey.fromPublicKey(publicKey)\n *\n * const publicKey2 = CoseKey.toPublicKey(coseKey)\n * ```\n *\n * @param coseKey - The CBOR-encoded COSE_Key.\n * @returns The P256 public key.\n */\nexport function toPublicKey(coseKey) {\n    const decoded = Cbor.decode(coseKey);\n    const x = decoded['-2'];\n    const y = decoded['-3'];\n    if (!(x instanceof Uint8Array) || !(y instanceof Uint8Array))\n        throw new InvalidCoseKeyError();\n    return PublicKey.from(new Uint8Array([0x04, ...x, ...y]));\n}\n/** Thrown when a COSE_Key does not contain valid P256 public key coordinates. */\nexport class InvalidCoseKeyError extends Errors.BaseError {\n    constructor() {\n        super('COSE_Key does not contain valid P256 public key coordinates.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'CoseKey.InvalidCoseKeyError'\n        });\n    }\n}\n//# sourceMappingURL=CoseKey.js.map","/**\n * Internal module for NIST P256, P384, P521 curves.\n * Do not use for now.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256, sha384, sha512 } from '@noble/hashes/sha2';\nimport { createCurve } from \"./_shortw_utils.js\";\nimport { createHasher } from \"./abstract/hash-to-curve.js\";\nimport { Field } from \"./abstract/modular.js\";\nimport { mapToCurveSimpleSWU } from \"./abstract/weierstrass.js\";\nconst Fp256 = Field(BigInt('0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff'));\nconst p256_a = Fp256.create(BigInt('-3'));\nconst p256_b = BigInt('0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b');\n/**\n * secp256r1 curve, ECDSA and ECDH methods.\n * Field: `2n**224n * (2n**32n-1n) + 2n**192n + 2n**96n-1n`\n */\n// prettier-ignore\nexport const p256 = createCurve({\n    a: p256_a,\n    b: p256_b,\n    Fp: Fp256,\n    n: BigInt('0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551'),\n    Gx: BigInt('0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296'),\n    Gy: BigInt('0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5'),\n    h: BigInt(1),\n    lowS: false\n}, sha256);\n/** Alias to p256. */\nexport const secp256r1 = p256;\nconst p256_mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp256, {\n    A: p256_a,\n    B: p256_b,\n    Z: Fp256.create(BigInt('-10')),\n}))();\n/** Hashing / encoding to p256 points / field. RFC 9380 methods. */\nexport const p256_hasher = /* @__PURE__ */ (() => createHasher(secp256r1.ProjectivePoint, (scalars) => p256_mapSWU(scalars[0]), {\n    DST: 'P256_XMD:SHA-256_SSWU_RO_',\n    encodeDST: 'P256_XMD:SHA-256_SSWU_NU_',\n    p: Fp256.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha256,\n}))();\n// Field over which we'll do calculations.\nconst Fp384 = Field(BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff'));\nconst p384_a = Fp384.create(BigInt('-3'));\n// prettier-ignore\nconst p384_b = BigInt('0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef');\n/**\n * secp384r1 curve, ECDSA and ECDH methods.\n * Field: `2n**384n - 2n**128n - 2n**96n + 2n**32n - 1n`.\n * */\n// prettier-ignore\nexport const p384 = createCurve({\n    a: p384_a,\n    b: p384_b,\n    Fp: Fp384,\n    n: BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973'),\n    Gx: BigInt('0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7'),\n    Gy: BigInt('0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f'),\n    h: BigInt(1),\n    lowS: false\n}, sha384);\n/** Alias to p384. */\nexport const secp384r1 = p384;\nconst p384_mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp384, {\n    A: p384_a,\n    B: p384_b,\n    Z: Fp384.create(BigInt('-12')),\n}))();\n/** Hashing / encoding to p384 points / field. RFC 9380 methods. */\nexport const p384_hasher = /* @__PURE__ */ (() => createHasher(secp384r1.ProjectivePoint, (scalars) => p384_mapSWU(scalars[0]), {\n    DST: 'P384_XMD:SHA-384_SSWU_RO_',\n    encodeDST: 'P384_XMD:SHA-384_SSWU_NU_',\n    p: Fp384.ORDER,\n    m: 1,\n    k: 192,\n    expand: 'xmd',\n    hash: sha384,\n}))();\n// Field over which we'll do calculations.\nconst Fp521 = Field(BigInt('0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'));\nconst p521_a = Fp521.create(BigInt('-3'));\nconst p521_b = BigInt('0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00');\n/**\n * NIST secp521r1 aka p521 curve, ECDSA and ECDH methods.\n * Field: `2n**521n - 1n`.\n */\n// prettier-ignore\nexport const p521 = createCurve({\n    a: p521_a,\n    b: p521_b,\n    Fp: Fp521,\n    n: BigInt('0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409'),\n    Gx: BigInt('0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66'),\n    Gy: BigInt('0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650'),\n    h: BigInt(1),\n    lowS: false,\n    allowedPrivateKeyLengths: [130, 131, 132] // P521 keys are variable-length. Normalize to 132b\n}, sha512);\n/** Alias to p521. */\nexport const secp521r1 = p521;\nconst p521_mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp521, {\n    A: p521_a,\n    B: p521_b,\n    Z: Fp521.create(BigInt('-4')),\n}))();\n/** Hashing / encoding to p521 points / field. RFC 9380 methods. */\nexport const p521_hasher = /* @__PURE__ */ (() => createHasher(secp521r1.ProjectivePoint, (scalars) => p521_mapSWU(scalars[0]), {\n    DST: 'P521_XMD:SHA-512_SSWU_RO_',\n    encodeDST: 'P521_XMD:SHA-512_SSWU_NU_',\n    p: Fp521.ORDER,\n    m: 1,\n    k: 256,\n    expand: 'xmd',\n    hash: sha512,\n}))();\n//# sourceMappingURL=nist.js.map","/**\n * NIST secp256r1 aka p256.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport {} from \"./abstract/hash-to-curve.js\";\nimport { p256_hasher, p256 as p256n } from \"./nist.js\";\nexport const p256 = p256n;\nexport const secp256r1 = p256n;\nexport const hashToCurve = /* @__PURE__ */ (() => p256_hasher.hashToCurve)();\nexport const encodeToCurve = /* @__PURE__ */ (() => p256_hasher.encodeToCurve)();\n//# sourceMappingURL=p256.js.map","import { secp256r1 } from '@noble/curves/p256';\nimport * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as Entropy from './internal/entropy.js';\nimport * as keyDerivation from './internal/keyDerivation.js';\nimport * as internal from './internal/mnemonic.js';\nimport * as PublicKey from './PublicKey.js';\n/** Re-export of noble/curves P256 utilities. */\nexport const noble = secp256r1;\n/**\n * Creates a new P256 ECDSA key pair consisting of a private key and its corresponding public key.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const { privateKey, publicKey } = P256.createKeyPair()\n * ```\n *\n * @param options - The options to generate the key pair.\n * @returns The generated key pair containing both private and public keys.\n */\nexport function createKeyPair(options = {}) {\n    const { as = 'Hex' } = options;\n    const privateKey = randomPrivateKey({ as });\n    const publicKey = getPublicKey({ privateKey });\n    return {\n        privateKey: privateKey,\n        publicKey,\n    };\n}\n/**\n * Derives a valid P256 private key from a BIP-39 mnemonic.\n *\n * This is equivalent to passing `Mnemonic.toSeed(mnemonic, { passphrase })`\n * to `P256.fromSeed`.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const privateKey = P256.fromMnemonic(\n *   'test test test test test test test test test test test junk'\n * )\n * ```\n *\n * @param mnemonic - BIP-39 mnemonic phrase.\n * @param options - Options.\n * @returns A valid P256 private key.\n */\nexport function fromMnemonic(mnemonic, options = {}) {\n    const { passphrase } = options;\n    const seed = internal.toSeed(mnemonic, { passphrase });\n    try {\n        return fromSeed(seed, options);\n    }\n    finally {\n        seed.fill(0);\n    }\n}\n/**\n * Derives a valid P256 private key from a seed.\n *\n * The seed must contain at least 32 bytes of cryptographically strong key\n * material. Do not pass a password directly; use a password KDF first.\n *\n * The permanent derivation contract uses the seed as the HMAC-SHA256\n * key. The HMAC message uses the `ox.p256.fromSeed.v1` domain followed by a\n * 32-bit big-endian counter starting at zero. Invalid scalars are skipped.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const privateKey = P256.fromSeed(\n *   '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'\n * )\n * ```\n *\n * @param seed - Seed containing at least 32 bytes of cryptographically strong key material.\n * @param options - Options.\n * @returns A valid P256 private key.\n */\nexport function fromSeed(seed, options = {}) {\n    const { as = 'Hex' } = options;\n    const bytes = Bytes.from(seed);\n    if (bytes.length < 32)\n        throw new InvalidSeedSizeError({ size: bytes.length });\n    const privateKey = keyDerivation.derive(bytes, fromSeedDomain, {\n        validate: noble.utils.isValidPrivateKey,\n    });\n    if (as === 'Hex') {\n        const value = Hex.fromBytes(privateKey);\n        privateKey.fill(0);\n        return value;\n    }\n    return privateKey;\n}\n/**\n * Computes the P256 ECDSA public key from a provided private key.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const publicKey = P256.getPublicKey({ privateKey: '0x...' })\n * ```\n *\n * @param options - The options to compute the public key.\n * @returns The computed public key.\n */\nexport function getPublicKey(options) {\n    const { privateKey } = options;\n    const point = secp256r1.ProjectivePoint.fromPrivateKey(typeof privateKey === 'string'\n        ? privateKey.slice(2)\n        : Hex.fromBytes(privateKey).slice(2));\n    return PublicKey.from(point);\n}\n/**\n * Computes a shared secret using ECDH (Elliptic Curve Diffie-Hellman) between a private key and a public key.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const { privateKey: privateKeyA } = P256.createKeyPair()\n * const { publicKey: publicKeyB } = P256.createKeyPair()\n *\n * const sharedSecret = P256.getSharedSecret({\n *   privateKey: privateKeyA,\n *   publicKey: publicKeyB\n * })\n * ```\n *\n * @param options - The options to compute the shared secret.\n * @returns The computed shared secret.\n */\nexport function getSharedSecret(options) {\n    const { as = 'Hex', privateKey, publicKey } = options;\n    const point = secp256r1.ProjectivePoint.fromHex(PublicKey.toHex(publicKey).slice(2));\n    const privateKeyHex = typeof privateKey === 'string'\n        ? privateKey.slice(2)\n        : Hex.fromBytes(privateKey).slice(2);\n    const sharedPoint = point.multiply(secp256r1.utils.normPrivateKeyToScalar(privateKeyHex));\n    const sharedSecret = sharedPoint.toRawBytes(true); // compressed format\n    if (as === 'Hex')\n        return Hex.fromBytes(sharedSecret);\n    return sharedSecret;\n}\n/**\n * Generates a random P256 ECDSA private key.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const privateKey = P256.randomPrivateKey()\n * ```\n *\n * @param options - The options to generate the private key.\n * @returns The generated private key.\n */\nexport function randomPrivateKey(options = {}) {\n    const { as = 'Hex' } = options;\n    const bytes = secp256r1.utils.randomPrivateKey();\n    if (as === 'Hex')\n        return Hex.fromBytes(bytes);\n    return bytes;\n}\n/**\n * Recovers the signing public key from the signed payload and signature.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const signature = P256.sign({ payload: '0xdeadbeef', privateKey: '0x...' })\n *\n * const publicKey = P256.recoverPublicKey({ // [!code focus]\n *   payload: '0xdeadbeef', // [!code focus]\n *   signature, // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param options - The recovery options.\n * @returns The recovered public key.\n */\nexport function recoverPublicKey(options) {\n    const { payload, signature } = options;\n    const { r, s, yParity } = signature;\n    const signature_ = new secp256r1.Signature(BigInt(r), BigInt(s)).addRecoveryBit(yParity);\n    const payload_ = payload instanceof Uint8Array ? Hex.fromBytes(payload) : payload;\n    const point = signature_.recoverPublicKey(payload_.substring(2));\n    return PublicKey.from(point);\n}\n/**\n * Signs the payload with the provided private key and returns a P256 signature.\n *\n * @example\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const signature = P256.sign({ // [!code focus]\n *   payload: '0xdeadbeef', // [!code focus]\n *   privateKey: '0x...' // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param options - The signing options.\n * @returns The ECDSA {@link ox#Signature.Signature}.\n */\nexport function sign(options) {\n    const { extraEntropy = Entropy.extraEntropy, hash, payload, privateKey, } = options;\n    const { r, s, recovery } = secp256r1.sign(payload instanceof Uint8Array ? payload : Bytes.fromHex(payload), privateKey instanceof Uint8Array ? privateKey : Bytes.fromHex(privateKey), {\n        extraEntropy: typeof extraEntropy === 'boolean'\n            ? extraEntropy\n            : Hex.from(extraEntropy).slice(2),\n        lowS: true,\n        ...(hash ? { prehash: true } : {}),\n    });\n    return {\n        r,\n        s,\n        yParity: recovery,\n    };\n}\n/**\n * Verifies a payload was signed by the provided public key.\n *\n * @example\n *\n * ```ts twoslash\n * import { P256 } from 'ox'\n *\n * const { privateKey, publicKey } = P256.createKeyPair()\n * const signature = P256.sign({ payload: '0xdeadbeef', privateKey })\n *\n * const verified = P256.verify({ // [!code focus]\n *   publicKey, // [!code focus]\n *   payload: '0xdeadbeef', // [!code focus]\n *   signature, // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param options - The verification options.\n * @returns Whether the payload was signed by the provided public key.\n */\nexport function verify(options) {\n    const { hash, payload, publicKey, signature } = options;\n    return secp256r1.verify(signature, payload instanceof Uint8Array ? payload : Bytes.fromHex(payload), PublicKey.toHex(publicKey).substring(2), { lowS: true, ...(hash ? { prehash: true } : {}) });\n}\n/** Thrown when a seed contains fewer than 32 bytes. */\nexport class InvalidSeedSizeError extends Errors.BaseError {\n    constructor(options) {\n        super(`Seed must contain at least 32 bytes. Received ${options.size} bytes.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'P256.InvalidSeedSizeError'\n        });\n    }\n}\nconst fromSeedDomain = Bytes.fromString('ox.p256.fromSeed.v1');\n//# sourceMappingURL=P256.js.map","import * as Base64 from '../../core/Base64.js';\n/** @internal */\nexport const base64UrlOptions = { url: true, pad: false };\n/** @internal */\nexport const responseKeys = [\n    'attestationObject',\n    'authenticatorData',\n    'clientDataJSON',\n    'signature',\n    'userHandle',\n];\n/** @internal */\nexport function bytesToArrayBuffer(bytes) {\n    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);\n}\n/** @internal */\nexport function bufferSourceToBytes(source) {\n    if (source instanceof Uint8Array)\n        return source;\n    if (source instanceof ArrayBuffer)\n        return new Uint8Array(source);\n    return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);\n}\n/** @internal */\nexport function serializeExtensions(extensions) {\n    const { prf, ...rest } = extensions;\n    return {\n        ...rest,\n        ...(prf && {\n            prf: {\n                eval: {\n                    first: Base64.fromBytes(prf.eval.first, base64UrlOptions),\n                },\n            },\n        }),\n    };\n}\n/** @internal */\nexport function deserializeExtensions(extensions) {\n    const { prf, ...rest } = extensions;\n    return {\n        ...rest,\n        ...(prf && {\n            prf: {\n                eval: {\n                    first: Base64.toBytes(prf.eval.first),\n                },\n            },\n        }),\n    };\n}\n//# sourceMappingURL=utils.js.map","import * as Base64 from '../core/Base64.js';\nimport * as Bytes from '../core/Bytes.js';\nimport * as Cbor from '../core/Cbor.js';\nimport * as CoseKey from '../core/CoseKey.js';\nimport * as Errors from '../core/Errors.js';\nimport * as Hash from '../core/Hash.js';\nimport * as Hex from '../core/Hex.js';\nimport * as internal from '../core/internal/webauthn.js';\nimport * as P256 from '../core/P256.js';\nimport * as PublicKey from '../core/PublicKey.js';\nimport * as Signature from '../core/Signature.js';\nimport { base64UrlOptions, bufferSourceToBytes, bytesToArrayBuffer, deserializeExtensions, responseKeys, serializeExtensions, } from './internal/utils.js';\nexport const createChallenge = Uint8Array.from([\n    105, 171, 180, 181, 160, 222, 75, 198, 42, 42, 32, 31, 141, 37, 186, 233,\n]);\n/**\n * Creates a new WebAuthn P256 Credential, which can be stored and later used for signing.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const credential = await Registration.create({ name: 'Example' }) // [!code focus]\n * // @log: {\n * // @log:   id: 'oZ48...',\n * // @log:   publicKey: { x: 51421...5123n, y: 12345...6789n },\n * // @log:   raw: PublicKeyCredential {},\n * // @log: }\n * ```\n *\n * @param options - Credential creation options.\n * @returns A WebAuthn P256 credential.\n */\nexport async function create(options) {\n    const { createFn = (opts) => window.navigator.credentials.create(opts), ...rest } = options;\n    const creationOptions = 'publicKey' in rest\n        ? rest\n        : getOptions(rest);\n    try {\n        const credential = (await createFn(creationOptions));\n        if (!credential)\n            throw new CreateFailedError();\n        const response = credential.response;\n        // Eagerly copy ArrayBuffer data to avoid cross-origin access errors\n        // when browser extensions (e.g. 1Password on Firefox) replace\n        // `navigator.credentials` with a cross-compartment proxy.\n        const attestationObject = response.attestationObject;\n        const clientDataJSON = response.clientDataJSON;\n        const id = credential.id;\n        const publicKey = await internal.parseCredentialPublicKey(response, attestationObject);\n        return {\n            attestationObject,\n            clientDataJSON,\n            id,\n            publicKey,\n            raw: credential,\n        };\n    }\n    catch (error) {\n        throw new CreateFailedError({\n            cause: error,\n        });\n    }\n}\n/**\n * Returns the creation options for a P256 WebAuthn Credential to be used with\n * the Web Authentication API.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const options = Registration.getOptions({ name: 'Example' })\n *\n * const credential = await window.navigator.credentials.create(options)\n * ```\n *\n * @param options - Options.\n * @returns The credential creation options.\n */\nexport function getOptions(options) {\n    const { attestation = 'none', authenticatorSelection = {\n        residentKey: 'preferred',\n        requireResidentKey: false,\n        userVerification: 'required',\n    }, challenge = createChallenge, excludeCredentialIds, extensions, name: name_, rp = {\n        id: window.location.hostname,\n        name: window.document.title,\n    }, user, } = options;\n    const name = (user?.name ?? name_);\n    return {\n        publicKey: {\n            attestation,\n            authenticatorSelection,\n            challenge: typeof challenge === 'string' ? Bytes.fromHex(challenge) : challenge,\n            ...(excludeCredentialIds\n                ? {\n                    excludeCredentials: excludeCredentialIds?.map((id) => ({\n                        id: Base64.toBytes(id),\n                        type: 'public-key',\n                    })),\n                }\n                : {}),\n            pubKeyCredParams: [\n                {\n                    type: 'public-key',\n                    alg: -7, // p256\n                },\n            ],\n            rp,\n            user: {\n                id: user?.id ?? Hash.keccak256(Bytes.fromString(name), { as: 'Bytes' }),\n                name,\n                displayName: user?.displayName ?? name,\n            },\n            ...(extensions && { extensions }),\n        },\n    };\n}\n/**\n * Serializes a registration response into a JSON-serializable\n * format, converting `ArrayBuffer` fields to base64url strings\n * and the public key to a hex string.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const credential = await Registration.create({ name: 'Example' })\n * const response = Registration.verify({\n *   credential,\n *   challenge: '0x...',\n *   origin: 'https://example.com',\n *   rpId: 'example.com',\n * })\n *\n * const serialized = Registration.serializeResponse(response) // [!code focus]\n *\n * // `serialized` is JSON-serializable — send it to a server, store it, etc.\n * const json = JSON.stringify(serialized)\n * ```\n *\n * @param response - The registration response to serialize.\n * @returns The serialized registration response.\n */\nexport function serializeResponse(response) {\n    const { credential, ...rest } = response;\n    const rawResponse = {};\n    for (const key of responseKeys) {\n        const r = credential.raw.response;\n        let value = r[key];\n        if (!(value instanceof ArrayBuffer)) {\n            const getter = `get${key[0].toUpperCase()}${key.slice(1)}`;\n            const fn = r[getter];\n            if (typeof fn === 'function')\n                value = fn.call(r);\n        }\n        if (value instanceof ArrayBuffer)\n            rawResponse[key] = Base64.fromBytes(new Uint8Array(value), base64UrlOptions);\n    }\n    return {\n        ...rest,\n        credential: {\n            attestationObject: Base64.fromBytes(new Uint8Array(credential.attestationObject), base64UrlOptions),\n            clientDataJSON: Base64.fromBytes(new Uint8Array(credential.clientDataJSON), base64UrlOptions),\n            id: credential.id,\n            publicKey: PublicKey.toHex(credential.publicKey),\n            raw: {\n                id: credential.raw.id,\n                type: credential.raw.type,\n                authenticatorAttachment: credential.raw.authenticatorAttachment,\n                rawId: Base64.fromBytes(bufferSourceToBytes(credential.raw.rawId), base64UrlOptions),\n                response: rawResponse,\n            },\n        },\n    };\n}\n/**\n * Serializes credential creation options into a JSON-serializable\n * format, converting `BufferSource` fields to base64url strings.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const options = Registration.getOptions({ name: 'Example' })\n *\n * const serialized = Registration.serializeOptions(options) // [!code focus]\n *\n * // `serialized` is JSON-serializable — send it to a server, store it, etc.\n * const json = JSON.stringify(serialized)\n * ```\n *\n * @param options - The credential creation options to serialize.\n * @returns The serialized credential creation options.\n */\nexport function serializeOptions(options) {\n    const publicKey = options.publicKey;\n    if (!publicKey)\n        return {};\n    const { challenge, excludeCredentials, extensions, user, ...rest } = publicKey;\n    return {\n        publicKey: {\n            ...rest,\n            challenge: Hex.fromBytes(bufferSourceToBytes(challenge)),\n            ...(excludeCredentials && {\n                excludeCredentials: excludeCredentials.map(({ id, ...rest }) => ({\n                    ...rest,\n                    id: Base64.fromBytes(bufferSourceToBytes(id), base64UrlOptions),\n                })),\n            }),\n            ...(extensions && {\n                extensions: serializeExtensions(extensions),\n            }),\n            user: {\n                ...user,\n                id: Base64.fromBytes(bufferSourceToBytes(user.id), base64UrlOptions),\n            },\n        },\n    };\n}\n/**\n * Deserializes credential creation options that can be passed to\n * `navigator.credentials.create()`.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const options = Registration.getOptions({ name: 'Example' })\n * const serialized = Registration.serializeOptions(options)\n *\n * // ... send to server and back ...\n *\n * const deserialized = Registration.deserializeOptions(serialized) // [!code focus]\n * const credential = await window.navigator.credentials.create(deserialized)\n * ```\n *\n * @param options - The serialized credential creation options.\n * @returns The deserialized credential creation options.\n */\nexport function deserializeOptions(options) {\n    const publicKey = options.publicKey;\n    if (!publicKey)\n        return {};\n    const { challenge, excludeCredentials, extensions, user, ...rest } = publicKey;\n    return {\n        publicKey: {\n            ...rest,\n            challenge: Bytes.fromHex(challenge),\n            ...(excludeCredentials && {\n                excludeCredentials: excludeCredentials.map(({ id, ...rest }) => ({\n                    ...rest,\n                    id: Base64.toBytes(id),\n                })),\n            }),\n            ...(extensions && {\n                extensions: deserializeExtensions(extensions),\n            }),\n            user: {\n                ...user,\n                id: Base64.toBytes(user.id),\n            },\n        },\n    };\n}\n/**\n * Deserializes a serialized registration response.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const response = Registration.deserializeResponse({ // [!code focus]\n *   credential: { // [!code focus]\n *     attestationObject: 'o2NmbXRkbm9uZQ...', // [!code focus]\n *     clientDataJSON: 'eyJ0eXBlIjoid2Vi...', // [!code focus]\n *     id: 'm1-bMPuAqpWhCxHZQZTT6e-lSPntQbh3opIoGe7g4Qs', // [!code focus]\n *     publicKey: '0x04ab891400...', // [!code focus]\n *     raw: { id: '...', type: 'public-key', authenticatorAttachment: 'platform', rawId: '...', response: { clientDataJSON: 'eyJ0eXBlIjoid2Vi...' } }, // [!code focus]\n *   }, // [!code focus]\n *   counter: 0, // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param response - The serialized registration response.\n * @returns The deserialized registration response.\n */\nexport function deserializeResponse(response) {\n    const { credential, ...rest } = response;\n    const rawResponse = {};\n    for (const [key, value] of Object.entries(credential.raw.response))\n        rawResponse[key] = bytesToArrayBuffer(Base64.toBytes(value));\n    return {\n        ...rest,\n        credential: {\n            attestationObject: bytesToArrayBuffer(Base64.toBytes(credential.attestationObject)),\n            clientDataJSON: bytesToArrayBuffer(Base64.toBytes(credential.clientDataJSON)),\n            id: credential.id,\n            publicKey: PublicKey.from(credential.publicKey),\n            raw: {\n                id: credential.raw.id,\n                type: credential.raw.type,\n                authenticatorAttachment: credential.raw.authenticatorAttachment,\n                rawId: bytesToArrayBuffer(Base64.toBytes(credential.raw.rawId)),\n                response: rawResponse,\n                getClientExtensionResults: () => ({}),\n            },\n        },\n    };\n}\n/**\n * Verifies a WebAuthn registration (credential creation) response. Validates the\n * `clientDataJSON`, `attestationObject`, authenticator flags, challenge, origin, and\n * relying party ID, then extracts the credential ID and public key.\n *\n * @example\n * ```ts twoslash\n * import { Registration } from 'ox/webauthn'\n *\n * const credential = await Registration.create({ name: 'Example' })\n *\n * const result = Registration.verify({ // [!code focus]\n *   credential, // [!code focus]\n *   challenge: '0x69abb4b5a0de4bc62a2a201f8d25bae9', // [!code focus]\n *   origin: 'https://example.com', // [!code focus]\n *   rpId: 'example.com', // [!code focus]\n * }) // [!code focus]\n * // @log: {\n * // @log:   credential: {\n * // @log:     id: 'oZ48...',\n * // @log:     publicKey: { prefix: 4, x: 51421...5123n, y: 12345...6789n },\n * // @log:   },\n * // @log:   counter: 0,\n * // @log:   userVerified: true,\n * // @log: }\n * ```\n *\n * @param options - Verification options.\n * @returns The verified registration result.\n */\nexport function verify(options) {\n    const { attestation = 'none', credential, origin, rpId, userVerification = 'required', } = options;\n    // 1. Decode and validate clientDataJSON\n    const clientDataJSONBytes = new Uint8Array(credential.clientDataJSON);\n    const clientDataJSON = Bytes.toString(clientDataJSONBytes);\n    const clientData = JSON.parse(clientDataJSON);\n    if (clientData.type !== 'webauthn.create')\n        throw new VerifyError(`Expected clientData.type \"webauthn.create\", got \"${clientData.type}\"`);\n    // Validate challenge\n    const challengeResult = (() => {\n        if (typeof options.challenge === 'function')\n            return options.challenge(clientData.challenge);\n        const challengeBytes = typeof options.challenge === 'string'\n            ? Bytes.fromHex(options.challenge)\n            : options.challenge;\n        const challenge = Base64.fromBytes(challengeBytes, base64UrlOptions);\n        return clientData.challenge === challenge;\n    })();\n    if (!challengeResult)\n        throw new VerifyError('Challenge mismatch');\n    // Validate origin\n    const origins = Array.isArray(origin) ? origin : [origin];\n    if (!origins.includes(clientData.origin))\n        throw new VerifyError(`Origin mismatch: expected ${JSON.stringify(origin)}, got \"${clientData.origin}\"`);\n    // 2. Decode attestationObject via CBOR\n    const attestationObjectBytes = new Uint8Array(credential.attestationObject);\n    const attestation_ = Cbor.decode(attestationObjectBytes);\n    // 3. Parse authenticatorData\n    const authData = attestation_.authData;\n    const rpIdHash = authData.slice(0, 32);\n    const expectedRpIdHash = Hash.sha256(Hex.fromString(rpId), { as: 'Bytes' });\n    if (!Bytes.isEqual(rpIdHash, expectedRpIdHash))\n        throw new VerifyError('rpId hash mismatch');\n    const flags = authData[32];\n    const up = (flags & 0x01) !== 0;\n    const uv = (flags & 0x04) !== 0;\n    const at = (flags & 0x40) !== 0;\n    const be = (flags & 0x08) !== 0;\n    const bs = (flags & 0x10) !== 0;\n    if (!up)\n        throw new VerifyError('User presence flag not set');\n    if (!at)\n        throw new VerifyError('Attested credential data flag not set');\n    if (userVerification === 'required' && !uv)\n        throw new VerifyError('User verification flag not set');\n    // If the BE bit is not set, the BS bit must not be set.\n    if (!be && bs)\n        throw new VerifyError('Backup state (BS) flag is set but backup eligibility (BE) flag is not');\n    // Minimum authData length: 37 (rpIdHash + flags + counter) + 16 (AAGUID) + 2 (credIdLen)\n    if (authData.length < 55)\n        throw new VerifyError('authData too short for attested credential data');\n    // Counter (4 bytes, big-endian, starting at offset 33)\n    const counter = ((authData[33] << 24) |\n        (authData[34] << 16) |\n        (authData[35] << 8) |\n        authData[36]) >>>\n        0;\n    // Credential ID length (2 bytes at offset 53, big-endian)\n    const credIdLen = (authData[53] << 8) | authData[54];\n    if (55 + credIdLen > authData.length)\n        throw new VerifyError('credIdLen exceeds authData bounds');\n    // Credential ID (variable length starting at offset 55)\n    const credentialId = authData.slice(55, 55 + credIdLen);\n    // Verify credential ID consistency if caller-supplied id is present\n    if (credential.id !== undefined) {\n        const expectedId = Base64.fromBytes(credentialId, base64UrlOptions);\n        if (credential.id !== expectedId)\n            throw new VerifyError(`Credential ID mismatch: supplied \"${credential.id}\" does not match authData \"${expectedId}\"`);\n    }\n    // 4. Parse and validate COSE public key\n    const ed = (flags & 0x80) !== 0;\n    const coseKeyBytes = authData.slice(55 + credIdLen);\n    const coseKeyHex = Hex.fromBytes(coseKeyBytes);\n    const coseKeyData = Cbor.decode(coseKeyHex);\n    // Validate key type is EC2 (2), algorithm is ES256 (-7), and curve is P-256 (1)\n    if (coseKeyData['1'] !== 2 ||\n        coseKeyData['3'] !== -7 ||\n        coseKeyData['-1'] !== 1)\n        throw new VerifyError('COSE key must be EC2 (kty=2) with ES256 algorithm (alg=-7) on P-256 curve (crv=1)');\n    const publicKey = CoseKey.toPublicKey(coseKeyHex);\n    // Verify no unexpected trailing bytes after the COSE key.\n    // Re-encode the extracted public key as a COSE key to determine its expected length.\n    const expectedCoseKeyLen = Bytes.fromHex(CoseKey.fromPublicKey(publicKey)).length;\n    const trailingBytes = coseKeyBytes.length - expectedCoseKeyLen;\n    if (trailingBytes > 0 && !ed)\n        throw new VerifyError(`authData contains ${trailingBytes} unexpected trailing byte(s) after COSE key`);\n    // 5. Verify attestation statement (cryptographic binding of authData + clientDataJSON)\n    const clientDataHash = Hash.sha256(Bytes.fromString(clientDataJSON), {\n        as: 'Bytes',\n    });\n    const verificationData = Bytes.concat(authData, clientDataHash);\n    const { fmt, attStmt } = attestation_;\n    if (fmt === 'none') {\n        // \"none\" format has no attestation signature; only accept if caller opts in\n        if (attestation === 'required')\n            throw new VerifyError('Attestation format is \"none\" but attestation verification is required. ' +\n                'Set `attestation: \"none\"` to accept unattested credentials.');\n    }\n    else if (fmt === 'packed') {\n        // Packed attestation: verify signature over authData || clientDataHash\n        const sig = attStmt.sig;\n        const alg = attStmt.alg;\n        if (!(sig instanceof Uint8Array) || typeof alg !== 'number')\n            throw new VerifyError('Invalid packed attestation statement: missing sig or alg');\n        if (alg !== -7)\n            throw new VerifyError(`Unsupported attestation algorithm: ${alg} (expected -7 / ES256)`);\n        if (attStmt.x5c) {\n            // Full attestation with certificate chain is not supported\n            throw new VerifyError('Packed attestation with x5c certificate chain is not supported. ' +\n                'Use self attestation (no x5c) or set `attestation: \"none\"`.');\n        }\n        // Self attestation: verify using the credential public key\n        const attSignature = Signature.fromDerBytes(sig);\n        const verified = P256.verify({\n            hash: true,\n            payload: verificationData,\n            publicKey,\n            signature: attSignature,\n        });\n        if (!verified)\n            throw new VerifyError('Attestation signature verification failed');\n    }\n    else {\n        throw new VerifyError(`Unsupported attestation format: \"${fmt}\"`);\n    }\n    // 6. Build credential ID string\n    const id = credential.id ?? Base64.fromBytes(credentialId, base64UrlOptions);\n    // 7. Build raw credential\n    const raw = credential.raw ?? {\n        authenticatorAttachment: null,\n        getClientExtensionResults: () => ({}),\n        id,\n        rawId: bytesToArrayBuffer(credentialId),\n        response: {\n            attestationObject: credential.attestationObject,\n            clientDataJSON: credential.clientDataJSON,\n        },\n        type: 'public-key',\n    };\n    return {\n        credential: {\n            attestationObject: credential.attestationObject,\n            clientDataJSON: credential.clientDataJSON,\n            id,\n            publicKey,\n            raw,\n        },\n        counter,\n        ...(uv ? { userVerified: true } : {}),\n        ...(be ? { backedUp: bs } : {}),\n        ...(be\n            ? {\n                deviceType: bs ? 'multiDevice' : 'singleDevice',\n            }\n            : {}),\n    };\n}\n/** Thrown when WebAuthn registration verification fails. */\nexport class VerifyError extends Errors.BaseError {\n    constructor() {\n        super(...arguments);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Registration.VerifyError'\n        });\n    }\n}\n/** Thrown when a WebAuthn P256 credential creation fails. */\nexport class CreateFailedError extends Errors.BaseError {\n    constructor({ cause } = {}) {\n        super('Failed to create credential.', {\n            cause,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Registration.CreateFailedError'\n        });\n    }\n}\n//# sourceMappingURL=Registration.js.map","import { p256 } from '@noble/curves/p256';\nimport * as Registration from '../../webauthn/Registration.js';\nimport * as PublicKey from '../PublicKey.js';\n/**\n * Parses an ASN.1 signature into a r and s value.\n *\n * @internal\n */\nexport function parseAsn1Signature(bytes) {\n    const sig = p256.Signature.fromDER(bytes).normalizeS();\n    return { r: sig.r, s: sig.s };\n}\n/**\n * Parses a public key into x and y coordinates from the public key\n * defined on the credential.\n *\n * @internal\n */\nexport async function parseCredentialPublicKey(response, \n/** Pre-cloned attestationObject to use in the fallback path, avoiding\n *  cross-origin access on the proxy response object. */\nattestationObject) {\n    try {\n        const publicKeyBuffer = response.getPublicKey();\n        if (!publicKeyBuffer)\n            throw new Registration.CreateFailedError();\n        // Converting `publicKeyBuffer` throws when credential is created by 1Password Firefox Add-on\n        const publicKeyBytes = new Uint8Array(publicKeyBuffer);\n        const cryptoKey = await crypto.subtle.importKey('spki', new Uint8Array(publicKeyBytes), {\n            name: 'ECDSA',\n            namedCurve: 'P-256',\n            hash: 'SHA-256',\n        }, true, ['verify']);\n        const publicKey = new Uint8Array(await crypto.subtle.exportKey('raw', cryptoKey));\n        return PublicKey.from(publicKey);\n    }\n    catch (error) {\n        // Fallback for 1Password Firefox Add-on restricts access to certain credential properties\n        // so we need to use `attestationObject` to extract the public key.\n        // https://github.com/passwordless-id/webauthn/issues/50#issuecomment-2072902094\n        if (error.message !== 'Permission denied to access object')\n            throw error;\n        const data = new Uint8Array(attestationObject ?? response.attestationObject);\n        const coordinateLength = 0x20;\n        const cborPrefix = 0x58;\n        const findStart = (key) => {\n            const coordinate = new Uint8Array([key, cborPrefix, coordinateLength]);\n            for (let i = 0; i < data.length - coordinate.length; i++)\n                if (coordinate.every((byte, j) => data[i + j] === byte))\n                    return i + coordinate.length;\n            throw new Registration.CreateFailedError();\n        };\n        const xStart = findStart(0x21);\n        const yStart = findStart(0x22);\n        return PublicKey.from(new Uint8Array([\n            0x04,\n            ...data.slice(xStart, xStart + coordinateLength),\n            ...data.slice(yStart, yStart + coordinateLength),\n        ]));\n    }\n}\n//# sourceMappingURL=webauthn.js.map","import * as Base64 from '../core/Base64.js';\nimport * as Bytes from '../core/Bytes.js';\nimport * as Errors from '../core/Errors.js';\nimport * as Hash from '../core/Hash.js';\nimport * as Hex from '../core/Hex.js';\nimport * as internal from '../core/internal/webauthn.js';\nimport * as P256 from '../core/P256.js';\nimport * as Signature from '../core/Signature.js';\nimport { getAuthenticatorData, getClientDataJSON } from './Authenticator.js';\nimport { base64UrlOptions, bufferSourceToBytes, bytesToArrayBuffer, deserializeExtensions, responseKeys, serializeExtensions, } from './internal/utils.js';\n/**\n * Deserializes credential request options that can be passed to\n * `navigator.credentials.get()`.\n *\n * @example\n * ```ts twoslash\n * import { Authentication } from 'ox/webauthn'\n *\n * const options = Authentication.getOptions({\n *   challenge: '0xdeadbeef',\n * })\n * const serialized = Authentication.serializeOptions(options)\n *\n * // ... send to server and back ...\n *\n * const deserialized = Authentication.deserializeOptions(serialized) // [!code focus]\n * const credential = await window.navigator.credentials.get(deserialized)\n * ```\n *\n * @param options - The serialized credential request options.\n * @returns The deserialized credential request options.\n */\nexport function deserializeOptions(options) {\n    const { publicKey, ...rest } = options;\n    if (!publicKey)\n        return { ...rest };\n    const { allowCredentials, challenge, extensions, ...publicKeyRest } = publicKey;\n    return {\n        ...rest,\n        publicKey: {\n            ...publicKeyRest,\n            challenge: Bytes.fromHex(challenge),\n            ...(allowCredentials && {\n                allowCredentials: allowCredentials.map(({ id, ...rest }) => ({\n                    ...rest,\n                    id: Base64.toBytes(id),\n                })),\n            }),\n            ...(extensions && {\n                extensions: deserializeExtensions(extensions),\n            }),\n        },\n    };\n}\n/**\n * Deserializes a serialized authentication response.\n *\n * @example\n * ```ts twoslash\n * import { Authentication } from 'ox/webauthn'\n *\n * const response = Authentication.deserializeResponse({ // [!code focus]\n *   id: 'm1-bMPuAqpWhCxHZQZTT6e-lSPntQbh3opIoGe7g4Qs', // [!code focus]\n *   metadata: { // [!code focus]\n *     authenticatorData: '0x49960de5...', // [!code focus]\n *     clientDataJSON: '{\"type\":\"webauthn.get\",...}', // [!code focus]\n *     challengeIndex: 23, // [!code focus]\n *     typeIndex: 1, // [!code focus]\n *     userVerificationRequired: true, // [!code focus]\n *   }, // [!code focus]\n *   raw: { // [!code focus]\n *     id: 'm1-bMPuAqpWhCxHZQZTT6e-lSPntQbh3opIoGe7g4Qs', // [!code focus]\n *     type: 'public-key', // [!code focus]\n *     authenticatorAttachment: 'platform', // [!code focus]\n *     rawId: 'm1-bMPuAqpWhCxHZQZTT6e-lSPntQbh3opIoGe7g4Qs', // [!code focus]\n *     response: { clientDataJSON: 'eyJ0eXBlIjoid2ViYXV0aG4uZ2V0In0' }, // [!code focus]\n *   }, // [!code focus]\n *   signature: '0x...', // [!code focus]\n * }) // [!code focus]\n * ```\n *\n * @param response - The serialized authentication response.\n * @returns The deserialized authentication response.\n */\nexport function deserializeResponse(response) {\n    const { id, metadata, raw, signature } = response;\n    const rawResponse = {};\n    for (const [key, value] of Object.entries(raw.response))\n        rawResponse[key] = bytesToArrayBuffer(Base64.toBytes(value));\n    return {\n        id,\n        metadata,\n        raw: {\n            id: raw.id,\n            type: raw.type,\n            authenticatorAttachment: raw.authenticatorAttachment,\n            rawId: bytesToArrayBuffer(Base64.toBytes(raw.rawId)),\n            response: rawResponse,\n            getClientExtensionResults: () => ({}),\n        },\n        signature: Signature.from(signature),\n    };\n}\n/**\n * Returns the request options to sign a challenge with the Web Authentication API.\n *\n * @example\n * ```ts twoslash\n * import { Authentication } from 'ox/webauthn'\n *\n * const options = Authentication.getOptions({\n *   challenge: '0xdeadbeef',\n * })\n *\n * const credential = await window.navigator.credentials.get(options)\n * ```\n *\n * @param options - Options.\n * @returns The credential request options.\n */\nexport function getOptions(options) {\n    const { credentialId, challenge, extensions, rpId = window.location.hostname, userVerification = 'required', } = options;\n    return {\n        publicKey: {\n            ...(credentialId\n                ? {\n                    allowCredentials: Array.isArray(credentialId)\n                        ? credentialId.map((id) => ({\n                            id: Base64.toBytes(id),\n                            type: 'public-key',\n                        }))\n                        : [\n                            {\n                                id: Base64.toBytes(credentialId),\n                                type: 'public-key',\n                            },\n                        ],\n                }\n                : {}),\n            challenge: Bytes.fromHex(challenge),\n            ...(extensions && { extensions }),\n            rpId,\n            userVerification,\n        },\n    };\n}\n/**\n * Constructs the final digest that was signed and computed by the authenticator. This payload includes\n * the cryptographic `challenge`, as well as authenticator metadata (`authenticatorData` + `clientDataJSON`).\n * This value can be also used with raw P256 verification (such as `P256.verify` or\n * `WebCryptoP256.verify`).\n *\n * :::warning\n *\n * This function is mainly for testing purposes or for manually constructing\n * signing payloads. In most cases you will not need this function and\n * instead use `Authentication.sign`.\n *\n * :::\n *\n * @example\n * ```ts twoslash\n * import { Authentication } from 'ox/webauthn'\n * import { WebCryptoP256 } from 'ox'\n *\n * const { metadata, payload } = Authentication.getSignPayload({ // [!code focus]\n *   challenge: '0xdeadbeef', // [!code focus]\n * }) // [!code focus]\n *\n * const { publicKey, privateKey } = await WebCryptoP256.createKeyPair()\n *\n * const signature = await WebCryptoP256.sign({\n *   payload,\n *   privateKey,\n * })\n * ```\n *\n * @param options - Options to construct the signing payload.\n * @returns The signing payload.\n */\nexport function getSignPayload(options) {\n    const { challenge, crossOrigin, extraClientData, flag, origin, rpId, signCount, userVerification = 'required', } = options;\n    const authenticatorData = getAuthenticatorData({\n        flag,\n        rpId,\n        signCount,\n    });\n    const clientDataJSON = getClientDataJSON({\n        challenge,\n        crossOrigin,\n        extraClientData,\n        origin,\n    });\n    const clientDataJSONHash = Hash.sha256(Hex.fromString(clientDataJSON));\n    const challengeIndex = clientDataJSON.indexOf('\"challenge\"');\n    const typeIndex = clientDataJSON.indexOf('\"type\"');\n    const metadata = {\n        authenticatorData,\n        clientDataJSON,\n        challengeIndex,\n        typeIndex,\n        userVerificationRequired: userVerification === 'required',\n    };\n    const payload = Hex.concat(authenticatorData, clientDataJSONHash);\n    return { metadata, payload };\n}\n/**\n * Serializes credential request options into a JSON-serializable\n * format, converting `BufferSource` fields to base64url strings.\n *\n * @example\n * ```ts twoslash\n * import { Authentication } from 'ox/webauthn'\n *\n * const options = Authentication.getOptions({\n *   challenge: '0xdeadbeef',\n * })\n *\n * const serialized = Authentication.serializeOptions(options) // [!code focus]\n *\n * // `serialized` is JSON-serializable — send it to a server, store it, etc.\n * const json = JSON.stringify(serialized)\n * ```\n *\n * @param options - The credential request options to serialize.\n * @returns The serialized credential request options.\n */\nexport function serializeOptions(options) {\n    const { publicKey, signal: _, ...rest } = options;\n    if (!publicKey)\n        return { ...rest };\n    const { allowCredentials, challenge, extensions, ...publicKeyRest } = publicKey;\n    return {\n        ...rest,\n        publicKey: {\n            ...publicKeyRest,\n            challenge: Hex.fromBytes(bufferSourceToBytes(challenge)),\n            ...(allowCredentials && {\n                allowCredentials: allowCredentials.map(({ id, ...rest }) => ({\n                    ...rest,\n                    id: Base64.fromBytes(bufferSourceToBytes(id), base64UrlOptions),\n                })),\n            }),\n            ...(extensions && {\n                extensions: serializeExtensions(extensions),\n            }),\n        },\n    };\n}\n/**\n * Serializes an authentication response into a JSON-serializable\n * format, converting `BufferSource` fields to base64url strings\n * and the signature to a hex string.\n *\n * @example\n * ```ts twoslash\n * import { Authentication } from 'ox/webauthn'\n *\n * const response = await Authentication.sign({\n *   challenge: '0xdeadbeef',\n * })\n *\n * const serialized = Authentication.serializeResponse(response) // [!code focus]\n *\n * // `serialized` is JSON-serializable — send it to a server, store it, etc.\n * const json = JSON.stringify(serialized)\n * ```\n *\n * @param response - The authentication response to serialize.\n * @returns The serialized authentication response.\n */\nexport function serializeResponse(response) {\n    const { id, metadata, raw, signature } = response;\n    const rawResponse = {};\n    for (const key of responseKeys) {\n        const r = raw.response;\n        let value = r[key];\n        if (!(value instanceof ArrayBuffer)) {\n            const getter = `get${key[0].toUpperCase()}${key.slice(1)}`;\n            const fn = r[getter];\n            if (typeof fn === 'function')\n                value = fn.call(r);\n        }\n        if (value instanceof ArrayBuffer)\n            rawResponse[key] = Base64.fromBytes(new Uint8Array(value), base64UrlOptions);\n    }\n    return {\n        id,\n        metadata,\n        raw: {\n            id: raw.id,\n            type: raw.type,\n            authenticatorAttachment: raw.authenticatorAttachment,\n            rawId: Base64.fromBytes(bufferSourceToBytes(raw.rawId), base64UrlOptions),\n            response: rawResponse,\n        },\n        signature: Signature.toHex(signature),\n    };\n}\n/**\n * Signs a challenge using a stored WebAuthn P256 Credential. If no Credential is provided,\n * a prompt will be displayed for the user to select an existing Credential\n * that was previously registered.\n *\n * @example\n * ```ts twoslash\n * import { Registration, Authentication } from 'ox/webauthn'\n *\n * const credential = await Registration.create({\n *   name: 'Example',\n * })\n *\n * const { metadata, signature } = await Authentication.sign({ // [!code focus]\n *   credentialId: credential.id, // [!code focus]\n *   challenge: '0xdeadbeef', // [!code focus]\n * }) // [!code focus]\n * // @log: {\n * // @log:   metadata: {\n * // @log:     authenticatorData: '0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97630500000000',\n * // @log:     clientDataJSON: '{\"type\":\"webauthn.get\",\"challenge\":\"9jEFijuhEWrM4SOW-tChJbUEHEP44VcjcJ-Bqo1fTM8\",\"origin\":\"http://localhost:5173\",\"crossOrigin\":false}',\n * // @log:     challengeIndex: 23,\n * // @log:     typeIndex: 1,\n * // @log:     userVerificationRequired: true,\n * // @log:   },\n * // @log:   signature: { r: 51231...4215n, s: 12345...6789n },\n * // @log: }\n * ```\n *\n * @param options - Options.\n * @returns The signature.\n */\nexport async function sign(options) {\n    const { getFn = (opts) => window.navigator.credentials.get(opts), ...rest } = options;\n    const requestOptions = 'publicKey' in rest\n        ? rest\n        : getOptions(rest);\n    try {\n        const credential = (await getFn(requestOptions));\n        if (!credential)\n            throw new SignFailedError();\n        const response = credential.response;\n        // Eagerly copy ArrayBuffer data to avoid cross-origin access errors\n        // when browser extensions (e.g. 1Password on Firefox) replace\n        // `navigator.credentials` with a cross-compartment proxy.\n        const clientDataJSONBytes = new Uint8Array(response.clientDataJSON);\n        const authenticatorDataBytes = new Uint8Array(response.authenticatorData);\n        const signatureBytes = new Uint8Array(response.signature);\n        const id = credential.id;\n        const clientDataJSON = String.fromCharCode(...clientDataJSONBytes);\n        const challengeIndex = clientDataJSON.indexOf('\"challenge\"');\n        const typeIndex = clientDataJSON.indexOf('\"type\"');\n        const signature = internal.parseAsn1Signature(signatureBytes);\n        return {\n            id,\n            metadata: {\n                authenticatorData: Hex.fromBytes(authenticatorDataBytes),\n                clientDataJSON,\n                challengeIndex,\n                typeIndex,\n                userVerificationRequired: requestOptions.publicKey.userVerification === 'required',\n            },\n            signature,\n            raw: credential,\n        };\n    }\n    catch (error) {\n        throw new SignFailedError({\n            cause: error,\n        });\n    }\n}\n/** Thrown when a WebAuthn P256 credential request fails. */\nexport class SignFailedError extends Errors.BaseError {\n    constructor({ cause } = {}) {\n        super('Failed to request credential.', {\n            cause,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Authentication.SignFailedError'\n        });\n    }\n}\n/**\n * Verifies a signature using the Credential's public key and the challenge which was signed.\n *\n * @example\n * ```ts twoslash\n * import { Registration, Authentication } from 'ox/webauthn'\n *\n * const credential = await Registration.create({\n *   name: 'Example',\n * })\n *\n * const { metadata, signature } = await Authentication.sign({\n *   credentialId: credential.id,\n *   challenge: '0xdeadbeef',\n * })\n *\n * const result = Authentication.verify({ // [!code focus]\n *   metadata, // [!code focus]\n *   challenge: '0xdeadbeef', // [!code focus]\n *   publicKey: credential.publicKey, // [!code focus]\n *   signature, // [!code focus]\n * }) // [!code focus]\n * // @log: true\n * ```\n *\n * @param options - Options.\n * @returns Whether the signature is valid.\n */\nexport function verify(options) {\n    const { challenge, metadata, origin, publicKey, rpId, signature } = options;\n    const { authenticatorData, clientDataJSON, userVerificationRequired } = metadata;\n    const authenticatorDataBytes = Bytes.fromHex(authenticatorData);\n    // Check length of `authenticatorData`.\n    if (authenticatorDataBytes.length < 37)\n        return false;\n    // If rpId is provided, validate the rpIdHash in authenticatorData.\n    if (rpId !== undefined) {\n        const rpIdHash = authenticatorDataBytes.slice(0, 32);\n        const expectedRpIdHash = Hash.sha256(Hex.fromString(rpId), { as: 'Bytes' });\n        if (!Bytes.isEqual(rpIdHash, expectedRpIdHash))\n            return false;\n    }\n    const flag = authenticatorDataBytes[32];\n    // Verify that the UP bit of the flags in authData is set.\n    if ((flag & 0x01) !== 0x01)\n        return false;\n    // If user verification was determined to be required, verify that\n    // the UV bit of the flags in authData is set. Otherwise, ignore the\n    // value of the UV flag.\n    if (userVerificationRequired && (flag & 0x04) !== 0x04)\n        return false;\n    // If the BE bit of the flags in authData is not set, verify that\n    // the BS bit is not set.\n    if ((flag & 0x08) !== 0x08 && (flag & 0x10) === 0x10)\n        return false;\n    // Parse clientDataJSON for validation.\n    const clientData = JSON.parse(clientDataJSON);\n    // Verify that response is for an authentication assertion.\n    if (clientData.type !== 'webauthn.get')\n        return false;\n    // Validate the challenge in the clientDataJSON.\n    if (!clientData.challenge ||\n        Hex.fromBytes(Base64.toBytes(clientData.challenge)) !== challenge)\n        return false;\n    // If origin is provided, validate origin.\n    if (origin !== undefined) {\n        const origins = Array.isArray(origin) ? origin : [origin];\n        if (!origins.includes(clientData.origin))\n            return false;\n    }\n    const clientDataJSONHash = Hash.sha256(Bytes.fromString(clientDataJSON), {\n        as: 'Bytes',\n    });\n    const payload = Bytes.concat(authenticatorDataBytes, clientDataJSONHash);\n    return P256.verify({\n        hash: true,\n        payload,\n        publicKey,\n        signature,\n    });\n}\n//# sourceMappingURL=Authentication.js.map"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],"mappings":"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"}

package/dist/app/server/assets/Authentication-C3oNZAVX.js

@@ -0,0 +1,2 @@
+import{a as e}from"./rolldown-runtime-BWaJ3C7D.js";import{a as t,o as n,t as r}from"./Authentication-BOkhlNQu.js";import{E as i}from"./react-dom-DYzj0HXX.js";import{E as a,T as o,b as s,c,h as l,i as u,j as d,o as f,t as p}from"./removable-BCLTvPOx.js";var m=class extends p{#e;#t;#n;#r;constructor(e){super(),this.#e=e.client,this.mutationId=e.mutationId,this.#n=e.mutationCache,this.#t=[],this.state=e.state||h(),this.setOptions(e.options),this.scheduleGc()}setOptions(e){this.options=e,this.updateGcTime(this.options.gcTime)}get meta(){return this.options.meta}addObserver(e){this.#t.includes(e)||(this.#t.push(e),this.clearGcTimeout(),this.#n.notify({type:`observerAdded`,mutation:this,observer:e}))}removeObserver(e){this.#t=this.#t.filter(t=>t!==e),this.scheduleGc(),this.#n.notify({type:`observerRemoved`,mutation:this,observer:e})}optionalRemove(){this.#t.length||(this.state.status===`pending`?this.scheduleGc():this.#n.remove(this))}continue(){return this.#r?.continue()??(this.state.status===`pending`?this.execute(this.state.variables):Promise.resolve())}async execute(e){let t=()=>{this.#i({type:`continue`})},n={client:this.#e,meta:this.options.meta,mutationKey:this.options.mutationKey},r=this.#r=u({fn:()=>this.options.mutationFn?this.options.mutationFn(e,n):Promise.reject(Error(`No mutationFn found`)),onFail:(e,t)=>{this.#i({type:`failed`,failureCount:e,error:t})},onPause:()=>{this.#i({type:`pause`})},onContinue:t,retry:this.options.retry??0,retryDelay:this.options.retryDelay,networkMode:this.options.networkMode,canRun:()=>this.#n.canRun(this)}),i=this.state.status===`pending`,a=!r.canStart();try{if(i)t();else{this.#i({type:`pending`,variables:e,isPaused:a}),this.#n.config.onMutate&&await this.#n.config.onMutate(e,this,n);let t=await this.options.onMutate?.(e,n);t!==this.state.context&&this.#i({type:`pending`,context:t,variables:e,isPaused:a})}let o=await r.start();return await this.#n.config.onSuccess?.(o,e,this.state.context,this,n),await this.options.onSuccess?.(o,e,this.state.context,n),await this.#n.config.onSettled?.(o,null,this.state.variables,this.state.context,this,n),await this.options.onSettled?.(o,null,e,this.state.context,n),this.#i({type:`success`,data:o}),o}catch(t){try{await this.#n.config.onError?.(t,e,this.state.context,this,n)}catch(e){Promise.reject(e)}try{await this.options.onError?.(t,e,this.state.context,n)}catch(e){Promise.reject(e)}try{await this.#n.config.onSettled?.(void 0,t,this.state.variables,this.state.context,this,n)}catch(e){Promise.reject(e)}try{await this.options.onSettled?.(void 0,t,e,this.state.context,n)}catch(e){Promise.reject(e)}throw this.#i({type:`error`,error:t}),t}finally{this.#r===r&&(this.#r=void 0),this.#n.runNext(this)}}#i(e){let t=t=>{switch(e.type){case`failed`:return{...t,failureCount:e.failureCount,failureReason:e.error};case`pause`:return{...t,isPaused:!0};case`continue`:return{...t,isPaused:!1};case`pending`:return{...t,context:e.context,data:void 0,failureCount:0,failureReason:null,error:null,isPaused:e.isPaused,status:`pending`,variables:e.variables,submittedAt:Date.now()};case`success`:return{...t,data:e.data,failureCount:0,failureReason:null,error:null,status:`success`,isPaused:!1};case`error`:return{...t,data:void 0,error:e.error,failureCount:t.failureCount+1,failureReason:e.error,isPaused:!1,status:`error`}}};this.state=t(this.state),f.batch(()=>{this.#t.forEach(t=>{t.onMutationUpdate(e)}),this.#n.notify({mutation:this,type:`updated`,action:e})})}};function h(){return{context:void 0,data:void 0,error:null,failureCount:0,failureReason:null,isPaused:!1,status:`idle`,variables:void 0,submittedAt:0}}var g=class extends c{#e;#t=void 0;#n;#r;constructor(e,t){super(),this.#e=e,this.setOptions(t),this.bindMethods(),this.#i()}bindMethods(){this.mutate=this.mutate.bind(this),this.reset=this.reset.bind(this)}setOptions(e){let t=this.options;this.options=this.#e.defaultMutationOptions(e),o(this.options,t)||this.#e.getMutationCache().notify({type:`observerOptionsUpdated`,mutation:this.#n,observer:this}),t?.mutationKey&&this.options.mutationKey&&l(t.mutationKey)!==l(this.options.mutationKey)?this.reset():this.#n?.state.status===`pending`&&this.#n.setOptions(this.options)}onSubscribe(){this.listeners.size===1&&this.#n&&(this.#n.addObserver(this),this.#i())}onUnsubscribe(){this.hasListeners()||this.#n?.removeObserver(this)}onMutationUpdate(e){this.#i(),this.#a(e)}getCurrentResult(){return this.#t}reset(){this.#n?.removeObserver(this),this.#n=void 0,this.#i(),this.#a()}mutate(e,t){return this.#r=t,this.#n?.removeObserver(this),this.#n=this.#e.getMutationCache().build(this.#e,this.options),this.#n.addObserver(this),this.#n.execute(e)}#i(){let e=this.#n?.state??h();this.#t={...e,isPending:e.status===`pending`,isSuccess:e.status===`success`,isError:e.status===`error`,isIdle:e.status===`idle`,mutate:this.mutate,reset:this.reset}}#a(e){f.batch(()=>{if(this.#r&&this.hasListeners()){let t=this.#t.variables,n=this.#t.context,r={client:this.#e,meta:this.options.meta,mutationKey:this.options.mutationKey};if(e?.type===`success`){try{this.#r.onSuccess?.(e.data,t,n,r)}catch(e){Promise.reject(e)}try{this.#r.onSettled?.(e.data,null,t,n,r)}catch(e){Promise.reject(e)}}else if(e?.type===`error`){try{this.#r.onError?.(e.error,t,n,r)}catch(e){Promise.reject(e)}try{this.#r.onSettled?.(void 0,e.error,t,n,r)}catch(e){Promise.reject(e)}}}this.listeners.forEach(e=>{e(this.#t)})})}},_=e(i(),1);function v(e,t){let n=d(t),[r]=_.useState(()=>new g(n,e));_.useEffect(()=>{r.setOptions(e)},[r,e]);let i=_.useSyncExternalStore(_.useCallback(e=>r.subscribe(f.batchCalls(e)),[r]),()=>r.getCurrentResult(),()=>r.getCurrentResult()),o=_.useCallback((...e)=>{r.mutate(e[0],e[1]).catch(s)},[r]);if(i.error&&a(r.options.throwOnError,[i.error]))throw i.error;return{...i,mutate:o,mutateAsync:i.mutate}}async function y(e){let i=await(()=>{if(`options`in e){let t=r(e.options);return n({...t,getFn:e.getFn})}return n(e)})();return t(i)}export{v as n,m as r,y as t};
+//# sourceMappingURL=Authentication-C3oNZAVX.js.map