{"version":3,"file":"index.native.mjs","names":["data: BufferSource","storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT: WeakMap | undefined","publicKeyBytesStore: WeakMap | undefined","createKeyPairFromBytes","bytes: Uint8Array","extractable: boolean","keyUsages: readonly KeyUsage[]","key: CryptoKey","value: string","format: KeyFormat","signature","signature: BufferSource","type: \"private\" | \"public\"","keyData: BufferSource | JsonWebKey","cachedEd25519Decision: PromiseLike | boolean | undefined","subtle: SubtleCrypto","crypto","codecDescription: string","bytes: ReadonlyUint8Array | Uint8Array","expected: number","offset: number","bytesLength: number","alphabet: string","testValue: string","givenValue: string","alphabet","value: TFrom","encoder: { fixedSize: number } | { getSizeFromValue: (value: TFrom) => number }","encoder: Omit, \"encode\"> | Omit, \"encode\">","decoder: Omit, \"decode\"> | Omit, \"decode\">","codec:\n | Omit, \"decode\" | \"encode\">\n | Omit, \"decode\" | \"encode\">","codec: { fixedSize: number } | { maxSize?: number }","encoder: Encoder","unmap: (value: TNewFrom) => TOldFrom","value: TNewFrom","decoder: Decoder","map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo","bytes: ReadonlyUint8Array | Uint8Array","encoder: Encoder","decoder: Decoder","codec: Codec","map?: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo","byteArrays: Uint8Array[]","length: number","data: ReadonlyUint8Array | Uint8Array","offset: number","fixedBytes: TSize","bytes: Uint8Array","offset: Offset","codec: Codec","char: number","value: string","base16: VariableSizeCodec","base16Encoder: Encoder | undefined","putativeSignature: string","key: CryptoKey","data: ReadonlyUint8Array","signature: SignatureBytes","data: ReadonlyUint8Array | Uint8Array","signature","bytes: ReadonlyUint8Array","extractable?: boolean","privateKey: CryptoKey","extractable: boolean","privateKey","putativeAddress: string","putativeAddress: TAddress","addressEncoder: FixedSizeEncoder | undefined","addressDecoder: FixedSizeDecoder | undefined","addressCodec: FixedSizeCodec | undefined","key: CryptoKey","putativeAccount: string","publicKey: CryptoKey","address","alphabet: string","value: string","alphabet","tailBytes: number[]","zeroCharacter: string","value: bigint","alphabet","base10: VariableSizeCodec","alphabet","base58: VariableSizeCodec","alphabet: string","bits: number","value: string","alphabet","input: number[]","inputBits: number","outputBits: number","useRemainder: boolean","value: string","value: string","base64Url: VariableSizeCodec","value: string","chars: number","textEncoder: TextEncoder","value: string","textDecoder: TextDecoder","utf8: VariableSizeCodec","input: string | Uint8Array","val: unknown","isArrayProp: boolean"],"sources":["../../../node_modules/.pnpm/uncrypto@0.1.3/node_modules/uncrypto/dist/crypto.web.mjs","../src/polyfill/secrets.ts","../src/polyfill/install.ts","../src/assertions.ts","../src/codecs/core.ts","../src/codecs/strings/base16.ts","../src/keys/signatures.ts","../src/keys/keys.ts","../src/address.ts","../src/codecs/strings/baseX.ts","../src/codecs/strings/base10.ts","../src/codecs/strings/base58.ts","../src/codecs/strings/baseX-reslice.ts","../src/codecs/strings/base64.ts","../src/codecs/strings/base64-url.ts","../src/codecs/strings/null.ts","../src/codecs/text.ts","../src/codecs/strings/utf-8.ts","../src/hash/base64-url-blake2b.ts","../src/stringify.ts","../src/index.ts"],"sourcesContent":["const webCrypto = globalThis.crypto;\nconst subtle = webCrypto.subtle;\nconst randomUUID = () => {\n return webCrypto.randomUUID();\n};\nconst getRandomValues = (array) => {\n return webCrypto.getRandomValues(array);\n};\nconst _crypto = {\n randomUUID,\n getRandomValues,\n subtle\n};\n\nexport { _crypto as default, getRandomValues, randomUUID, subtle };\n","/**\n * HEY! <== SECRET KEY KOALA\n * |/ <== WOULD LIKE YOUR\n * ʕ·͡ᴥ·ʔ <== ATTENTION PLEASE\n *\n * Key material generated in this module must stay in this module. So long as the secrets cache and\n * the methods that interact with it are not exported from `@solana/webcrypto-ed25519-polyfill`,\n * accidental logging of the actual bytes of a secret key (eg. to the console, or to a remote\n * server) should not be possible.\n *\n * WARNING: This does not imply that the secrets cache is secure against supply-chain attacks.\n * Untrusted code in your JavaScript context can easily override `WeakMap.prototype.set` to steal\n * private keys as they are written to the cache, without alerting you to its presence or affecting\n * the regular operation of the cache.\n */\nimport { getPublicKeyAsync, signAsync, utils, verifyAsync } from \"@noble/ed25519\";\n\nconst PROHIBITED_KEY_USAGES = new Set([\n \"decrypt\",\n \"deriveBits\",\n \"deriveKey\",\n \"encrypt\",\n \"unwrapKey\",\n \"wrapKey\",\n]);\n\nconst ED25519_PKCS8_HEADER =\n // prettier-ignore\n [\n /**\n * PKCS#8 header\n */\n 0x30, // ASN.1 sequence tag\n 0x2e, // Length of sequence (46 more bytes)\n\n 0x02, // ASN.1 integer tag\n 0x01, // Length of integer\n 0x00, // Version number\n\n 0x30, // ASN.1 sequence tag\n 0x05, // Length of sequence\n 0x06, // ASN.1 object identifier tag\n 0x03, // Length of object identifier\n // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n 0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n 0x65, // thawte(101)\n // Ed25519 identifier\n 0x70, // id-Ed25519(112)\n\n /**\n * Private key payload\n */\n 0x04, // ASN.1 octet string tag\n 0x22, // String length (34 more bytes)\n\n // Private key bytes as octet string\n 0x04, // ASN.1 octet string tag\n 0x20, // String length (32 bytes)\n ];\n\nfunction bufferSourceToUint8Array(data: BufferSource): Uint8Array {\n return data instanceof Uint8Array ? data : new Uint8Array(ArrayBuffer.isView(data) ? data.buffer : data);\n}\n\nlet storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT: WeakMap | undefined;\n\n// Map of public key bytes. These are the result of calling `getPublicKey`\nlet publicKeyBytesStore: WeakMap | undefined;\n\nfunction createKeyPairFromBytes(\n bytes: Uint8Array,\n extractable: boolean,\n keyUsages: readonly KeyUsage[],\n): CryptoKeyPair {\n const keyPair = createKeyPair_INTERNAL_ONLY_DO_NOT_EXPORT(extractable, keyUsages);\n const cache = (storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT ||= new WeakMap());\n cache.set(keyPair.privateKey, bytes);\n cache.set(keyPair.publicKey, bytes);\n return keyPair;\n}\n\nfunction createKeyPair_INTERNAL_ONLY_DO_NOT_EXPORT(\n extractable: boolean,\n keyUsages: readonly KeyUsage[],\n): CryptoKeyPair {\n if (keyUsages.length === 0) {\n throw new DOMException(\"Usages cannot be empty when creating a key.\", \"SyntaxError\");\n }\n if (keyUsages.some((usage) => PROHIBITED_KEY_USAGES.has(usage))) {\n throw new DOMException(\"Unsupported key usage for an Ed25519 key.\", \"SyntaxError\");\n }\n const base = {\n [Symbol.toStringTag]: \"CryptoKey\",\n algorithm: Object.freeze({ name: \"Ed25519\" }),\n };\n const privateKey = {\n ...base,\n extractable,\n type: \"private\",\n usages: Object.freeze(keyUsages.filter((usage) => usage === \"sign\")) as KeyUsage[],\n } as CryptoKey;\n const publicKey = {\n ...base,\n extractable: true,\n type: \"public\",\n usages: Object.freeze(keyUsages.filter((usage) => usage === \"verify\")) as KeyUsage[],\n } as CryptoKey;\n return Object.freeze({\n privateKey: Object.freeze(privateKey),\n publicKey: Object.freeze(publicKey),\n });\n}\n\nfunction getSecretKeyBytes_INTERNAL_ONLY_DO_NOT_EXPORT(key: CryptoKey): Uint8Array {\n const secretKeyBytes = storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT?.get(key);\n if (secretKeyBytes === undefined) {\n throw new Error(\"Could not find secret key material associated with this `CryptoKey`\");\n }\n return secretKeyBytes;\n}\n\nasync function getPublicKeyBytes(key: CryptoKey): Promise {\n // Try to find the key in the public key store first\n const publicKeyStore = (publicKeyBytesStore ||= new WeakMap());\n const fromPublicStore = publicKeyStore.get(key);\n if (fromPublicStore) return fromPublicStore;\n\n // If not available, get the key from the secrets store instead\n const publicKeyBytes = await getPublicKeyAsync(getSecretKeyBytes_INTERNAL_ONLY_DO_NOT_EXPORT(key));\n\n // Store the public key bytes in the public key store for next time\n publicKeyStore.set(key, publicKeyBytes);\n return publicKeyBytes;\n}\n\nfunction base64UrlEncode(bytes: Uint8Array): string {\n return btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(\"\"))\n .replace(/\\+/g, \"-\")\n .replace(/\\//g, \"_\")\n .replace(/=+$/, \"\");\n}\n\nfunction base64UrlDecode(value: string): Uint8Array {\n const m = value.length % 4;\n const base64Value = value\n .replace(/-/g, \"+\")\n .replace(/_/g, \"/\")\n .padEnd(value.length + (m === 0 ? 0 : 4 - m), \"=\");\n return Uint8Array.from(atob(base64Value), (c) => c.charCodeAt(0));\n}\n\nexport async function exportKeyPolyfill(format: \"jwk\", key: CryptoKey): Promise;\nexport async function exportKeyPolyfill(format: KeyFormat, key: CryptoKey): Promise;\nexport async function exportKeyPolyfill(format: KeyFormat, key: CryptoKey): Promise {\n if (key.extractable === false) {\n throw new DOMException(\"key is not extractable\", \"InvalidAccessException\");\n }\n switch (format) {\n case \"raw\": {\n if (key.type !== \"public\") {\n throw new DOMException(`Unable to export a raw Ed25519 ${key.type} key`, \"InvalidAccessError\");\n }\n const publicKeyBytes = await getPublicKeyBytes(key);\n // @ts-expect-error\n return publicKeyBytes;\n }\n case \"pkcs8\": {\n if (key.type !== \"private\") {\n throw new DOMException(`Unable to export a pkcs8 Ed25519 ${key.type} key`, \"InvalidAccessError\");\n }\n const secretKeyBytes = getSecretKeyBytes_INTERNAL_ONLY_DO_NOT_EXPORT(key);\n // @ts-expect-error\n return new Uint8Array([...ED25519_PKCS8_HEADER, ...secretKeyBytes]);\n }\n case \"jwk\": {\n const publicKeyBytes = await getPublicKeyBytes(key);\n const base = {\n crv /* curve */: \"Ed25519\",\n ext /* extractable */: key.extractable,\n key_ops /* key operations */: key.usages,\n kty /* key type */: \"OKP\" /* octet key pair */,\n x /* public key x-coordinate (base64-URL encoded) */: base64UrlEncode(publicKeyBytes),\n };\n if (key.type === \"private\") {\n const secretKeyBytes = getSecretKeyBytes_INTERNAL_ONLY_DO_NOT_EXPORT(key);\n return Object.freeze({\n ...base,\n d /* private key (base64-URL encoded) */: base64UrlEncode(secretKeyBytes),\n });\n }\n return Object.freeze({ ...base });\n }\n default:\n throw new Error(`Exporting polyfilled Ed25519 keys in the \"${format}\" format is unimplemented`);\n }\n}\n\n/**\n * This function generates a key pair and stores the secret bytes associated with it in a\n * module-private cache. Instead of vending the actual secret bytes, it returns a `CryptoKeyPair`\n * that you can use with other methods in this package to produce signatures and derive public keys\n * associated with the secret.\n */\nexport function generateKeyPolyfill(extractable: boolean, keyUsages: readonly KeyUsage[]): CryptoKeyPair {\n const privateKeyBytes = utils.randomPrivateKey();\n const keyPair = createKeyPairFromBytes(privateKeyBytes, extractable, keyUsages);\n return keyPair;\n}\n\nexport function isPolyfilledKey(key: CryptoKey): boolean {\n return !!storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT?.has(key) || !!publicKeyBytesStore?.has(key);\n}\n\nexport async function signPolyfill(key: CryptoKey, data: BufferSource): Promise {\n if (key.type !== \"private\" || !key.usages.includes(\"sign\")) {\n throw new DOMException(\"Unable to use this key to sign\", \"InvalidAccessError\");\n }\n const privateKeyBytes = getSecretKeyBytes_INTERNAL_ONLY_DO_NOT_EXPORT(key);\n const payload = bufferSourceToUint8Array(data);\n const signature = await signAsync(payload, privateKeyBytes);\n // @ts-expect-error\n return signature;\n}\n\nexport async function verifyPolyfill(key: CryptoKey, signature: BufferSource, data: BufferSource): Promise {\n if (key.type !== \"public\" || !key.usages.includes(\"verify\")) {\n throw new DOMException(\"Unable to use this key to verify\", \"InvalidAccessError\");\n }\n const publicKeyBytes = await getPublicKeyBytes(key);\n try {\n return await verifyAsync(bufferSourceToUint8Array(signature), bufferSourceToUint8Array(data), publicKeyBytes);\n } catch {\n return false;\n }\n}\n\nfunction assertValidKeyUsages(keyUsages: readonly KeyUsage[], type: \"private\" | \"public\") {\n const prohibitedKeyUses = new Set([\n ...((type === \"private\" ? [\"verify\"] : [\"sign\"]) as KeyUsage[]),\n ...PROHIBITED_KEY_USAGES,\n ]);\n if (keyUsages.some((usage) => prohibitedKeyUses.has(usage))) {\n throw new DOMException(\"Unsupported key usage for a Ed25519 key\", \"SyntaxError\");\n }\n}\n\nexport function importKeyPolyfill(\n format: \"jwk\",\n keyData: JsonWebKey,\n extractable: boolean,\n keyUsages: readonly KeyUsage[],\n): CryptoKey;\nexport function importKeyPolyfill(\n format: Exclude,\n keyData: BufferSource,\n extractable: boolean,\n keyUsages: readonly KeyUsage[],\n): CryptoKey;\nexport function importKeyPolyfill(\n format: KeyFormat,\n keyData: BufferSource | JsonWebKey,\n extractable: boolean,\n keyUsages: readonly KeyUsage[],\n): CryptoKey {\n if (format === \"raw\") {\n const bytes = bufferSourceToUint8Array(keyData as BufferSource);\n assertValidKeyUsages(keyUsages, \"public\");\n if (bytes.length !== 32) {\n throw new DOMException(\"Ed25519 raw keys must be exactly 32-bytes\", \"DataError\");\n }\n const publicKey = {\n [Symbol.toStringTag]: \"CryptoKey\",\n algorithm: Object.freeze({ name: \"Ed25519\" }),\n extractable,\n type: \"public\",\n usages: Object.freeze(keyUsages.filter((usage) => usage === \"verify\")) as KeyUsage[],\n } as CryptoKey;\n\n const cache = (publicKeyBytesStore ||= new WeakMap());\n cache.set(publicKey, bytes);\n\n return publicKey;\n }\n\n if (format === \"pkcs8\") {\n const bytes = bufferSourceToUint8Array(keyData as BufferSource);\n assertValidKeyUsages(keyUsages, \"private\");\n // 48 bytes: 16-byte PKCS8 header + 32 byte secret key\n if (bytes.length !== 48) {\n throw new DOMException(\"Invalid keyData\", \"DataError\");\n }\n // Must start with exactly the Ed25519 pkcs8 header\n const header = bytes.slice(0, 16);\n if (!header.every((val, i) => val === ED25519_PKCS8_HEADER[i])) {\n throw new DOMException(\"Invalid keyData\", \"DataError\");\n }\n const secretKeyBytes = bytes.slice(16);\n\n const privateKey = {\n [Symbol.toStringTag]: \"CryptoKey\",\n algorithm: Object.freeze({ name: \"Ed25519\" }),\n extractable,\n type: \"private\",\n usages: Object.freeze(keyUsages.filter((usage) => usage === \"sign\")) as KeyUsage[],\n } as CryptoKey;\n\n const cache = (storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT ||= new WeakMap());\n cache.set(privateKey, secretKeyBytes);\n\n return privateKey;\n }\n\n if (format === \"jwk\") {\n const jwk = keyData as JsonWebKey;\n const type = \"d\" in jwk ? \"private\" : \"public\";\n assertValidKeyUsages(keyUsages, type);\n const keyOps = new Set(jwk.key_ops ?? []);\n const sameKeyUsages = keyUsages.length === keyOps.size && [...keyUsages].every((x) => keyOps.has(x));\n if (jwk.kty !== \"OKP\" || jwk.crv !== \"Ed25519\" || jwk.ext !== extractable || !sameKeyUsages) {\n throw new DOMException(\"Invalid Ed25519 JWK\", \"DataError\");\n }\n if (type === \"public\" && !jwk.x) {\n throw new DOMException(\"Ed25519 JWK is missing public key coordinates\", \"DataError\");\n }\n if (type === \"private\" && !jwk.d) {\n throw new DOMException(\"Ed25519 JWK is missing private key coordinates\", \"DataError\");\n }\n const usageToKeep = type === \"public\" ? \"verify\" : \"sign\";\n const key = Object.freeze({\n [Symbol.toStringTag]: \"CryptoKey\",\n algorithm: Object.freeze({ name: \"Ed25519\" }),\n extractable,\n type,\n usages: Object.freeze(keyUsages.filter((usage) => usage === usageToKeep)) as KeyUsage[],\n }) as CryptoKey;\n\n if (type === \"public\") {\n const cache = (publicKeyBytesStore ||= new WeakMap());\n cache.set(key, base64UrlDecode(jwk.x!));\n } else {\n const cache = (storageKeyBySecretKey_INTERNAL_ONLY_DO_NOT_EXPORT ||= new WeakMap());\n cache.set(key, base64UrlDecode(jwk.d!));\n }\n\n return key;\n }\n\n throw new Error(`Importing Ed25519 keys in the \"${format}\" format is unimplemented`);\n}\n","import cryptoImpl from \"uncrypto\";\n\nimport {\n exportKeyPolyfill,\n generateKeyPolyfill,\n importKeyPolyfill,\n isPolyfilledKey,\n signPolyfill,\n verifyPolyfill,\n} from \"./secrets\";\n\nexport function install(): void {\n if (__NODEJS__) {\n /**\n * Node only sets the `crypto` global variable when run with `--experimental-global-webcrypto`.\n * Let's set it unconditionally here.\n */\n globalThis.crypto ||= cryptoImpl;\n }\n\n if (!__BROWSER__ || globalThis.isSecureContext) {\n /**\n * Create `crypto.subtle` if it doesn't exist.\n */\n const originalCryptoObject = (globalThis.crypto ||= {} as Crypto);\n const originalSubtleCrypto = ((originalCryptoObject as Crypto & { subtle: SubtleCrypto }).subtle ||=\n {} as SubtleCrypto);\n\n /**\n * Override `SubtleCrypto#exportKey`\n */\n const originalExportKey = originalSubtleCrypto.exportKey as SubtleCrypto[\"exportKey\"] | undefined;\n originalSubtleCrypto.exportKey = (async (...args: Parameters) => {\n const [_, key] = args;\n if (isPolyfilledKey(key)) {\n return await exportKeyPolyfill(...args);\n } else if (originalExportKey) {\n return await originalExportKey.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `exportKey` function exists to handle this call\");\n }\n }) as SubtleCrypto[\"exportKey\"];\n\n /**\n * Override `SubtleCrypto#generateKey`\n */\n const originalGenerateKey = originalSubtleCrypto.generateKey as SubtleCrypto[\"generateKey\"] | undefined;\n let originalGenerateKeySupportsEd25519: Promise | boolean | undefined;\n originalSubtleCrypto.generateKey = (async (...args: Parameters) => {\n const [algorithm] = args;\n if (algorithm !== \"Ed25519\") {\n if (originalGenerateKey) {\n return await originalGenerateKey.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `generateKey` function exists to handle this call\");\n }\n }\n let optimisticallyGeneratedKeyPair;\n if (originalGenerateKeySupportsEd25519 === undefined) {\n originalGenerateKeySupportsEd25519 = new Promise((resolve) => {\n if (!originalGenerateKey) {\n resolve((originalGenerateKeySupportsEd25519 = false));\n return;\n }\n originalGenerateKey\n .apply(originalSubtleCrypto, args)\n .then((keyPair) => {\n if (__DEV__) {\n console.warn(\n \"`webcrypto-ed25519-polyfill` was installed in an \" +\n \"environment that supports Ed25519 key manipulation \" +\n \"natively. Falling back to the native implementation. \" +\n \"Consider installing this polyfill only in environments where \" +\n \"Ed25519 is not supported.\",\n );\n }\n if (originalSubtleCrypto.generateKey !== originalGenerateKey) {\n originalSubtleCrypto.generateKey = originalGenerateKey;\n }\n optimisticallyGeneratedKeyPair = keyPair;\n resolve((originalGenerateKeySupportsEd25519 = true));\n })\n .catch(() => {\n resolve((originalGenerateKeySupportsEd25519 = false));\n });\n });\n }\n if (\n typeof originalGenerateKeySupportsEd25519 === \"boolean\"\n ? originalGenerateKeySupportsEd25519\n : await originalGenerateKeySupportsEd25519\n ) {\n if (optimisticallyGeneratedKeyPair) {\n return optimisticallyGeneratedKeyPair;\n } else if (originalGenerateKey) {\n return await originalGenerateKey.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `generateKey` function exists to handle this call\");\n }\n } else {\n const [_, extractable, keyUsages] = args;\n return generateKeyPolyfill(extractable, keyUsages);\n }\n }) as SubtleCrypto[\"generateKey\"];\n\n /**\n * Override `SubtleCrypto#sign`\n */\n const originalSign = originalSubtleCrypto.sign as SubtleCrypto[\"sign\"] | undefined;\n originalSubtleCrypto.sign = (async (...args: Parameters) => {\n const [_, key] = args;\n if (isPolyfilledKey(key)) {\n const [_, ...rest] = args;\n return await signPolyfill(...rest);\n } else if (originalSign) {\n return await originalSign.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `sign` function exists to handle this call\");\n }\n }) as SubtleCrypto[\"sign\"];\n\n /**\n * Override `SubtleCrypto#verify`\n */\n const originalVerify = originalSubtleCrypto.verify as SubtleCrypto[\"verify\"] | undefined;\n originalSubtleCrypto.verify = (async (...args: Parameters) => {\n const [_, key] = args;\n if (isPolyfilledKey(key)) {\n const [_, ...rest] = args;\n return await verifyPolyfill(...rest);\n } else if (originalVerify) {\n return await originalVerify.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `verify` function exists to handle this call\");\n }\n }) as SubtleCrypto[\"verify\"];\n\n /**\n * Override `SubtleCrypto#importKey`\n */\n const originalImportKey = originalSubtleCrypto.importKey as SubtleCrypto[\"importKey\"] | undefined;\n let originalImportKeySupportsEd25519: Promise | boolean | undefined;\n originalSubtleCrypto.importKey = (async (...args: Parameters) => {\n const [format, keyData, algorithm] = args;\n if (algorithm !== \"Ed25519\") {\n if (originalImportKey) {\n return await originalImportKey.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `importKey` function exists to handle this call\");\n }\n }\n let optimisticallyImportedKey;\n if (originalImportKeySupportsEd25519 === undefined) {\n originalImportKeySupportsEd25519 = new Promise((resolve) => {\n if (!originalImportKey) {\n resolve((originalImportKeySupportsEd25519 = false));\n return;\n }\n originalImportKey\n .apply(originalSubtleCrypto, args)\n .then((key) => {\n if (__DEV__) {\n console.warn(\n \"`webcrypto-ed25519-polyfill` was included in an \" +\n \"environment that supports Ed25519 key manipulation \" +\n \"natively. Falling back to the native implementation. \" +\n \"Consider including this polyfill only in environments where \" +\n \"Ed25519 is not supported.\",\n );\n }\n if (originalSubtleCrypto.importKey !== originalImportKey) {\n originalSubtleCrypto.importKey = originalImportKey;\n }\n optimisticallyImportedKey = key;\n resolve((originalImportKeySupportsEd25519 = true));\n })\n .catch(() => {\n resolve((originalImportKeySupportsEd25519 = false));\n });\n });\n }\n if (\n typeof originalImportKey === \"boolean\"\n ? originalImportKeySupportsEd25519\n : await originalImportKeySupportsEd25519\n ) {\n if (optimisticallyImportedKey) {\n return optimisticallyImportedKey;\n } else if (originalImportKey) {\n return await originalImportKey.apply(originalSubtleCrypto, args);\n } else {\n throw new TypeError(\"No native `importKey` function exists to handle this call\");\n }\n } else {\n const [_format, _keyData, _algorithm, extractable, keyUsages] = args;\n return importKeyPolyfill(format, keyData, extractable, keyUsages);\n }\n }) as SubtleCrypto[\"importKey\"];\n }\n}\n","import crypto from \"uncrypto\";\n\nimport type { ReadonlyUint8Array } from \"./codecs/types\";\n\nfunction assertIsSecureContext() {\n if (!__NODEJS__ && __BROWSER__ && !globalThis.isSecureContext) {\n throw new Error(\"Must be in a secure context (HTTPS, localhost, file://)\");\n }\n}\n\nlet cachedEd25519Decision: PromiseLike | boolean | undefined;\nasync function isEd25519CurveSupported(subtle: SubtleCrypto): Promise {\n if (cachedEd25519Decision === undefined) {\n cachedEd25519Decision = new Promise((resolve) => {\n subtle\n .generateKey(\"Ed25519\", /* extractable */ false, [\"sign\", \"verify\"])\n .catch(() => {\n resolve((cachedEd25519Decision = false));\n })\n .then(() => {\n resolve((cachedEd25519Decision = true));\n });\n });\n }\n if (typeof cachedEd25519Decision === \"boolean\") {\n return cachedEd25519Decision;\n } else {\n return await cachedEd25519Decision;\n }\n}\n\nexport function assertDigestCapabilityIsAvailable(): void {\n assertIsSecureContext();\n if (typeof crypto === \"undefined\" || typeof crypto.subtle?.digest !== \"function\") {\n throw new Error(\"SubtleCrypto.digest is not available\");\n }\n}\n\nexport async function assertKeyGenerationIsAvailable(): Promise {\n assertIsSecureContext();\n if (typeof crypto === \"undefined\" || typeof crypto.subtle?.generateKey !== \"function\") {\n throw new Error(\"SubtleCrypto.generateKey is not available\");\n }\n if (!(await isEd25519CurveSupported(crypto.subtle))) {\n throw new Error(\"Ed25519 curve is not supported\");\n }\n}\n\nexport function assertKeyExporterIsAvailable(): void {\n assertIsSecureContext();\n if (typeof crypto === \"undefined\" || typeof crypto.subtle?.exportKey !== \"function\") {\n throw new Error(\"SubtleCrypto.exportKey is not available\");\n }\n}\n\nexport function assertSigningCapabilityIsAvailable(): void {\n assertIsSecureContext();\n if (typeof crypto === \"undefined\" || typeof crypto.subtle?.sign !== \"function\") {\n throw new Error(\"SubtleCrypto.sign is not available\");\n }\n}\n\nexport function assertVerificationCapabilityIsAvailable(): void {\n assertIsSecureContext();\n if (typeof crypto === \"undefined\" || typeof crypto.subtle?.verify !== \"function\") {\n throw new Error(\"SubtleCrypto.verify is not available\");\n }\n}\n\nexport function assertPRNGIsAvailable(): void {\n if (typeof crypto === \"undefined\" || typeof crypto.getRandomValues !== \"function\") {\n throw new Error(\"Crypto.getRandomValues is not available\");\n }\n}\n\n/**\n * Asserts that a given byte array is not empty.\n */\nexport function assertByteArrayIsNotEmptyForCodec(\n codecDescription: string,\n bytes: ReadonlyUint8Array | Uint8Array,\n offset = 0,\n): void {\n if (bytes.length - offset <= 0) {\n throw new Error(`Empty byte array for ${codecDescription}`);\n }\n}\n\n/**\n * Asserts that a given byte array has enough bytes to decode.\n */\nexport function assertByteArrayHasEnoughBytesForCodec(\n codecDescription: string,\n expected: number,\n bytes: ReadonlyUint8Array | Uint8Array,\n offset = 0,\n): void {\n const bytesLength = bytes.length - offset;\n if (bytesLength < expected) {\n throw new Error(`Not enough bytes to decode ${codecDescription}. Expected: ${expected}, Actual: ${bytesLength}`);\n }\n}\n\n/**\n * Asserts that a given offset is within the byte array bounds.\n * This range is between 0 and the byte array length and is inclusive.\n * An offset equals to the byte array length is considered a valid offset\n * as it allows the post-offset of codecs to signal the end of the byte array.\n */\nexport function assertByteArrayOffsetIsNotOutOfRange(\n codecDescription: string,\n offset: number,\n bytesLength: number,\n): void {\n if (offset < 0 || offset > bytesLength) {\n throw new Error(`Offset is out of range for ${codecDescription}: ${offset}`);\n }\n}\n\n/**\n * Asserts that a given string matches a given alphabet.\n */\nexport function assertValidBaseString(alphabet: string, testValue: string, givenValue: string = testValue): void {\n if (!testValue.match(new RegExp(`^[${alphabet}]*$`))) {\n throw new Error(`Invalid base${alphabet.length} string: ${givenValue}`);\n }\n}\n","import type { ReadonlyUint8Array } from \"./types\";\nimport { assertByteArrayHasEnoughBytesForCodec } from \"../assertions\";\n\n/**\n * Defines an offset in bytes.\n */\nexport type Offset = number;\n\ntype BaseEncoder = {\n /** Encode the provided value and return the encoded bytes directly. */\n readonly encode: (value: TFrom) => ReadonlyUint8Array;\n /**\n * Writes the encoded value into the provided byte array at the given offset.\n * Returns the offset of the next byte after the encoded value.\n */\n readonly write: (value: TFrom, bytes: Uint8Array, offset: Offset) => Offset;\n};\n\nexport type FixedSizeEncoder = BaseEncoder & {\n /** The fixed size of the encoded value in bytes. */\n readonly fixedSize: TSize;\n};\n\nexport type VariableSizeEncoder = BaseEncoder & {\n /** The total size of the encoded value in bytes. */\n readonly getSizeFromValue: (value: TFrom) => number;\n /** The maximum size an encoded value can be in bytes, if applicable. */\n readonly maxSize?: number;\n};\n\n/**\n * An object that can encode a value to a `Uint8Array`.\n */\nexport type Encoder = FixedSizeEncoder | VariableSizeEncoder;\n\ntype BaseDecoder = {\n /** Decodes the provided byte array at the given offset (or zero) and returns the value directly. */\n readonly decode: (bytes: ReadonlyUint8Array | Uint8Array, offset?: Offset) => TTo;\n /**\n * Reads the encoded value from the provided byte array at the given offset.\n * Returns the decoded value and the offset of the next byte after the encoded value.\n */\n readonly read: (bytes: ReadonlyUint8Array | Uint8Array, offset: Offset) => [TTo, Offset];\n};\n\nexport type FixedSizeDecoder = BaseDecoder & {\n /** The fixed size of the encoded value in bytes. */\n readonly fixedSize: TSize;\n};\n\nexport type VariableSizeDecoder = BaseDecoder & {\n /** The maximum size an encoded value can be in bytes, if applicable. */\n readonly maxSize?: number;\n};\n\n/**\n * An object that can decode a value from a `Uint8Array`.\n */\nexport type Decoder = FixedSizeDecoder | VariableSizeDecoder;\n\nexport type FixedSizeCodec = FixedSizeDecoder<\n TTo,\n TSize\n> &\n FixedSizeEncoder;\n\nexport type VariableSizeCodec = VariableSizeDecoder & VariableSizeEncoder;\n\n/**\n * An object that can encode and decode a value to and from a `Uint8Array`.\n * It supports encoding looser types than it decodes for convenience.\n * For example, a `bigint` encoder will always decode to a `bigint`\n * but can be used to encode a `number`.\n *\n * @typeParam TFrom - The type of the value to encode.\n * @typeParam TTo - The type of the decoded value. Defaults to `TFrom`.\n */\nexport type Codec = FixedSizeCodec | VariableSizeCodec;\n\n/**\n * Get the encoded size of a given value in bytes.\n */\nexport function getEncodedSize(\n value: TFrom,\n encoder: { fixedSize: number } | { getSizeFromValue: (value: TFrom) => number },\n): number {\n return \"fixedSize\" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);\n}\n\n/** Fills the missing `encode` function using the existing `write` function. */\nexport function createEncoder(\n encoder: Omit, \"encode\">,\n): FixedSizeEncoder;\nexport function createEncoder(encoder: Omit, \"encode\">): VariableSizeEncoder;\nexport function createEncoder(\n encoder: Omit, \"encode\"> | Omit, \"encode\">,\n): Encoder;\nexport function createEncoder(\n encoder: Omit, \"encode\"> | Omit, \"encode\">,\n): Encoder {\n return Object.freeze({\n ...encoder,\n encode: (value) => {\n const bytes = new Uint8Array(getEncodedSize(value, encoder));\n encoder.write(value, bytes, 0);\n return bytes;\n },\n });\n}\n\n/** Fills the missing `decode` function using the existing `read` function. */\nexport function createDecoder(\n decoder: Omit, \"decode\">,\n): FixedSizeDecoder;\nexport function createDecoder(decoder: Omit, \"decode\">): VariableSizeDecoder;\nexport function createDecoder(\n decoder: Omit, \"decode\"> | Omit, \"decode\">,\n): Decoder;\nexport function createDecoder(\n decoder: Omit, \"decode\"> | Omit, \"decode\">,\n): Decoder {\n return Object.freeze({\n ...decoder,\n decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0],\n });\n}\n\n/** Fills the missing `encode` and `decode` function using the existing `write` and `read` functions. */\nexport function createCodec(\n codec: Omit, \"decode\" | \"encode\">,\n): FixedSizeCodec;\nexport function createCodec(\n codec: Omit, \"decode\" | \"encode\">,\n): VariableSizeCodec;\nexport function createCodec(\n codec:\n | Omit, \"decode\" | \"encode\">\n | Omit, \"decode\" | \"encode\">,\n): Codec;\nexport function createCodec(\n codec:\n | Omit, \"decode\" | \"encode\">\n | Omit, \"decode\" | \"encode\">,\n): Codec {\n return Object.freeze({\n ...codec,\n decode: (bytes, offset = 0) => codec.read(bytes, offset)[0],\n encode: (value) => {\n const bytes = new Uint8Array(getEncodedSize(value, codec));\n codec.write(value, bytes, 0);\n return bytes;\n },\n });\n}\n\nexport function isFixedSize(\n encoder: FixedSizeEncoder | VariableSizeEncoder,\n): encoder is FixedSizeEncoder;\nexport function isFixedSize(\n decoder: FixedSizeDecoder | VariableSizeDecoder,\n): decoder is FixedSizeDecoder;\nexport function isFixedSize(\n codec: FixedSizeCodec | VariableSizeCodec,\n): codec is FixedSizeCodec;\nexport function isFixedSize(\n codec: { fixedSize: TSize } | { maxSize?: number },\n): codec is { fixedSize: TSize };\nexport function isFixedSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { fixedSize: number } {\n return \"fixedSize\" in codec && typeof codec.fixedSize === \"number\";\n}\n\nexport function assertIsFixedSize(\n encoder: FixedSizeEncoder | VariableSizeEncoder,\n): asserts encoder is FixedSizeEncoder;\nexport function assertIsFixedSize(\n decoder: FixedSizeDecoder | VariableSizeDecoder,\n): asserts decoder is FixedSizeDecoder;\nexport function assertIsFixedSize(\n codec: FixedSizeCodec | VariableSizeCodec,\n): asserts codec is FixedSizeCodec;\nexport function assertIsFixedSize(\n codec: { fixedSize: TSize } | { maxSize?: number },\n): asserts codec is { fixedSize: TSize };\nexport function assertIsFixedSize(\n codec: { fixedSize: number } | { maxSize?: number },\n): asserts codec is { fixedSize: number } {\n if (!isFixedSize(codec)) {\n throw new Error(\"expected a fixed size codec\");\n }\n}\n\nexport function isVariableSize(encoder: Encoder): encoder is VariableSizeEncoder;\nexport function isVariableSize(decoder: Decoder): decoder is VariableSizeDecoder;\nexport function isVariableSize(\n codec: Codec,\n): codec is VariableSizeCodec;\nexport function isVariableSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { maxSize?: number };\nexport function isVariableSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { maxSize?: number } {\n return !isFixedSize(codec);\n}\n\nexport function assertIsVariableSize(encoder: Encoder): asserts encoder is VariableSizeEncoder;\nexport function assertIsVariableSize(decoder: Decoder): asserts decoder is VariableSizeDecoder;\nexport function assertIsVariableSize(\n codec: Codec,\n): asserts codec is VariableSizeCodec;\nexport function assertIsVariableSize(\n codec: { fixedSize: number } | { maxSize?: number },\n): asserts codec is { maxSize?: number };\nexport function assertIsVariableSize(\n codec: { fixedSize: number } | { maxSize?: number },\n): asserts codec is { maxSize?: number } {\n if (!isVariableSize(codec)) {\n throw new Error(\"expected a variable size codec\");\n }\n}\n\n/**\n * Converts an encoder A to a encoder B by mapping their values.\n */\nexport function transformEncoder(\n encoder: FixedSizeEncoder,\n unmap: (value: TNewFrom) => TOldFrom,\n): FixedSizeEncoder;\nexport function transformEncoder(\n encoder: VariableSizeEncoder,\n unmap: (value: TNewFrom) => TOldFrom,\n): VariableSizeEncoder;\nexport function transformEncoder(\n encoder: Encoder,\n unmap: (value: TNewFrom) => TOldFrom,\n): Encoder;\nexport function transformEncoder(\n encoder: Encoder,\n unmap: (value: TNewFrom) => TOldFrom,\n): Encoder {\n return createEncoder({\n ...(isVariableSize(encoder)\n ? { ...encoder, getSizeFromValue: (value: TNewFrom) => encoder.getSizeFromValue(unmap(value)) }\n : encoder),\n write: (value: TNewFrom, bytes, offset) => encoder.write(unmap(value), bytes, offset),\n });\n}\n\n/**\n * Converts an decoder A to a decoder B by mapping their values.\n */\nexport function transformDecoder(\n decoder: FixedSizeDecoder,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): FixedSizeDecoder;\nexport function transformDecoder(\n decoder: VariableSizeDecoder,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): VariableSizeDecoder;\nexport function transformDecoder(\n decoder: Decoder,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): Decoder;\nexport function transformDecoder(\n decoder: Decoder,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): Decoder {\n return createDecoder({\n ...decoder,\n read: (bytes: ReadonlyUint8Array | Uint8Array, offset) => {\n const [value, newOffset] = decoder.read(bytes, offset);\n return [map(value, bytes, offset), newOffset];\n },\n });\n}\n\n/**\n * Combines an encoder and a decoder into a codec.\n * The encoder and decoder must have the same fixed size, max size and description.\n * If a description is provided, it will override the encoder and decoder descriptions.\n */\nexport function combineCodec(\n encoder: FixedSizeEncoder,\n decoder: FixedSizeDecoder,\n): FixedSizeCodec;\nexport function combineCodec(\n encoder: VariableSizeEncoder,\n decoder: VariableSizeDecoder,\n): VariableSizeCodec;\nexport function combineCodec(\n encoder: Encoder,\n decoder: Decoder,\n): Codec;\nexport function combineCodec(\n encoder: Encoder,\n decoder: Decoder,\n): Codec {\n if (isFixedSize(encoder) !== isFixedSize(decoder)) {\n throw new Error(\"encoder and decoder size compatibility mismatch\");\n }\n\n if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {\n throw new Error(`encoder and decoder fixed size mismatch ${encoder.fixedSize} !== ${decoder.fixedSize}`);\n }\n\n if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {\n throw new Error(`encoder and decoder max size mismatch ${encoder.maxSize} !== ${decoder.maxSize}`);\n }\n\n return {\n ...decoder,\n ...encoder,\n decode: decoder.decode,\n encode: encoder.encode,\n read: decoder.read,\n write: encoder.write,\n };\n}\n\n/**\n * Converts a codec A to a codec B by mapping their values.\n */\nexport function transformCodec(\n codec: FixedSizeCodec,\n unmap: (value: TNewFrom) => TOldFrom,\n): FixedSizeCodec;\nexport function transformCodec(\n codec: VariableSizeCodec,\n unmap: (value: TNewFrom) => TOldFrom,\n): VariableSizeCodec;\nexport function transformCodec(\n codec: Codec,\n unmap: (value: TNewFrom) => TOldFrom,\n): Codec;\nexport function transformCodec<\n TOldFrom,\n TNewFrom,\n TOldTo extends TOldFrom,\n TNewTo extends TNewFrom,\n TSize extends number,\n>(\n codec: FixedSizeCodec,\n unmap: (value: TNewFrom) => TOldFrom,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): FixedSizeCodec;\nexport function transformCodec(\n codec: VariableSizeCodec,\n unmap: (value: TNewFrom) => TOldFrom,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): VariableSizeCodec;\nexport function transformCodec(\n codec: Codec,\n unmap: (value: TNewFrom) => TOldFrom,\n map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): Codec;\nexport function transformCodec(\n codec: Codec,\n unmap: (value: TNewFrom) => TOldFrom,\n map?: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,\n): Codec {\n return createCodec({\n ...transformEncoder(codec, unmap),\n read: map ? transformDecoder(codec, map).read : (codec.read as unknown as Decoder[\"read\"]),\n });\n}\n\n/**\n * Concatenates an array of `Uint8Array`s into a single `Uint8Array`.\n * Reuses the original byte array when applicable.\n */\nexport const mergeBytes = (byteArrays: Uint8Array[]): Uint8Array => {\n const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);\n if (nonEmptyByteArrays.length === 0) {\n return byteArrays.length ? byteArrays[0]! : new Uint8Array();\n }\n\n if (nonEmptyByteArrays.length === 1) {\n return nonEmptyByteArrays[0]!;\n }\n\n const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);\n const result = new Uint8Array(totalLength);\n let offset = 0;\n nonEmptyByteArrays.forEach((arr) => {\n result.set(arr, offset);\n offset += arr.length;\n });\n return result;\n};\n\n/**\n * Pads a `Uint8Array` with zeroes to the specified length.\n * If the array is longer than the specified length, it is returned as-is.\n */\nexport const padBytes = (bytes: ReadonlyUint8Array | Uint8Array, length: number): ReadonlyUint8Array | Uint8Array => {\n if (bytes.length >= length) return bytes;\n const paddedBytes = new Uint8Array(length).fill(0);\n paddedBytes.set(bytes);\n return paddedBytes;\n};\n\n/**\n * Fixes a `Uint8Array` to the specified length.\n * If the array is longer than the specified length, it is truncated.\n * If the array is shorter than the specified length, it is padded with zeroes.\n */\nexport const fixBytes = (bytes: ReadonlyUint8Array | Uint8Array, length: number): ReadonlyUint8Array | Uint8Array =>\n padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);\n\n/**\n * Returns true if and only if the provided `data` byte array contains\n * the provided `bytes` byte array at the specified `offset`.\n */\nexport function containsBytes(\n data: ReadonlyUint8Array | Uint8Array,\n bytes: ReadonlyUint8Array | Uint8Array,\n offset: number,\n): boolean {\n const slice = offset === 0 && data.length === bytes.length ? data : data.slice(offset, offset + bytes.length);\n if (slice.length !== bytes.length) return false;\n return bytes.every((b, i) => b === slice[i]);\n}\n\n/**\n * Creates a fixed-size encoder from a given encoder.\n *\n * @param encoder - The encoder to wrap into a fixed-size encoder.\n * @param fixedBytes - The fixed number of bytes to write.\n */\nexport function fixEncoderSize(\n encoder: Encoder,\n fixedBytes: TSize,\n): FixedSizeEncoder {\n return createEncoder({\n fixedSize: fixedBytes,\n write: (value: TFrom, bytes: Uint8Array, offset: Offset) => {\n // Here we exceptionally use the `encode` function instead of the `write`\n // function as using the nested `write` function on a fixed-sized byte\n // array may result in a out-of-bounds error on the nested encoder.\n const variableByteArray = encoder.encode(value);\n const fixedByteArray =\n variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;\n bytes.set(fixedByteArray, offset);\n return offset + fixedBytes;\n },\n });\n}\n\n/**\n * Creates a fixed-size decoder from a given decoder.\n *\n * @param decoder - The decoder to wrap into a fixed-size decoder.\n * @param fixedBytes - The fixed number of bytes to read.\n */\nexport function fixDecoderSize(\n decoder: Decoder,\n fixedBytes: TSize,\n): FixedSizeDecoder {\n return createDecoder({\n fixedSize: fixedBytes,\n read: (bytes, offset) => {\n assertByteArrayHasEnoughBytesForCodec(\"fixCodecSize\", fixedBytes, bytes, offset);\n // Slice the byte array to the fixed size if necessary.\n if (offset > 0 || bytes.length > fixedBytes) {\n bytes = bytes.slice(offset, offset + fixedBytes);\n }\n // If the nested decoder is fixed-size, pad and truncate the byte array accordingly.\n if (isFixedSize(decoder)) {\n bytes = fixBytes(bytes, decoder.fixedSize);\n }\n // Decode the value using the nested decoder.\n const [value] = decoder.read(bytes, 0);\n return [value, offset + fixedBytes];\n },\n });\n}\n\n/**\n * Creates a fixed-size codec from a given codec.\n *\n * @param codec - The codec to wrap into a fixed-size codec.\n * @param fixedBytes - The fixed number of bytes to read/write.\n */\nexport function fixCodecSize(\n codec: Codec,\n fixedBytes: TSize,\n): FixedSizeCodec {\n return combineCodec(fixEncoderSize(codec, fixedBytes), fixDecoderSize(codec, fixedBytes));\n}\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { combineCodec, createDecoder, createEncoder } from \"../core\";\n\nconst enum HexC {\n ZERO = 48, // 0\n NINE = 57, // 9\n A_UP = 65, // A\n F_UP = 70, // F\n A_LO = 97, // a\n F_LO = 102, // f\n}\n\nfunction charCodeToBase16(char: number) {\n if (char >= HexC.ZERO && char <= HexC.NINE) return char - HexC.ZERO;\n if (char >= HexC.A_UP && char <= HexC.F_UP) return char - (HexC.A_UP - 10);\n if (char >= HexC.A_LO && char <= HexC.F_LO) return char - (HexC.A_LO - 10);\n}\n\n/** Encodes strings in base16. */\nexport function getBase16Encoder(): VariableSizeEncoder {\n return createEncoder({\n getSizeFromValue: (value: string) => Math.ceil(value.length / 2),\n write(value: string, bytes, offset) {\n const len = value.length;\n const al = len / 2;\n if (len === 1) {\n const c = value.charCodeAt(0);\n const n = charCodeToBase16(c);\n if (n === undefined) {\n throw new Error(`Invalid string for base16: ${value}`);\n }\n bytes.set([n], offset);\n return 1 + offset;\n }\n const hexBytes = new Uint8Array(al);\n for (let i = 0, j = 0; i < al; i++) {\n const c1 = value.charCodeAt(j++);\n const c2 = value.charCodeAt(j++);\n\n const n1 = charCodeToBase16(c1);\n const n2 = charCodeToBase16(c2);\n if (n1 === undefined || (n2 === undefined && !Number.isNaN(c2))) {\n throw new Error(`Invalid string for base16: ${value}`);\n }\n hexBytes[i] = !Number.isNaN(c2) ? (n1 << 4) | (n2 ?? 0) : n1;\n }\n\n bytes.set(hexBytes, offset);\n return hexBytes.length + offset;\n },\n });\n}\n\n/** Decodes strings in base16. */\nexport function getBase16Decoder(): VariableSizeDecoder {\n return createDecoder({\n read(bytes, offset) {\n const value = bytes.slice(offset).reduce((str, byte) => str + byte.toString(16).padStart(2, \"0\"), \"\");\n return [value, bytes.length];\n },\n });\n}\n\n/** Encodes and decodes strings in base16. */\nexport function getBase16Codec(): VariableSizeCodec {\n return combineCodec(getBase16Encoder(), getBase16Decoder());\n}\n\nexport const base16: VariableSizeCodec = getBase16Codec();\n","import type { Encoder } from \"../codecs/core\";\nimport type { ReadonlyUint8Array } from \"../codecs/types\";\nimport { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from \"../assertions\";\nimport { getBase16Encoder } from \"../codecs/strings/base16\";\n\nexport type Signature = string & { readonly __brand: unique symbol };\nexport type SignatureBytes = Uint8Array & { readonly __brand: unique symbol };\n\nlet base16Encoder: Encoder | undefined;\n\nexport function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {\n if (!base16Encoder) base16Encoder = getBase16Encoder();\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest value (64 bytes of zeroes)\n putativeSignature.length < 64 ||\n // Highest value (64 bytes of 255)\n putativeSignature.length > 88\n ) {\n throw new Error(`Invalid signature length: ${putativeSignature.length} out of range`);\n }\n // Slow-path; actually attempt to decode the input string.\n const bytes = base16Encoder.encode(putativeSignature);\n const numBytes = bytes.byteLength;\n if (numBytes !== 64) {\n throw new Error(`Invalid signature length: ${numBytes} bytes`);\n }\n}\n\nexport function isSignature(putativeSignature: string): putativeSignature is Signature {\n if (!base16Encoder) base16Encoder = getBase16Encoder();\n\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest value (64 bytes of zeroes)\n putativeSignature.length < 64 ||\n // Highest value (64 bytes of 255)\n putativeSignature.length > 88\n ) {\n return false;\n }\n // Slow-path; actually attempt to decode the input string.\n const bytes = base16Encoder.encode(putativeSignature);\n const numBytes = bytes.byteLength;\n if (numBytes !== 64) {\n return false;\n }\n return true;\n}\n\nexport async function signBytes(key: CryptoKey, data: ReadonlyUint8Array): Promise {\n assertSigningCapabilityIsAvailable();\n const signedData = await crypto.subtle.sign(\"Ed25519\", key, data);\n return new Uint8Array(signedData) as SignatureBytes;\n}\n\nexport function signature(putativeSignature: string): Signature {\n assertIsSignature(putativeSignature);\n return putativeSignature;\n}\n\nexport async function verifySignature(\n key: CryptoKey,\n signature: SignatureBytes,\n data: ReadonlyUint8Array | Uint8Array,\n): Promise {\n assertVerificationCapabilityIsAvailable();\n return await crypto.subtle.verify(\"Ed25519\", key, signature, data);\n}\n","import crypto from \"uncrypto\";\n\nimport type { ReadonlyUint8Array } from \"../codecs/types\";\nimport { assertKeyExporterIsAvailable, assertKeyGenerationIsAvailable, assertPRNGIsAvailable } from \"../assertions\";\nimport { signBytes, verifySignature } from \"./signatures\";\n\nfunction addPkcs8Header(bytes: ReadonlyUint8Array): ReadonlyUint8Array {\n // prettier-ignore\n return new Uint8Array([\n /**\n * PKCS#8 header\n */\n 0x30, // ASN.1 sequence tag\n 0x2e, // Length of sequence (46 more bytes)\n\n 0x02, // ASN.1 integer tag\n 0x01, // Length of integer\n 0x00, // Version number\n\n 0x30, // ASN.1 sequence tag\n 0x05, // Length of sequence\n 0x06, // ASN.1 object identifier tag\n 0x03, // Length of object identifier\n // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n 0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n 0x65, // thawte(101)\n // Ed25519 identifier\n 0x70, // id-Ed25519(112)\n\n /**\n * Private key payload\n */\n 0x04, // ASN.1 octet string tag\n 0x22, // String length (34 more bytes)\n\n // Private key bytes as octet string\n 0x04, // ASN.1 octet string tag\n 0x20, // String length (32 bytes)\n\n ...bytes\n ]);\n}\n\nexport async function createPrivateKeyFromBytes(bytes: ReadonlyUint8Array, extractable?: boolean): Promise {\n const actualLength = bytes.byteLength;\n if (actualLength !== 32) {\n throw new Error(`Invalid private key length: ${actualLength}`);\n }\n const privateKeyBytesPkcs8 = addPkcs8Header(bytes);\n return crypto.subtle.importKey(\"pkcs8\", privateKeyBytesPkcs8, \"Ed25519\", extractable ?? false, [\"sign\"]);\n}\n\nexport async function getPublicKeyFromPrivateKey(\n privateKey: CryptoKey,\n extractable: boolean = false,\n): Promise {\n assertKeyExporterIsAvailable();\n\n if (privateKey.extractable === false) {\n throw new Error(`Private key ${privateKey} is not extractable`);\n }\n\n // Export private key.\n const jwk = await crypto.subtle.exportKey(\"jwk\", privateKey);\n\n // Import public key.\n return await crypto.subtle.importKey(\n \"jwk\",\n {\n crv /* curve */: \"Ed25519\",\n ext /* extractable */: extractable,\n key_ops /* key operations */: [\"verify\"],\n kty /* key type */: \"OKP\" /* octet key pair */,\n x /* public key x-coordinate */: jwk.x,\n },\n \"Ed25519\",\n extractable,\n [\"verify\"],\n );\n}\n\nexport async function generateKeyPair(): Promise {\n await assertKeyGenerationIsAvailable();\n const keyPair = await crypto.subtle.generateKey(\n /* algorithm */ \"Ed25519\", // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n /* allowed uses */ [\"sign\", \"verify\"],\n );\n return keyPair as CryptoKeyPair;\n}\n\nexport async function generateExtractableKeyPair(): Promise {\n await assertKeyGenerationIsAvailable();\n const keyPair = await crypto.subtle.generateKey(\"Ed25519\", true, [\"sign\", \"verify\"]);\n return keyPair as CryptoKeyPair;\n}\n\nexport async function createKeyPairFromBytes(bytes: ReadonlyUint8Array, extractable?: boolean): Promise {\n assertPRNGIsAvailable();\n\n if (bytes.byteLength !== 64) {\n throw new Error(`invalid key pair length: ${bytes.byteLength}`);\n }\n const [publicKey, privateKey] = await Promise.all([\n crypto.subtle.importKey(\"raw\", bytes.slice(32), \"Ed25519\", /* extractable */ true, [\"verify\"]),\n createPrivateKeyFromBytes(bytes.slice(0, 32), extractable),\n ]);\n\n // Verify the key pair\n const randomBytes = new Uint8Array(32);\n crypto.getRandomValues(randomBytes);\n const signedData = await signBytes(privateKey, randomBytes);\n const isValid = await verifySignature(publicKey, signedData, randomBytes);\n if (!isValid) {\n throw new Error(\"public key must match private key\");\n }\n\n return { privateKey, publicKey } as CryptoKeyPair;\n}\n\nexport async function createKeyPairFromPrivateKeyBytes(\n bytes: ReadonlyUint8Array,\n extractable: boolean = false,\n): Promise {\n const privateKeyPromise = createPrivateKeyFromBytes(bytes, extractable);\n\n // Here we need the private key to be extractable in order to export\n // it as a public key. Therefore, if the `extractable` parameter\n // is `false`, we need to create two private keys such that:\n // - The extractable one is used to create the public key and\n // - The non-extractable one is the one we will return.\n const [publicKey, privateKey] = await Promise.all([\n // This nested promise makes things efficient by\n // creating the public key in parallel with the\n // second private key creation, if it is needed.\n (extractable ? privateKeyPromise : createPrivateKeyFromBytes(bytes, true /* extractable */)).then(\n async (privateKey) => await getPublicKeyFromPrivateKey(privateKey, true /* extractable */),\n ),\n privateKeyPromise,\n ]);\n\n return { privateKey, publicKey };\n}\n","import type { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from \"./codecs/core\";\nimport { assertKeyExporterIsAvailable } from \"./assertions\";\nimport { combineCodec, fixDecoderSize, fixEncoderSize, transformEncoder } from \"./codecs/core\";\nimport { base16 } from \"./codecs/strings/base16\";\nimport { generateExtractableKeyPair } from \"./keys/keys\";\n\nexport type Address = TAddress & {\n readonly __brand: unique symbol;\n};\n\nexport function isAddress(putativeAddress: string): putativeAddress is Address {\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest address (32 bytes of zeroes)\n putativeAddress.length < 32 ||\n // Highest address (32 bytes of 255)\n putativeAddress.length > 44\n ) {\n return false;\n }\n // Slow-path; actually attempt to decode the input string.\n\n const bytes = base16.encode(putativeAddress);\n const numBytes = bytes.byteLength;\n if (numBytes !== 32) {\n return false;\n }\n return true;\n}\n\nexport function assertIsAddress(putativeAddress: string): asserts putativeAddress is Address {\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest address (32 bytes of zeroes)\n putativeAddress.length < 32 ||\n // Highest address (32 bytes of 255)\n putativeAddress.length > 44\n ) {\n throw new Error(`Invalid address length: ${putativeAddress.length} out of range`);\n }\n // Slow-path; actually attempt to decode the input string.\n const bytes = base16.encode(putativeAddress);\n const numBytes = bytes.byteLength;\n if (numBytes !== 32) {\n throw new Error(`Invalid address length: ${numBytes} bytes`);\n }\n}\n\nexport function address(putativeAddress: TAddress): Address {\n assertIsAddress(putativeAddress);\n return putativeAddress as Address;\n}\n\nlet addressEncoder: FixedSizeEncoder | undefined;\nlet addressDecoder: FixedSizeDecoder | undefined;\nlet addressCodec: FixedSizeCodec | undefined;\nexport function getAddressEncoder(): FixedSizeEncoder {\n return (addressEncoder ??= transformEncoder(fixEncoderSize(base16, 32), (putativeAddress) =>\n address(putativeAddress),\n ));\n}\n\nexport function getAddressDecoder(): FixedSizeDecoder {\n return (addressDecoder ??= fixDecoderSize(base16, 32) as FixedSizeDecoder);\n}\n\nexport function getAddressCodec(): FixedSizeCodec {\n return (addressCodec ??= combineCodec(getAddressEncoder(), getAddressDecoder()));\n}\n\nexport function getAddressComparator(): (x: string, y: string) => number {\n return new Intl.Collator(\"en\", {\n caseFirst: \"lower\",\n ignorePunctuation: false,\n localeMatcher: \"best fit\",\n numeric: false,\n sensitivity: \"variant\",\n usage: \"sort\",\n }).compare;\n}\n\nexport async function exportBase16Key(key: CryptoKey): Promise {\n assertKeyExporterIsAvailable();\n if (!key.extractable || key.algorithm.name !== \"Ed25519\") {\n throw new Error(`Key is not extractable or has an invalid algorithm: ${key.algorithm.name}`);\n }\n const keyBytes = await crypto.subtle.exportKey(\"raw\", key);\n return getAddressDecoder().decode(new Uint8Array(keyBytes));\n}\n\nexport type KAccount = `k:${Address}` & {\n readonly __brand: unique symbol;\n};\n\nexport function isKAccount(putativeAccount: string): putativeAccount is KAccount {\n return putativeAccount.startsWith(\"k:\") && isAddress(putativeAccount.slice(2));\n}\n\nexport function assertIsKAccount(putativeAccount: string): asserts putativeAccount is KAccount {\n if (!isKAccount(putativeAccount)) {\n throw new Error(`Invalid account: ${putativeAccount}`);\n }\n}\n\nexport function kAccount(putativeAccount: string): KAccount {\n assertIsKAccount(putativeAccount);\n return putativeAccount as KAccount;\n}\n\nexport async function getKAccountFromPublicKey(publicKey: CryptoKey): Promise {\n const address = await exportBase16Key(publicKey);\n return kAccount(`k:${address}`);\n}\n\ninterface KeyPair {\n publicKey: string;\n privateKey: string;\n}\nexport async function genKeyPair(): Promise {\n const keyPair = await generateExtractableKeyPair();\n return {\n publicKey: await exportBase16Key(keyPair.publicKey),\n privateKey: await exportBase16Key(keyPair.privateKey),\n };\n}\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { assertValidBaseString } from \"../../assertions\";\nimport { combineCodec, createDecoder, createEncoder } from \"../core\";\n\n/**\n * Encodes a string using a custom alphabet by dividing\n * by the base and handling leading zeroes.\n * @see {@link getBaseXCodec} for a more detailed description.\n */\nexport const getBaseXEncoder = (alphabet: string): VariableSizeEncoder => {\n return createEncoder({\n getSizeFromValue: (value: string): number => {\n const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet[0]!);\n if (!tailChars) return value.length;\n\n const base10Number = getBigIntFromBaseX(tailChars, alphabet);\n return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);\n },\n write(value: string, bytes, offset) {\n // Check if the value is valid.\n assertValidBaseString(alphabet, value);\n if (value === \"\") return offset;\n\n // Handle leading zeroes.\n const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet[0]!);\n if (!tailChars) {\n bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);\n return offset + leadingZeroes.length;\n }\n\n // From baseX to base10.\n let base10Number = getBigIntFromBaseX(tailChars, alphabet);\n\n // From base10 to bytes.\n const tailBytes: number[] = [];\n while (base10Number > 0n) {\n tailBytes.unshift(Number(base10Number % 256n));\n base10Number /= 256n;\n }\n\n const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];\n bytes.set(bytesToAdd, offset);\n return offset + bytesToAdd.length;\n },\n });\n};\n\n/**\n * Decodes a string using a custom alphabet by dividing\n * by the base and handling leading zeroes.\n * @see {@link getBaseXCodec} for a more detailed description.\n */\nexport const getBaseXDecoder = (alphabet: string): VariableSizeDecoder => {\n return createDecoder({\n read(rawBytes, offset): [string, number] {\n const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n if (bytes.length === 0) return [\"\", 0];\n\n // Handle leading zeroes.\n let trailIndex = bytes.findIndex((n) => n !== 0);\n trailIndex = trailIndex === -1 ? bytes.length : trailIndex;\n const leadingZeroes = alphabet[0]!.repeat(trailIndex);\n if (trailIndex === bytes.length) return [leadingZeroes, rawBytes.length];\n\n // From bytes to base10.\n const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);\n\n // From base10 to baseX.\n const tailChars = getBaseXFromBigInt(base10Number, alphabet);\n\n return [leadingZeroes + tailChars, rawBytes.length];\n },\n });\n};\n\n/**\n * A string codec that requires a custom alphabet and uses\n * the length of that alphabet as the base. It then divides\n * the input by the base as many times as necessary to get\n * the output. It also supports leading zeroes by using the\n * first character of the alphabet as the zero character.\n *\n * This can be used to create codecs such as base10 or base58.\n */\nexport const getBaseXCodec = (alphabet: string): VariableSizeCodec =>\n combineCodec(getBaseXEncoder(alphabet), getBaseXDecoder(alphabet));\n\nfunction partitionLeadingZeroes(\n value: string,\n zeroCharacter: string,\n): [leadingZeros: string, tailChars: string | undefined] {\n const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));\n return [leadingZeros!, tailChars];\n}\n\nfunction getBigIntFromBaseX(value: string, alphabet: string): bigint {\n const base = BigInt(alphabet.length);\n let sum = 0n;\n for (const char of value) {\n sum *= base;\n sum += BigInt(alphabet.indexOf(char));\n }\n return sum;\n}\n\nfunction getBaseXFromBigInt(value: bigint, alphabet: string): string {\n const base = BigInt(alphabet.length);\n const tailChars = [];\n while (value > 0n) {\n tailChars.unshift(alphabet[Number(value % base)]);\n value /= base;\n }\n return tailChars.join(\"\");\n}\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { getBaseXCodec, getBaseXDecoder, getBaseXEncoder } from \"./baseX\";\n\nconst alphabet = \"0123456789\";\n\n/** Encodes strings in base10. */\nexport function getBase10Encoder(): VariableSizeEncoder {\n return getBaseXEncoder(alphabet);\n}\n\n/** Decodes strings in base10. */\nexport function getBase10Decoder(): VariableSizeDecoder {\n return getBaseXDecoder(alphabet);\n}\n\n/** Encodes and decodes strings in base10. */\nexport function getBase10Codec(): VariableSizeCodec {\n return getBaseXCodec(alphabet);\n}\n\nexport const base10: VariableSizeCodec = getBase10Codec();\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { getBaseXCodec, getBaseXDecoder, getBaseXEncoder } from \"./baseX\";\n\nconst alphabet = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\";\n\n/** Encodes strings in base58. */\nexport function getBase58Encoder(): VariableSizeEncoder {\n return getBaseXEncoder(alphabet);\n}\n\n/** Decodes strings in base58. */\nexport function getBase58Decoder(): VariableSizeDecoder {\n return getBaseXDecoder(alphabet);\n}\n\n/** Encodes and decodes strings in base58. */\nexport function getBase58Codec(): VariableSizeCodec {\n return getBaseXCodec(alphabet);\n}\n\nexport const base58: VariableSizeCodec = getBase58Codec();\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { assertValidBaseString } from \"../../assertions\";\nimport { combineCodec, createDecoder, createEncoder } from \"../core\";\n\n/**\n * Encodes a string using a custom alphabet by reslicing the bits of the byte array.\n * @see {@link getBaseXResliceCodec} for a more detailed description.\n */\nexport function getBaseXResliceEncoder(alphabet: string, bits: number): VariableSizeEncoder {\n return createEncoder({\n getSizeFromValue: (value: string) => Math.floor((value.length * bits) / 8),\n write(value: string, bytes, offset) {\n assertValidBaseString(alphabet, value);\n if (value === \"\") return offset;\n const charIndices = [...value].map((c) => alphabet.indexOf(c));\n const reslicedBytes = reslice(charIndices, bits, 8, false);\n bytes.set(reslicedBytes, offset);\n return reslicedBytes.length + offset;\n },\n });\n}\n\n/**\n * Decodes a string using a custom alphabet by reslicing the bits of the byte array.\n * @see {@link getBaseXResliceCodec} for a more detailed description.\n */\nexport function getBaseXResliceDecoder(alphabet: string, bits: number): VariableSizeDecoder {\n return createDecoder({\n read(rawBytes, offset = 0): [string, number] {\n const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n if (bytes.length === 0) return [\"\", rawBytes.length];\n const charIndices = reslice([...bytes], 8, bits, true);\n return [charIndices.map((i) => alphabet[i]).join(\"\"), rawBytes.length];\n },\n });\n}\n/**\n * A string serializer that reslices bytes into custom chunks\n * of bits that are then mapped to a custom alphabet.\n *\n * This can be used to create serializers whose alphabet\n * is a power of 2 such as base16 or base64.\n */\nexport function getBaseXResliceCodec(alphabet: string, bits: number): VariableSizeCodec {\n return combineCodec(getBaseXResliceEncoder(alphabet, bits), getBaseXResliceDecoder(alphabet, bits));\n}\n\n/** Helper function to reslice the bits inside bytes. */\nfunction reslice(input: number[], inputBits: number, outputBits: number, useRemainder: boolean): number[] {\n const output = [];\n let accumulator = 0;\n let bitsInAccumulator = 0;\n const mask = (1 << outputBits) - 1;\n for (const value of input) {\n accumulator = (accumulator << inputBits) | value;\n bitsInAccumulator += inputBits;\n while (bitsInAccumulator >= outputBits) {\n bitsInAccumulator -= outputBits;\n output.push((accumulator >> bitsInAccumulator) & mask);\n }\n }\n if (useRemainder && bitsInAccumulator > 0) {\n output.push((accumulator << (outputBits - bitsInAccumulator)) & mask);\n }\n return output;\n}\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { assertValidBaseString } from \"../../assertions\";\nimport { combineCodec, createDecoder, createEncoder, transformDecoder, transformEncoder } from \"../core\";\nimport { getBaseXResliceDecoder, getBaseXResliceEncoder } from \"./baseX-reslice\";\n\nconst alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n/** Encodes strings in base64. */\nexport function getBase64Encoder(): VariableSizeEncoder {\n if (__BROWSER__) {\n return createEncoder({\n getSizeFromValue: (value: string) => {\n try {\n return (atob as Window[\"atob\"])(value).length;\n } catch {\n throw new Error(`Invalid string for base64: ${value}`);\n }\n },\n write(value: string, bytes, offset) {\n try {\n const bytesToAdd = (atob as Window[\"atob\"])(value)\n .split(\"\")\n .map((c) => c.charCodeAt(0));\n bytes.set(bytesToAdd, offset);\n return bytesToAdd.length + offset;\n } catch {\n throw new Error(`Invalid string for base64: ${value}`);\n }\n },\n });\n }\n\n if (__NODEJS__) {\n return createEncoder({\n getSizeFromValue: (value: string) => Buffer.from(value, \"base64\").length,\n write(value: string, bytes, offset) {\n assertValidBaseString(alphabet, value.replace(/=/g, \"\"));\n const buffer = Buffer.from(value, \"base64\");\n bytes.set(buffer, offset);\n return buffer.length + offset;\n },\n });\n }\n\n return transformEncoder(getBaseXResliceEncoder(alphabet, 6), (value: string): string => value.replace(/=/g, \"\"));\n}\n\n/** Decodes strings in base64. */\nexport function getBase64Decoder(): VariableSizeDecoder {\n if (__BROWSER__) {\n return createDecoder({\n read(bytes, offset = 0) {\n const slice = bytes.slice(offset);\n const value = (btoa as Window[\"btoa\"])(String.fromCharCode(...slice));\n return [value, bytes.length];\n },\n });\n }\n\n if (__NODEJS__) {\n return createDecoder({\n read: (bytes, offset = 0) => [Buffer.from(bytes.buffer, offset).toString(\"base64\"), bytes.length],\n });\n }\n\n return transformDecoder(getBaseXResliceDecoder(alphabet, 6), (value: string): string =>\n value.padEnd(Math.ceil(value.length / 4) * 4, \"=\"),\n );\n}\n\n/** Encodes and decodes strings in base64. */\nexport function getBase64Codec(): VariableSizeCodec {\n return combineCodec(getBase64Encoder(), getBase64Decoder());\n}\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { combineCodec, createDecoder, createEncoder, transformDecoder, transformEncoder } from \"../core\";\nimport { getBaseXResliceDecoder, getBaseXResliceEncoder } from \"./baseX-reslice\";\n\nconst base64UrlAlphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\n\n/** Encodes strings in base64url. */\nexport function getBase64UrlEncoder(): VariableSizeEncoder {\n if (__BROWSER__) {\n return createEncoder({\n getSizeFromValue: (value: string) => {\n try {\n const paddedValue = value\n .replace(/-/g, \"+\")\n .replace(/_/g, \"/\")\n .padEnd(Math.ceil(value.length / 4) * 4, \"=\");\n return atob(paddedValue).length;\n } catch {\n throw new Error(`Invalid string for base64url: ${value}`);\n }\n },\n write(value: string, bytes, offset) {\n try {\n const paddedValue = value\n .replace(/-/g, \"+\")\n .replace(/_/g, \"/\")\n .padEnd(Math.ceil(value.length / 4) * 4, \"=\");\n const bytesToAdd = atob(paddedValue)\n .split(\"\")\n .map((c) => c.charCodeAt(0));\n bytes.set(bytesToAdd, offset);\n return bytesToAdd.length + offset;\n } catch {\n throw new Error(`Invalid string for base64url: ${value}`);\n }\n },\n });\n }\n\n if (__NODEJS__) {\n return createEncoder({\n getSizeFromValue: (value: string) => Buffer.from(value, \"base64url\").length,\n write(value: string, bytes, offset) {\n // assertValidBaseString(base64UrlAlphabet, value);\n const buffer = Buffer.from(value, \"base64url\");\n bytes.set(buffer, offset);\n return buffer.length + offset;\n },\n });\n }\n\n return transformEncoder(getBaseXResliceEncoder(base64UrlAlphabet, 6), (value: string): string => value);\n}\n\n/** Decodes strings in base64url. */\nexport function getBase64UrlDecoder(): VariableSizeDecoder {\n if (__BROWSER__) {\n return createDecoder({\n read(bytes, offset = 0) {\n const slice = bytes.slice(offset);\n const base64 = btoa(Array.from(slice, (b) => String.fromCharCode(b)).join(\"\"))\n .replace(/\\+/g, \"-\")\n .replace(/\\//g, \"_\")\n .replace(/=+$/, \"\");\n return [base64, bytes.length];\n },\n });\n }\n\n if (__NODEJS__) {\n return createDecoder({\n read: (bytes, offset = 0) => [Buffer.from(bytes.slice(offset)).toString(\"base64url\"), bytes.length],\n });\n }\n\n return transformDecoder(getBaseXResliceDecoder(base64UrlAlphabet, 6), (value: string): string => value);\n}\n\n/** Encodes and decodes strings in base64url. */\nexport function getBase64UrlCodec(): VariableSizeCodec {\n return combineCodec(getBase64UrlEncoder(), getBase64UrlDecoder());\n}\n\nexport const base64Url: VariableSizeCodec = getBase64UrlCodec();\n","/**Removes null characters from a string. */\nexport function removeNullCharacters(value: string): string {\n // eslint-disable-next-line no-control-regex\n return value.replace(/\\u0000/g, \"\");\n}\n\n/** Pads a string with null characters at the end. */\nexport function padNullCharacters(value: string, chars: number): string {\n return value.padEnd(chars, \"\\u0000\");\n}\n","// TODO: fix this for react native\nexport const TextDecoder = globalThis.TextDecoder as typeof globalThis.TextDecoder;\nexport const TextEncoder = globalThis.TextEncoder as typeof globalThis.TextEncoder;\n","import type { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from \"../core\";\nimport { combineCodec, createDecoder, createEncoder } from \"../core\";\nimport { removeNullCharacters } from \"./null\";\nimport { TextEncoder, TextDecoder } from \"../text\";\n\n/** Encodes UTF-8 strings using the native `TextEncoder` API. */\nexport function getUtf8Encoder(): VariableSizeEncoder {\n let textEncoder: TextEncoder;\n return createEncoder({\n getSizeFromValue: (value) => (textEncoder ||= new TextEncoder()).encode(value).length,\n write: (value: string, bytes, offset) => {\n const bytesToAdd = (textEncoder ||= new TextEncoder()).encode(value);\n bytes.set(bytesToAdd, offset);\n return offset + bytesToAdd.length;\n },\n });\n}\n\n/** Decodes UTF-8 strings using the native `TextDecoder` API. */\nexport function getUtf8Decoder(): VariableSizeDecoder {\n let textDecoder: TextDecoder;\n return createDecoder({\n read(bytes, offset) {\n const value = (textDecoder ||= new TextDecoder()).decode(bytes.slice(offset));\n return [removeNullCharacters(value), bytes.length];\n },\n });\n}\n\n/** Encodes and decodes UTF-8 strings using the native `TextEncoder` and `TextDecoder` API. */\nexport function getUtf8Codec(): VariableSizeCodec {\n return combineCodec(getUtf8Encoder(), getUtf8Decoder());\n}\n\nexport const utf8: VariableSizeCodec = getUtf8Codec();\n","// import { base64url } from \"@scure/base\";\n\nimport { base64Url } from \"../codecs/strings/base64-url\";\nimport { blake2b } from \"./blake2b\";\n\nexport function blake2bBase64Url(input: string | Uint8Array): string {\n return base64Url.decode(blake2b(input, undefined, 32));\n}\n","const objToString = Object.prototype.toString;\nconst objKeys =\n Object.keys ||\n function (obj) {\n const keys = [];\n for (const name in obj) {\n keys.push(name);\n }\n return keys;\n };\n\nfunction stringify(val: unknown, isArrayProp: boolean) {\n let i, max, str, keys, key, propVal, toStr;\n if (val === true) {\n return \"true\";\n }\n if (val === false) {\n return \"false\";\n }\n switch (typeof val) {\n case \"object\":\n if (val === null) {\n return null;\n } else if (\"toJSON\" in val && typeof val.toJSON === \"function\") {\n return stringify(val.toJSON(), isArrayProp);\n } else {\n toStr = objToString.call(val);\n if (toStr === \"[object Array]\") {\n str = \"[\";\n max = (val as unknown[]).length - 1;\n for (i = 0; i < max; i++) {\n str += stringify((val as unknown[])[i], true) + \",\";\n }\n if (max > -1) {\n str += stringify((val as unknown[])[i], true);\n }\n return str + \"]\";\n } else if (toStr === \"[object Object]\") {\n // only object is left\n keys = objKeys(val).sort();\n max = keys.length;\n str = \"\";\n i = 0;\n while (i < max) {\n key = keys[i];\n //@ts-expect-error\n propVal = stringify((val as Record)[key], false);\n if (propVal !== undefined) {\n if (str) {\n str += \",\";\n }\n str += JSON.stringify(key) + \":\" + propVal;\n }\n i++;\n }\n return \"{\" + str + \"}\";\n } else {\n return JSON.stringify(val);\n }\n }\n case \"function\":\n case \"undefined\":\n return isArrayProp ? null : undefined;\n case \"bigint\":\n return `${val.toString()}n`;\n case \"string\":\n return JSON.stringify(val);\n default:\n return isFinite(val as number) ? val : null;\n }\n}\n\nexport function fastStableStringify(\n val:\n | Function // eslint-disable-line @typescript-eslint/no-unsafe-function-type\n | undefined,\n): undefined;\nexport function fastStableStringify(val: unknown): string;\nexport function fastStableStringify(val: unknown): string | undefined {\n const returnVal = stringify(val, false);\n if (returnVal !== undefined) {\n return \"\" + returnVal;\n }\n}\n","import { install } from \"./polyfill\";\n\nif (!__NODEJS__) {\n install();\n}\n\nexport * from \"./address\";\nexport * from \"./assertions\";\nexport * from \"./codecs\";\nexport * from \"./hash\";\nexport * from \"./keys\";\nexport * from \"./stringify\";\n"],"x_google_ignoreList":[0],"mappings":"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"}