{
  "version": 3,
  "sources": ["../src/aes.ts", "../src/helpers/hex-to-bytes.ts", "../src/constants.ts", "../src/ecdh.ts", "../src/helpers/validators.ts", "../src/ecdsa.ts", "../src/helpers/encoding.ts", "../src/helpers/util.ts", "../src/hmac.ts", "../src/random.ts", "../src/internal/sha512.ts", "../src/ecies.ts"],
  "sourcesContent": ["import * as aesJs from \"aes-js\";\nimport {\n  ERROR_AES_IV_LENGTH,\n  ERROR_AES_KEY_LENGTH,\n  IV_LENGTH,\n  KEY_LENGTH,\n} from \"./constants\";\n\nconst { ModeOfOperation } = aesJs;\n\nfunction bytesToAesNumberArray(buf: Uint8Array): number[] {\n  return Array.from(buf);\n}\n\nfunction assertAesLengths(iv: Uint8Array, key: Uint8Array): void {\n  if (iv.length !== IV_LENGTH) {\n    throw new Error(ERROR_AES_IV_LENGTH);\n  }\n  if (key.length !== KEY_LENGTH) {\n    throw new Error(ERROR_AES_KEY_LENGTH);\n  }\n}\n\n/**\n * Encrypts data using AES-256-CBC.\n * @param iv Initialization vector (16 bytes).\n * @param key Encryption key (32 bytes).\n * @param data Plaintext bytes.\n * @returns Ciphertext bytes with PKCS#7 padding applied.\n */\nexport async function aesCbcEncrypt(\n  iv: Uint8Array,\n  key: Uint8Array,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  return aesCbcEncryptSync(iv, key, data);\n}\n\n/**\n * Decrypts data using AES-256-CBC.\n * @param iv Initialization vector (16 bytes).\n * @param key Encryption key (32 bytes).\n * @param data Ciphertext bytes.\n * @returns Decrypted plaintext bytes without PKCS#7 padding.\n */\nexport async function aesCbcDecrypt(\n  iv: Uint8Array,\n  key: Uint8Array,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  return aesCbcDecryptSync(iv, key, data);\n}\n\n/**\n * Encrypts data using AES-256-CBC.\n * @param iv Initialization vector (16 bytes).\n * @param key Encryption key (32 bytes).\n * @param data Plaintext bytes.\n * @returns Ciphertext bytes with PKCS#7 padding applied.\n */\nexport function aesCbcEncryptSync(\n  iv: Uint8Array,\n  key: Uint8Array,\n  data: Uint8Array\n): Uint8Array {\n  assertAesLengths(iv, key);\n  const padded = pkcs7Pad(data, IV_LENGTH);\n  const cbc = new ModeOfOperation.cbc(\n    bytesToAesNumberArray(key),\n    bytesToAesNumberArray(iv)\n  );\n  return new Uint8Array(cbc.encrypt(bytesToAesNumberArray(padded)));\n}\n\n/**\n * Decrypts data using AES-256-CBC.\n * @param iv Initialization vector (16 bytes).\n * @param key Encryption key (32 bytes).\n * @param data Ciphertext bytes.\n * @returns Decrypted plaintext bytes without PKCS#7 padding.\n */\nexport function aesCbcDecryptSync(\n  iv: Uint8Array,\n  key: Uint8Array,\n  data: Uint8Array\n): Uint8Array {\n  assertAesLengths(iv, key);\n  const cbc = new ModeOfOperation.cbc(\n    bytesToAesNumberArray(key),\n    bytesToAesNumberArray(iv)\n  );\n  const decrypted = new Uint8Array(cbc.decrypt(bytesToAesNumberArray(data)));\n  return pkcs7Unpad(decrypted, IV_LENGTH);\n}\n\n/**\n * Applies PKCS#7 padding to a byte array.\n * @param data Input bytes.\n * @param blockSize Cipher block size in bytes.\n * @returns Padded byte array.\n */\nfunction pkcs7Pad(data: Uint8Array, blockSize: number): Uint8Array {\n  const pad = blockSize - (data.length % blockSize);\n  const out = new Uint8Array(data.length + pad);\n  out.set(data);\n  out.fill(pad, data.length);\n  return out;\n}\n\n/**\n * Removes PKCS#7 padding from a byte array.\n * @param data Input bytes with PKCS#7 padding.\n * @returns Unpadded byte array.\n * @throws Error if padding is invalid.\n */\nfunction pkcs7Unpad(data: Uint8Array, blockSize: number): Uint8Array {\n  const padByte =\n    data.length === 0 ? undefined : data[data.length - 1];\n  if (padByte === undefined) {\n    throw new Error(\"PKCS#7: empty data\");\n  }\n  const pad = padByte;\n  if (pad < 1 || pad > blockSize || pad > data.length) {\n    throw new Error(\"PKCS#7: invalid padding\");\n  }\n  for (let i = data.length - pad; i < data.length; i++) {\n    if (data[i] !== pad) {\n      throw new Error(\"PKCS#7: invalid padding\");\n    }\n  }\n  return data.slice(0, data.length - pad);\n}\n", "/**\n * Hex string \u2192 byte values `0..255`. Odd length implies a leading `0` nibble (unlike {@link hexToBuffer}).\n *\n * @param hex Contiguous hex digits (no `0x` stripping).\n * @returns `number[]` of byte values.\n */\nexport function hexToBytes(hex: string): number[] {\n  const clean = hex.length % 2 ? `0${hex}` : hex;\n  const out: number[] = [];\n  for (let i = 0; i < clean.length; i += 2) {\n    out.push(Number.parseInt(clean.slice(i, i + 2), 16));\n  }\n  return out;\n}\n", "import { hexToBytes } from \"./helpers/hex-to-bytes\";\n\nexport const HEX_ENC = \"hex\";\nexport const UTF8_ENC = \"utf8\";\nexport const BINARY_ENC = \"binary\";\n\nexport const ENCRYPT_OP = \"encrypt\";\nexport const DECRYPT_OP = \"decrypt\";\n\nexport const SIGN_OP = \"sign\";\nexport const VERIFY_OP = \"verify\";\n\nexport const LENGTH_0 = 0;\nexport const LENGTH_1 = 1;\nexport const LENGTH_12 = 12;\nexport const LENGTH_16 = 16;\nexport const LENGTH_32 = 32;\nexport const LENGTH_64 = 64;\nexport const LENGTH_128 = 128;\nexport const LENGTH_256 = 256;\nexport const LENGTH_512 = 512;\nexport const LENGTH_1024 = 1024;\n\nexport const AES_LENGTH = LENGTH_256;\nexport const HMAC_LENGTH = LENGTH_256;\n\nexport const AES_BROWSER_ALGO = \"AES-CBC\";\nexport const HMAC_BROWSER_ALGO = `SHA-${AES_LENGTH}`;\nexport const HMAC_BROWSER = \"HMAC\";\n\nexport const SHA256_BROWSER_ALGO = \"SHA-256\";\nexport const SHA512_BROWSER_ALGO = \"SHA-512\";\n\nexport const AES_NODE_ALGO = `aes-${AES_LENGTH}-cbc`;\nexport const HMAC_NODE_ALGO = `sha${HMAC_LENGTH}`;\n\nexport const SHA256_NODE_ALGO = \"sha256\";\nexport const SHA512_NODE_ALGO = \"sha512\";\nexport const RIPEMD160_NODE_ALGO = \"ripemd160\";\n\nexport const PBKDF2_DIGEST_SHA256 = SHA256_NODE_ALGO;\nexport const PBKDF2_DIGEST_SHA512 = SHA512_NODE_ALGO;\n\nexport const PREFIX_LENGTH = LENGTH_1;\nexport const KEY_LENGTH = LENGTH_32;\nexport const IV_LENGTH = LENGTH_16;\nexport const AES_GCM_NONCE_LENGTH = LENGTH_12;\nexport const AES_GCM_ENVELOPE_NONCE_MAX_LENGTH = LENGTH_128;\nexport const AES_GCM_TAG_LENGTH = LENGTH_16;\nexport const MAC_LENGTH = LENGTH_32;\nexport const DECOMPRESSED_LENGTH = LENGTH_64;\n\nexport const PREFIXED_KEY_LENGTH = KEY_LENGTH + PREFIX_LENGTH;\nexport const PREFIXED_DECOMPRESSED_LENGTH = DECOMPRESSED_LENGTH + PREFIX_LENGTH;\n\nexport const ECIES_SERIALIZED_MIN_LENGTH =\n  IV_LENGTH + PREFIXED_KEY_LENGTH + MAC_LENGTH;\n\nexport const MAX_KEY_LENGTH = LENGTH_1024;\nexport const PBKDF2_DEFAULT_ITERATIONS = 210_000;\nexport const MAX_MSG_LENGTH = LENGTH_32;\n\nexport const EMPTY_BUFFER = new Uint8Array(LENGTH_0);\n\nexport const EC_GROUP_ORDER = new Uint8Array(\n  hexToBytes(\n    \"fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141\"\n  )\n);\n\nexport const ZERO32 = new Uint8Array(LENGTH_32).fill(LENGTH_0);\n\nexport const ERROR_BAD_MAC = \"Bad MAC\";\nexport const ERROR_BAD_SIGNATURE = \"Bad signature\";\nexport const ERROR_BAD_PRIVATE_KEY = \"Bad private key\";\nexport const ERROR_BAD_PUBLIC_KEY = \"Bad public key\";\nexport const ERROR_ECIES_SERIALIZED_LENGTH =\n  \"ECIES deserialize: buffer shorter than minimum serialized length\";\n\nexport const ERROR_EMPTY_MESSAGE = \"Message should not be empty\";\nexport const ERROR_MESSAGE_TOO_LONG = \"Message is too long\";\n\nexport const ERROR_BAD_EPHEM_PRIVATE_KEY = \"Invalid ephemeral private key\";\n\nexport const ERROR_AES_IV_LENGTH = \"AES-CBC: IV must be 16 bytes\";\nexport const ERROR_AES_KEY_LENGTH = \"AES-CBC: key must be 32 bytes\";\n\nexport const ERROR_AES_GCM_KEY_LENGTH =\n  \"AES-GCM: key must be 16, 24, or 32 bytes\";\nexport const ERROR_AES_GCM_NONCE_LENGTH =\n  \"AES-GCM: nonce must be at least 8 bytes\";\nexport const ERROR_AES_GCM_CIPHERTEXT_LENGTH =\n  \"AES-GCM: ciphertext must be longer than the authentication tag\";\n", "import { Point, etc } from \"@noble/secp256k1\";\nimport { checkPrivateKey, checkPublicKey } from \"./helpers/validators\";\nimport { decompress } from \"./ecdsa\";\n\n/**\n * Derives a shared secret using ECDH over secp256k1.\n * @param privateKeyA Local private key (32 bytes).\n * @param publicKeyB Remote public key (compressed or uncompressed SEC1 format).\n * @returns 32-byte x coordinate of the shared point.\n */\nexport function derive(\n  privateKeyA: Uint8Array,\n  publicKeyB: Uint8Array\n): Uint8Array {\n  checkPrivateKey(privateKeyA);\n  checkPublicKey(publicKeyB);\n  const pub = decompress(publicKeyB);\n  const affine = Point.fromBytes(pub)\n    .multiply(etc.secretKeyToScalar(privateKeyA))\n    .toAffine();\n  return etc.numberToBytesBE(affine.x);\n}\n", "import {\n  EC_GROUP_ORDER,\n  ERROR_BAD_PRIVATE_KEY,\n  ERROR_BAD_PUBLIC_KEY,\n  ERROR_EMPTY_MESSAGE,\n  ERROR_MESSAGE_TOO_LONG,\n  KEY_LENGTH,\n  LENGTH_0,\n  MAX_KEY_LENGTH,\n  MAX_MSG_LENGTH,\n  PREFIXED_DECOMPRESSED_LENGTH,\n  PREFIXED_KEY_LENGTH,\n  ZERO32,\n} from \"../constants\";\n\n/**\n * Asserts a condition and throws when it fails.\n * @param condition Condition to evaluate.\n * @param message Error message when condition fails.\n */\nexport function assert(condition: boolean, message: string): void {\n  if (!condition) {\n    throw new Error(message || \"Assertion failed\");\n  }\n}\n\n/**\n * Checks whether input is a 32-byte scalar.\n * @param x Input bytes.\n * @returns True when input is a scalar.\n */\nexport function isScalar(x: Uint8Array): boolean {\n  return x instanceof Uint8Array && x.length === 32;\n}\n\n/**\n * Validates a secp256k1 private key range.\n * @param privateKey Private key bytes.\n * @returns True when key is valid.\n */\nexport function isValidPrivateKey(privateKey: Uint8Array): boolean {\n  if (!isScalar(privateKey)) {\n    return false;\n  }\n  return (\n    compareBuffers(privateKey, ZERO32) > 0 &&\n    compareBuffers(privateKey, EC_GROUP_ORDER) < 0\n  );\n}\n\n/**\n * Compares two byte arrays lexicographically.\n * @param a First byte array.\n * @param b Second byte array.\n * @returns -1, 0, or 1 depending on comparison result.\n */\nexport function compareBuffers(a: Uint8Array, b: Uint8Array): number {\n  const len = Math.max(a.length, b.length);\n  for (let i = 0; i < len; i++) {\n    const av = a[i] ?? 0;\n    const bv = b[i] ?? 0;\n    if (av !== bv) {\n      return av < bv ? -1 : 1;\n    }\n  }\n  return 0;\n}\n\n/**\n * Compares two byte arrays in constant time.\n * @param b1 First byte array.\n * @param b2 Second byte array.\n * @returns True when arrays are equal.\n */\nexport function equalConstTime(b1: Uint8Array, b2: Uint8Array): boolean {\n  if (b1.length !== b2.length) {\n    return false;\n  }\n  let res = 0;\n  for (let i = 0; i < b1.length; i++) {\n    res |= b1[i] ^ b2[i];\n  }\n  return res === 0;\n}\n\n/**\n * Validates random key length constraints.\n * @param length Requested length.\n * @returns True when length is valid.\n */\nexport function isValidKeyLength(length: number): boolean {\n  return !(\n    length <= LENGTH_0 ||\n    length > MAX_KEY_LENGTH ||\n    Number.parseInt(String(length), 10) !== length\n  );\n}\n\n/**\n * Validates a private key and throws when invalid.\n * @param privateKey Private key bytes.\n */\nexport function checkPrivateKey(privateKey: Uint8Array): void {\n  assert(privateKey.length === KEY_LENGTH, ERROR_BAD_PRIVATE_KEY);\n  assert(isValidPrivateKey(privateKey), ERROR_BAD_PRIVATE_KEY);\n}\n\n/**\n * Validates a public key and throws when invalid.\n * @param publicKey Public key bytes.\n */\nexport function checkPublicKey(publicKey: Uint8Array): void {\n  assert(\n    publicKey.length === PREFIXED_DECOMPRESSED_LENGTH ||\n      publicKey.length === PREFIXED_KEY_LENGTH,\n    ERROR_BAD_PUBLIC_KEY\n  );\n  if (publicKey.length === PREFIXED_DECOMPRESSED_LENGTH) {\n    assert(publicKey[0] === 4, ERROR_BAD_PUBLIC_KEY);\n  }\n  if (publicKey.length === PREFIXED_KEY_LENGTH) {\n    assert(publicKey[0] === 2 || publicKey[0] === 3, ERROR_BAD_PUBLIC_KEY);\n  }\n}\n\n/**\n * Validates message bytes and throws when invalid.\n * @param msg Message bytes.\n */\nexport function checkMessage(msg: Uint8Array): void {\n  assert(msg.length > 0, ERROR_EMPTY_MESSAGE);\n  assert(msg.length <= MAX_MSG_LENGTH, ERROR_MESSAGE_TOO_LONG);\n}\n", "import { hmac } from \"@noble/hashes/hmac.js\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport * as secp from \"@noble/secp256k1\";\nimport {\n  ERROR_BAD_SIGNATURE,\n  PREFIXED_DECOMPRESSED_LENGTH,\n  PREFIXED_KEY_LENGTH,\n} from \"./constants\";\nimport { derDecodeEcdsaSignature, derEncodeEcdsaSignature } from \"./internal/der\";\nimport type { KeyPair } from \"./helpers/types\";\nimport {\n  isCompressed,\n  isDecompressed,\n  isValidDERSignature,\n} from \"./helpers/util\";\nimport {\n  checkMessage,\n  checkPrivateKey,\n  checkPublicKey,\n} from \"./helpers/validators\";\n\nsecp.hashes.sha256 = sha256;\nsecp.hashes.hmacSha256 = (key: Uint8Array, msg: Uint8Array) =>\n  hmac(sha256, key, msg);\n\n/**\n * Generates a random secp256k1 private key.\n * @returns Private key bytes (32 bytes).\n */\nexport function generatePrivate(): Uint8Array {\n  return secp.utils.randomSecretKey();\n}\n\n/**\n * Converts a public key to compressed SEC1 format.\n * @param publicKey Public key bytes.\n * @returns Compressed public key bytes.\n */\nexport function compress(publicKey: Uint8Array): Uint8Array {\n  if (isCompressed(publicKey)) {\n    checkPublicKey(publicKey);\n    return publicKey;\n  }\n  if (publicKey.length === PREFIXED_DECOMPRESSED_LENGTH) {\n    checkPublicKey(publicKey);\n  }\n  return secp.Point.fromBytes(publicKey).toBytes(true);\n}\n\n/**\n * Converts a public key to uncompressed SEC1 format.\n * @param publicKey Public key bytes.\n * @returns Uncompressed public key bytes.\n */\nexport function decompress(publicKey: Uint8Array): Uint8Array {\n  if (isDecompressed(publicKey)) {\n    if (publicKey.length === PREFIXED_DECOMPRESSED_LENGTH) {\n      checkPublicKey(publicKey);\n    }\n    return publicKey;\n  }\n  if (publicKey.length === PREFIXED_KEY_LENGTH) {\n    checkPublicKey(publicKey);\n  }\n  return secp.Point.fromBytes(publicKey).toBytes(false);\n}\n\n/**\n * Derives an uncompressed public key from a private key.\n * @param privateKey Private key bytes (32 bytes).\n * @returns Uncompressed public key bytes.\n */\nexport function getPublic(privateKey: Uint8Array): Uint8Array {\n  checkPrivateKey(privateKey);\n  return secp.getPublicKey(privateKey, false);\n}\n\n/**\n * Derives a compressed public key from a private key.\n * @param privateKey Private key bytes (32 bytes).\n * @returns Compressed public key bytes.\n */\nexport function getPublicCompressed(privateKey: Uint8Array): Uint8Array {\n  checkPrivateKey(privateKey);\n  return secp.getPublicKey(privateKey, true);\n}\n\n/**\n * Generates a secp256k1 key pair.\n * @returns Object with private and public key bytes.\n */\nexport function generateKeyPair(): KeyPair {\n  const privateKey = generatePrivate();\n  const publicKey = getPublic(privateKey);\n  return { privateKey, publicKey };\n}\n\n/**\n * Converts a compact signature to DER format when needed.\n * @param sig Signature bytes in DER, compact, or recovered format.\n * @returns DER-encoded signature bytes.\n */\nexport function signatureExport(sig: Uint8Array): Uint8Array {\n  if (isValidDERSignature(sig)) {\n    return sig;\n  }\n  const compact = sig.length === 65 ? sig.slice(0, 64) : sig;\n  if (compact.length !== 64) {\n    throw new Error(\"signatureExport: invalid compact signature\");\n  }\n  return derEncodeEcdsaSignature(compact);\n}\n\n/**\n * Signs a message digest with ECDSA.\n * @param privateKey Private key bytes (32 bytes).\n * @param msg Message digest bytes.\n * @param rsvSig If true, returns recovered format (65 bytes); otherwise compact format (64 bytes).\n * @returns Signature bytes.\n */\nexport function sign(\n  privateKey: Uint8Array,\n  msg: Uint8Array,\n  rsvSig = false\n): Uint8Array {\n  checkPrivateKey(privateKey);\n  checkMessage(msg);\n  return secp.sign(msg, privateKey, {\n    prehash: false,\n    format: rsvSig ? \"recovered\" : \"compact\",\n    lowS: false,\n  });\n}\n\n/**\n * Recovers a public key from a signature and message digest.\n * @param msg Message digest bytes.\n * @param sig Recovered signature bytes.\n * @param compressed If true, returns compressed public key format.\n * @returns Recovered public key bytes.\n */\nexport function recover(\n  msg: Uint8Array,\n  sig: Uint8Array,\n  compressed = false\n): Uint8Array {\n  checkMessage(msg);\n  const pub = secp.recoverPublicKey(sig, msg, { prehash: false });\n  return secp.Point.fromBytes(pub).toBytes(compressed);\n}\n\n/**\n * Verifies an ECDSA signature.\n * @param publicKey Public key bytes.\n * @param msg Message digest bytes.\n * @param sig Signature bytes in DER, compact, or recovered format.\n * @throws Error when signature is invalid.\n */\nexport function verify(\n  publicKey: Uint8Array,\n  msg: Uint8Array,\n  sig: Uint8Array\n): void {\n  checkPublicKey(publicKey);\n  checkMessage(msg);\n\n  let sigBytes: Uint8Array;\n  let format: \"compact\" | \"recovered\";\n  if (sig.length === 64) {\n    sigBytes = sig;\n    format = \"compact\";\n  } else if (sig[0] === 0x30) {\n    sigBytes = derDecodeEcdsaSignature(sig);\n    format = \"compact\";\n  } else {\n    sigBytes = sig;\n    format = sig.length === 65 ? \"recovered\" : \"compact\";\n  }\n\n  const ok = secp.verify(sigBytes, msg, publicKey, {\n    prehash: false,\n    format,\n    lowS: false,\n  });\n  if (!ok) throw new Error(ERROR_BAD_SIGNATURE);\n}\n", "import {\n  HEX_ENC,\n  LENGTH_0,\n  LENGTH_16,\n  type UTF8_ENC,\n} from \"../constants\";\n\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder();\n\n/**\n * Encodes a UTF-8 string into bytes.\n * @param str Input string.\n * @returns UTF-8 encoded bytes.\n */\nexport function utf8ToBuffer(str: string): Uint8Array {\n  return textEncoder.encode(str);\n}\n\n/**\n * Decodes UTF-8 bytes into a string.\n * @param buf UTF-8 encoded bytes.\n * @returns Decoded string.\n */\nexport function bufferToUtf8(buf: Uint8Array): string {\n  return textDecoder.decode(buf);\n}\n\n/**\n * Concatenates multiple byte arrays.\n * @param buffers Byte arrays to concatenate.\n * @returns Concatenated byte array.\n */\nexport function concatBuffers(...buffers: Uint8Array[]): Uint8Array {\n  const total = buffers.reduce((n, b) => n + b.length, LENGTH_0);\n  const out = new Uint8Array(total);\n  let offset = LENGTH_0;\n  for (const b of buffers) {\n    out.set(b, offset);\n    offset += b.length;\n  }\n  return out;\n}\n\n/**\n * Converts bytes to a lowercase hex string.\n * @param buf Input bytes.\n * @param enc Output encoding selector. Only `hex` is accepted.\n * @returns Hex string.\n */\nexport function bufferToHex(\n  buf: Uint8Array,\n  enc: typeof HEX_ENC | typeof UTF8_ENC = HEX_ENC\n): string {\n  if (enc !== HEX_ENC) {\n    throw new Error(\"bufferToHex: only hex encoding is supported\");\n  }\n  let hex = \"\";\n  for (const byte of buf) {\n    hex += byte.toString(16).padStart(2, \"0\");\n  }\n  return hex;\n}\n\n/**\n * Converts a hex string to bytes.\n * @param hex Input hex string, with optional `0x` prefix.\n * @returns Decoded bytes.\n */\nexport function hexToBuffer(hex: string): Uint8Array {\n  const clean = hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n  if (clean.length % 2 !== 0) {\n    throw new Error(\"hexToBuffer: invalid length\");\n  }\n  const out = new Uint8Array(clean.length / 2);\n  for (let i = 0; i < out.length; i++) {\n    const byte = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);\n    if (!Number.isFinite(byte) || byte < 0 || byte > 255) {\n      throw new Error(\"hexToBuffer: invalid hex character\");\n    }\n    out[i] = byte;\n  }\n  return out;\n}\n\n/**\n * Removes a leading `0x` prefix from a hex string.\n * @param hex Input hex string.\n * @returns Hex string without prefix.\n */\nexport function sanitizeHex(hex: string): string {\n  return hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n}\n\n/**\n * Removes leading zeros from a hex string.\n * @param hex Input hex string.\n * @returns Hex string without leading zeros.\n */\nexport function removeHexLeadingZeros(hex: string): string {\n  const h = sanitizeHex(hex);\n  const stripped = h.replace(/^0+/, \"\");\n  return stripped.length ? stripped : \"0\";\n}\n\n/**\n * Parses a hex string into a number.\n * @param hex Input hex string.\n * @returns Parsed number.\n */\nexport function hexToNumber(hex: string): number {\n  return Number.parseInt(sanitizeHex(hex), 16);\n}\n\n/**\n * RFC 4648 Base64 from bytes. Chunks `btoa` input to avoid huge spread argument lists.\n *\n * @param buf Input bytes.\n * @returns Base64 string (no line breaks).\n */\nexport function bufferToBase64(buf: Uint8Array): string {\n  const chunk = 0x8000;\n  let binary = \"\";\n  for (let i = 0; i < buf.length; i += chunk) {\n    binary += String.fromCharCode(...buf.subarray(i, i + chunk));\n  }\n  return btoa(binary);\n}\n\n/**\n * RFC 4648 Base64 to bytes (whitespace stripped). Uses `atob`.\n *\n * @param str Base64 string.\n * @returns New `Uint8Array`.\n * @throws {DOMException} Invalid Base64 where `atob` throws.\n */\nexport function base64ToBuffer(str: string): Uint8Array {\n  const normalized = str.replace(/\\s+/g, \"\");\n  const binary = atob(normalized);\n  const out = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    out[i] = binary.charCodeAt(i) & 0xff;\n  }\n  return out;\n}\n\n/**\n * RFC 4648 Base64url without `=` padding (`-`/`_`). Common for JWK `k`.\n *\n * @param buf Input bytes.\n * @returns Base64url string.\n */\nexport function bufferToBase64Url(buf: Uint8Array): string {\n  return bufferToBase64(buf)\n    .replace(/\\+/g, \"-\")\n    .replace(/\\//g, \"_\")\n    .replace(/=+$/, \"\");\n}\n\n/**\n * Base64url to bytes (optional padding; then {@link base64ToBuffer}).\n *\n * @param str Base64url string.\n * @returns New `Uint8Array`.\n * @throws {Error} Length mod 4 === 1 (invalid).\n */\nexport function base64UrlToBuffer(str: string): Uint8Array {\n  let s = str.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  const pad = s.length % 4;\n  if (pad === 2) s += \"==\";\n  else if (pad === 3) s += \"=\";\n  else if (pad === 1) {\n    throw new Error(\"base64UrlToBuffer: invalid length\");\n  }\n  return base64ToBuffer(s);\n}\n\n/**\n * 16-byte AES-128 raw key from `utf8ToBuffer(key.padEnd(16, \" \"))`. Must yield exactly 16 UTF-8 bytes\n * (same constraint as Web Crypto `importKey(\"raw\", \u2026)` for AES-128).\n *\n * @param key Passphrase.\n * @returns 16 key bytes.\n * @throws {Error} UTF-8 length \u2260 16 after padding.\n */\nexport function aes128StringKeyMaterial(key: string): Uint8Array {\n  const padded = key.padEnd(LENGTH_16, \" \");\n  const bytes = textEncoder.encode(padded);\n  if (bytes.length !== LENGTH_16) {\n    throw new Error(\n      \"aes128StringKeyMaterial: padded key must UTF-8 encode to exactly 16 bytes\",\n    );\n  }\n  return bytes;\n}\n\n", "import {\n  DECOMPRESSED_LENGTH,\n  KEY_LENGTH,\n  PREFIXED_DECOMPRESSED_LENGTH,\n  PREFIXED_KEY_LENGTH,\n} from \"../constants\";\nimport type { Signature, SignResult } from \"./types\";\nimport {\n  bufferToHex,\n  concatBuffers,\n  hexToBuffer,\n  hexToNumber,\n  removeHexLeadingZeros,\n  sanitizeHex,\n} from \"./encoding\";\n\n/**\n * Checks whether a public key is in compressed format.\n * @param publicKey Public key bytes.\n * @returns True when key is compressed.\n */\nexport function isCompressed(publicKey: Uint8Array): boolean {\n  return (\n    publicKey.length === KEY_LENGTH || publicKey.length === PREFIXED_KEY_LENGTH\n  );\n}\n\n/**\n * Checks whether a public key is in uncompressed format.\n * @param publicKey Public key bytes.\n * @returns True when key is uncompressed.\n */\nexport function isDecompressed(publicKey: Uint8Array): boolean {\n  return (\n    publicKey.length === DECOMPRESSED_LENGTH ||\n    publicKey.length === PREFIXED_DECOMPRESSED_LENGTH\n  );\n}\n\n/**\n * Checks whether a public key has SEC1 prefix byte.\n * @param publicKey Public key bytes.\n * @returns True when key includes prefix.\n */\nexport function isPrefixed(publicKey: Uint8Array): boolean {\n  if (isCompressed(publicKey)) {\n    return publicKey.length === PREFIXED_KEY_LENGTH;\n  }\n  return publicKey.length === PREFIXED_DECOMPRESSED_LENGTH;\n}\n\n/**\n * Ensures a public key is SEC1-prefixed.\n * @param publicKey Public key bytes.\n * @returns Prefixed public key bytes.\n */\nexport function sanitizePublicKey(publicKey: Uint8Array): Uint8Array {\n  return isPrefixed(publicKey)\n    ? publicKey\n    : concatBuffers(hexToBuffer(\"04\"), publicKey);\n}\n\n/**\n * Converts recovery id to Ethereum-style recovery byte.\n * @param recoveryParam Recovery id.\n * @returns Recovery byte as Uint8Array.\n */\nexport function exportRecoveryParam(recoveryParam: number): Uint8Array {\n  return hexToBuffer(sanitizeHex((recoveryParam + 27).toString(16)));\n}\n\n/**\n * Converts recovery byte to recovery id.\n * @param v Recovery byte.\n * @returns Recovery id.\n */\nexport function importRecoveryParam(v: Uint8Array): number {\n  return hexToNumber(removeHexLeadingZeros(bufferToHex(v))) - 27;\n}\n\n/**\n * Splits compact signature bytes into r, s, and v components.\n * @param sig Signature bytes.\n * @returns Signature object with r, s, and v.\n */\nexport function splitSignature(sig: Uint8Array): Signature {\n  return {\n    r: sig.slice(0, 32),\n    s: sig.slice(32, 64),\n    v: sig.slice(64, 65),\n  };\n}\n\n/**\n * Joins r, s, and v signature components into byte array.\n * @param sig Signature object.\n * @returns Signature bytes.\n */\nexport function joinSignature(sig: Signature): Uint8Array {\n  return concatBuffers(sig.r, sig.s, sig.v);\n}\n\n/**\n * Checks whether signature bytes look like DER format.\n * @param sig Signature bytes.\n * @returns True when signature appears DER-encoded.\n */\nexport function isValidDERSignature(sig: Uint8Array): boolean {\n  return sig.length > 65 && sig[0] === 0x30;\n}\n\n/**\n * Converts recovered signature bytes into signature and recovery id.\n * @param sig Recovered signature bytes.\n * @returns Signature bytes and recovery id.\n */\nexport function sanitizeRSVSignature(sig: Uint8Array): SignResult {\n  return {\n    signature: sig.slice(0, 64),\n    recovery: importRecoveryParam(sig.slice(64, 65)),\n  };\n}\n", "import { hmac } from \"@noble/hashes/hmac.js\";\nimport { sha256, sha512 } from \"@noble/hashes/sha2.js\";\nimport { bufferToBase64, utf8ToBuffer } from \"./helpers/encoding\";\nimport { equalConstTime } from \"./helpers/validators\";\n\n/**\n * Computes HMAC-SHA256 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @returns HMAC-SHA256 bytes.\n */\nexport async function hmacSha256Sign(\n  key: Uint8Array,\n  msg: Uint8Array\n): Promise<Uint8Array> {\n  return hmacSha256SignSync(key, msg);\n}\n\n/**\n * Verifies HMAC-SHA256 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @param sig Signature bytes to verify.\n * @returns True when signature is valid.\n */\nexport async function hmacSha256Verify(\n  key: Uint8Array,\n  msg: Uint8Array,\n  sig: Uint8Array\n): Promise<boolean> {\n  return hmacSha256VerifySync(key, msg, sig);\n}\n\n/**\n * Computes HMAC-SHA512 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @returns HMAC-SHA512 bytes.\n */\nexport async function hmacSha512Sign(\n  key: Uint8Array,\n  msg: Uint8Array\n): Promise<Uint8Array> {\n  return hmacSha512SignSync(key, msg);\n}\n\n/**\n * Verifies HMAC-SHA512 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @param sig Signature bytes to verify.\n * @returns True when signature is valid.\n */\nexport async function hmacSha512Verify(\n  key: Uint8Array,\n  msg: Uint8Array,\n  sig: Uint8Array\n): Promise<boolean> {\n  return hmacSha512VerifySync(key, msg, sig);\n}\n\n/**\n * Computes HMAC-SHA256 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @returns HMAC-SHA256 bytes.\n */\nexport function hmacSha256SignSync(key: Uint8Array, msg: Uint8Array): Uint8Array {\n  return hmac(sha256, key, msg);\n}\n\n/**\n * Verifies HMAC-SHA256 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @param sig Signature bytes to verify.\n * @returns True when signature is valid.\n */\nexport function hmacSha256VerifySync(\n  key: Uint8Array,\n  msg: Uint8Array,\n  sig: Uint8Array\n): boolean {\n  const expected = hmacSha256SignSync(key, msg);\n  return equalConstTime(expected, sig);\n}\n\n/**\n * Computes HMAC-SHA512 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @returns HMAC-SHA512 bytes.\n */\nexport function hmacSha512SignSync(key: Uint8Array, msg: Uint8Array): Uint8Array {\n  return hmac(sha512, key, msg);\n}\n\n/**\n * Verifies HMAC-SHA512 signature.\n * @param key HMAC key bytes.\n * @param msg Message bytes.\n * @param sig Signature bytes to verify.\n * @returns True when signature is valid.\n */\nexport function hmacSha512VerifySync(\n  key: Uint8Array,\n  msg: Uint8Array,\n  sig: Uint8Array\n): boolean {\n  const expected = hmacSha512SignSync(key, msg);\n  return equalConstTime(expected, sig);\n}\n\n/**\n * HMAC-SHA256: UTF-8(`keyUtf8`) is the raw key (Web Crypto `importKey(\"raw\", \u2026, HMAC-SHA-256)` style).\n * Tag is RFC 4648 Base64.\n *\n * @param keyUtf8 Secret string.\n * @param msg Message bytes.\n * @returns Base64 MAC.\n */\nexport async function hmacSha256SignUtf8KeyBase64(\n  keyUtf8: string,\n  msg: Uint8Array,\n): Promise<string> {\n  return hmacSha256SignUtf8KeyBase64Sync(keyUtf8, msg);\n}\n\n/** Synchronous {@link hmacSha256SignUtf8KeyBase64}. */\nexport function hmacSha256SignUtf8KeyBase64Sync(\n  keyUtf8: string,\n  msg: Uint8Array,\n): string {\n  const keyBytes = utf8ToBuffer(keyUtf8);\n  return bufferToBase64(hmacSha256SignSync(keyBytes, msg));\n}\n\n/**\n * HMAC-SHA256 over UTF-8(`JSON.stringify(data)`) with UTF-8 string key; see {@link hmacSha256SignUtf8KeyBase64}.\n *\n * @param keyUtf8 Secret string.\n * @param data `JSON.stringify` input.\n * @returns Base64 MAC.\n */\nexport async function hmacSha256SignJsonUtf8KeyBase64(\n  keyUtf8: string,\n  data: unknown,\n): Promise<string> {\n  return hmacSha256SignJsonUtf8KeyBase64Sync(keyUtf8, data);\n}\n\n/** Synchronous {@link hmacSha256SignJsonUtf8KeyBase64}. */\nexport function hmacSha256SignJsonUtf8KeyBase64Sync(\n  keyUtf8: string,\n  data: unknown,\n): string {\n  return hmacSha256SignUtf8KeyBase64Sync(keyUtf8, utf8ToBuffer(JSON.stringify(data)));\n}\n", "import { isValidKeyLength } from \"./helpers/validators\";\n\n/**\n * Generates cryptographically secure random bytes.\n * @param length Number of bytes to generate.\n * @returns Random bytes.\n */\nexport function randomBytes(length: number): Uint8Array {\n  if (!isValidKeyLength(length)) {\n    throw new Error(`randomBytes - invalid key length: ${length}`);\n  }\n  const out = new Uint8Array(length);\n  globalThis.crypto.getRandomValues(out);\n  return out;\n}\n", "import { sha512 as sha512Noble } from \"@noble/hashes/sha2.js\";\n\n/**\n * Computes SHA-512 digest.\n * @param msg Input bytes.\n * @returns SHA-512 digest bytes.\n */\nexport async function sha512(msg: Uint8Array): Promise<Uint8Array> {\n  return sha512Noble(msg);\n}\n\n/**\n * Computes SHA-512 digest.\n * @param msg Input bytes.\n * @returns SHA-512 digest bytes.\n */\nexport function sha512Sync(msg: Uint8Array): Uint8Array {\n  return sha512Noble(msg);\n}\n", "import {\n  aesCbcDecrypt,\n  aesCbcDecryptSync,\n  aesCbcEncrypt,\n  aesCbcEncryptSync,\n} from \"./aes\";\nimport { derive } from \"./ecdh\";\nimport { compress, decompress, getPublic } from \"./ecdsa\";\nimport {\n  assert,\n  concatBuffers,\n  type Encrypted,\n  type PreEncryptOpts,\n} from \"./helpers\";\nimport { isValidPrivateKey } from \"./helpers/validators\";\nimport {\n  hmacSha256Sign,\n  hmacSha256SignSync,\n  hmacSha256Verify,\n  hmacSha256VerifySync,\n} from \"./hmac\";\nimport { randomBytes } from \"./random\";\nimport { sha512, sha512Sync } from \"./internal/sha512\";\nimport {\n  ECIES_SERIALIZED_MIN_LENGTH,\n  ERROR_BAD_EPHEM_PRIVATE_KEY,\n  ERROR_BAD_MAC,\n  ERROR_ECIES_SERIALIZED_LENGTH,\n  IV_LENGTH,\n  KEY_LENGTH,\n  LENGTH_0,\n  MAC_LENGTH,\n  PREFIXED_KEY_LENGTH,\n} from \"./constants\";\n\n/**\n * Derives an ECDH shared key from a private key and peer public key.\n * @param privateKey Private key bytes.\n * @param publicKey Public key bytes.\n * @returns Shared key bytes.\n */\nfunction getSharedKey(privateKey: Uint8Array, publicKey: Uint8Array) {\n  const pub = decompress(publicKey);\n  return derive(privateKey, pub);\n}\n\n/**\n * Extracts the encryption key portion from a SHA-512 digest.\n * @param hash SHA-512 digest bytes.\n * @returns Encryption key bytes.\n */\nfunction getEncryptionKey(hash: Uint8Array) {\n  return hash.slice(LENGTH_0, KEY_LENGTH);\n}\n\n/**\n * Extracts the MAC key portion from a SHA-512 digest.\n * @param hash SHA-512 digest bytes.\n * @returns MAC key bytes.\n */\nfunction getMacKey(hash: Uint8Array) {\n  return hash.slice(KEY_LENGTH);\n}\n\n/**\n * Derives ECIES encryption and MAC keys.\n * @param privateKey Private key bytes.\n * @param publicKey Peer public key bytes.\n * @returns Object containing encryption and MAC keys.\n */\nasync function getEciesKeys(\n  privateKey: Uint8Array,\n  publicKey: Uint8Array\n): Promise<{ encryptionKey: Uint8Array; macKey: Uint8Array }> {\n  const sharedKey = getSharedKey(privateKey, publicKey);\n  const hash = await sha512(sharedKey);\n  return { encryptionKey: getEncryptionKey(hash), macKey: getMacKey(hash) };\n}\n\n/**\n * Derives ECIES encryption and MAC keys using sync hashing.\n * @param privateKey Private key bytes.\n * @param publicKey Peer public key bytes.\n * @returns Object containing encryption and MAC keys.\n */\nfunction getEciesKeysSync(privateKey: Uint8Array, publicKey: Uint8Array) {\n  const sharedKey = getSharedKey(privateKey, publicKey);\n  const hash = sha512Sync(sharedKey);\n  return { encryptionKey: getEncryptionKey(hash), macKey: getMacKey(hash) };\n}\n\n/**\n * Creates an ephemeral key pair for ECIES encryption.\n * @param opts Optional encryption overrides.\n * @returns Ephemeral private and public key bytes.\n */\nfunction getEphemKeyPair(opts?: Partial<PreEncryptOpts>) {\n  const fixed = opts?.ephemPrivateKey;\n  if (fixed !== undefined) {\n    if (!isValidPrivateKey(fixed)) {\n      throw new Error(ERROR_BAD_EPHEM_PRIVATE_KEY);\n    }\n    return { ephemPrivateKey: fixed, ephemPublicKey: getPublic(fixed) };\n  }\n  let ephemPrivateKey = randomBytes(KEY_LENGTH);\n  while (!isValidPrivateKey(ephemPrivateKey)) {\n    ephemPrivateKey = randomBytes(KEY_LENGTH);\n  }\n  const ephemPublicKey = getPublic(ephemPrivateKey);\n  return { ephemPrivateKey, ephemPublicKey };\n}\n\n/**\n * Encrypts a message with ECIES.\n * @param publicKeyTo Recipient public key bytes.\n * @param msg Plaintext bytes.\n * @param opts Optional encryption overrides.\n * @returns Encrypted payload.\n */\nexport async function encrypt(\n  publicKeyTo: Uint8Array,\n  msg: Uint8Array,\n  opts?: Partial<PreEncryptOpts>\n): Promise<Encrypted> {\n  const { ephemPrivateKey, ephemPublicKey } = getEphemKeyPair(opts);\n  const { encryptionKey, macKey } = await getEciesKeys(\n    ephemPrivateKey,\n    publicKeyTo\n  );\n  const iv = opts?.iv ?? randomBytes(IV_LENGTH);\n  const ciphertext = await aesCbcEncrypt(iv, encryptionKey, msg);\n  const dataToMac = concatBuffers(iv, ephemPublicKey, ciphertext);\n  const mac = await hmacSha256Sign(macKey, dataToMac);\n  return { iv, ephemPublicKey, ciphertext, mac };\n}\n\n/**\n * Decrypts an ECIES payload.\n * @param privateKey Recipient private key bytes.\n * @param opts Encrypted payload.\n * @returns Decrypted plaintext bytes.\n */\nexport async function decrypt(\n  privateKey: Uint8Array,\n  opts: Encrypted\n): Promise<Uint8Array> {\n  const { ephemPublicKey, iv, mac, ciphertext } = opts;\n  const { encryptionKey, macKey } = await getEciesKeys(\n    privateKey,\n    ephemPublicKey\n  );\n  const dataToMac = concatBuffers(iv, ephemPublicKey, ciphertext);\n  const macTest = await hmacSha256Verify(macKey, dataToMac, mac);\n  assert(macTest, ERROR_BAD_MAC);\n  return aesCbcDecrypt(iv, encryptionKey, ciphertext);\n}\n\n/**\n * Encrypts a message with ECIES using sync primitives.\n * @param publicKeyTo Recipient public key bytes.\n * @param msg Plaintext bytes.\n * @param opts Optional encryption overrides.\n * @returns Encrypted payload.\n */\nexport function encryptSync(\n  publicKeyTo: Uint8Array,\n  msg: Uint8Array,\n  opts?: Partial<PreEncryptOpts>\n): Encrypted {\n  const { ephemPrivateKey, ephemPublicKey } = getEphemKeyPair(opts);\n  const { encryptionKey, macKey } = getEciesKeysSync(\n    ephemPrivateKey,\n    publicKeyTo\n  );\n  const iv = opts?.iv ?? randomBytes(IV_LENGTH);\n  const ciphertext = aesCbcEncryptSync(iv, encryptionKey, msg);\n  const dataToMac = concatBuffers(iv, ephemPublicKey, ciphertext);\n  const mac = hmacSha256SignSync(macKey, dataToMac);\n  return { iv, ephemPublicKey, ciphertext, mac };\n}\n\n/**\n * Decrypts an ECIES payload using sync primitives.\n * @param privateKey Recipient private key bytes.\n * @param opts Encrypted payload.\n * @returns Decrypted plaintext bytes.\n */\nexport function decryptSync(\n  privateKey: Uint8Array,\n  opts: Encrypted\n): Uint8Array {\n  const { ephemPublicKey, iv, mac, ciphertext } = opts;\n  const { encryptionKey, macKey } = getEciesKeysSync(\n    privateKey,\n    ephemPublicKey\n  );\n  const dataToMac = concatBuffers(iv, ephemPublicKey, ciphertext);\n  const macTest = hmacSha256VerifySync(macKey, dataToMac, mac);\n  assert(macTest, ERROR_BAD_MAC);\n  return aesCbcDecryptSync(iv, encryptionKey, ciphertext);\n}\n\n/**\n * Serializes an encrypted payload into a single byte array.\n * @param opts Encrypted payload.\n * @returns Serialized payload bytes.\n */\nexport function serialize(opts: Encrypted): Uint8Array {\n  const ephemPublicKey = compress(opts.ephemPublicKey);\n  return concatBuffers(opts.iv, ephemPublicKey, opts.mac, opts.ciphertext);\n}\n\n/**\n * Deserializes a byte array into an encrypted payload object.\n * @param buf Serialized payload bytes.\n * @returns Encrypted payload.\n */\nexport function deserialize(buf: Uint8Array): Encrypted {\n  assert(buf.length >= ECIES_SERIALIZED_MIN_LENGTH, ERROR_ECIES_SERIALIZED_LENGTH);\n  const slice0 = LENGTH_0;\n  const slice1 = slice0 + IV_LENGTH;\n  const slice2 = slice1 + PREFIXED_KEY_LENGTH;\n  const slice3 = slice2 + MAC_LENGTH;\n  const slice4 = buf.length;\n  return {\n    iv: buf.slice(slice0, slice1),\n    ephemPublicKey: decompress(buf.slice(slice1, slice2)),\n    mac: buf.slice(slice2, slice3),\n    ciphertext: buf.slice(slice3, slice4),\n  };\n}\n"],
  "mappings": "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",
  "names": ["Point", "Point", "hmac", "sha256", "hmac", "sha256", "sha512", "sha512"]
}