{
  "version": 3,
  "sources": ["../src/util.ts"],
  "sourcesContent": ["import { webcrypto } from '@bicycle-codes/one-webcrypto'\nimport { fromString, concat, toString as uToString } from 'uint8arrays'\nimport type {\n    DID,\n    Msg,\n    HashAlg,\n    SymmKeyOpts,\n    SymmKey\n} from './types.js'\nimport {\n    KeyUse,\n    CharSize,\n} from './types.js'\nimport {\n    BASE58_DID_PREFIX,\n    RSA_SIGN_ALGORITHM,\n    RSA_ALGORITHM,\n    DEFAULT_HASH_ALGORITHM,\n    DEFAULT_CHAR_SIZE,\n    SALT_LENGTH,\n    RSA_HASHING_ALGORITHM,\n    RSA_DID_PREFIX,\n    KEY_TYPE,\n    EDWARDS_DID_PREFIX,\n    BLS_DID_PREFIX,\n    DEFAULT_SYMM_ALGORITHM,\n    DEFAULT_SYMM_LENGTH\n} from './constants.js'\n\n/**\n * Using the key type as the record property name (ie. string = key type)\n *\n * The magic bytes are the `code` found in {@link https://github.com/multiformats/multicodec/blob/master/table.csv}\n * encoded as a variable integer (more info about that at {@link https://github.com/multiformats/unsigned-varint)}.\n *\n * The key type is also found in that table.\n * It's the name of the codec minus the `-pub` suffix.\n *\n * Example\n * -------\n * Ed25519 public key\n * Key type: \"ed25519\"\n * Magic bytes: [ 0xed, 0x01 ]\n */\ntype KeyTypes = Record<string, {\n    magicBytes:Uint8Array\n    verify:(args:{\n        message: Uint8Array\n        publicKey: Uint8Array\n        signature: Uint8Array\n    }) => Promise<boolean>\n}>\n\nexport const did:{ keyTypes:KeyTypes } = {\n    keyTypes: {\n        'bls12-381': {\n            magicBytes: new Uint8Array([0xea, 0x01]),\n            verify: () => { throw new Error('Not implemented') },\n        },\n        rsa: {\n            magicBytes: new Uint8Array([0x00, 0xf5, 0x02]),\n            verify: rsaVerify,\n        },\n    }\n}\n\n/**\n * Create a 32 character, DNS-friendly hash of the given DID.\n *\n * @param {DID} did String representation of the DID for the device\n * @returns {string} The 32 character, DNS friendly hash\n */\nexport async function createDeviceName (did:DID):Promise<string> {\n    const normalizedDid = did.normalize('NFD')\n    const hashedUsername = await sha256(\n        new TextEncoder().encode(normalizedDid)\n    )\n    return uToString(hashedUsername, 'base32').slice(0, 32)\n}\n\nexport async function sha256 (bytes:Uint8Array):Promise<Uint8Array> {\n    return new Uint8Array(await webcrypto.subtle.digest('sha-256', bytes))\n}\n\n/**\n * Convert a public key to a DID format string.\n *\n * @param {Uint8Array|CryptoKey|CryptoKeyPair} publicKey Public key as Uint8Array\n * @param {'rsa'} [keyType] 'rsa' only\n * @returns {DID} A DID format string\n */\nexport async function publicKeyToDid (\n    _publicKey:Uint8Array|CryptoKey,\n    keyType = 'rsa'\n):Promise<DID> {\n    const publicKey = ((_publicKey instanceof CryptoKey) ?\n        new Uint8Array(await getPublicKeyAsArrayBuffer(_publicKey)) :\n        _publicKey\n    )\n\n    // Prefix public-write key\n    const prefix = did.keyTypes[keyType]?.magicBytes\n    if (!prefix) {\n        throw new Error(`Key type '${keyType}' not supported, ` +\n            `available types: ${Object.keys(did.keyTypes).join(', ')}`)\n    }\n\n    const prefixedBuf = concat([prefix, publicKey])\n\n    return (BASE58_DID_PREFIX + uToString(prefixedBuf, 'base58btc')) as DID\n}\n\nexport const rsaOperations = {\n    verify: async function rsaVerify (\n        msg:Msg,\n        sig:Msg,\n        publicKey:string|CryptoKey,\n        charSize:CharSize = DEFAULT_CHAR_SIZE,\n        hashAlg:HashAlg = DEFAULT_HASH_ALGORITHM\n    ):Promise<boolean> {\n        return webcrypto.subtle.verify(\n            {\n                name: RSA_SIGN_ALGORITHM,\n                saltLength: SALT_LENGTH\n            },\n            (typeof publicKey === 'string' ?\n                await importPublicKey(publicKey, hashAlg, KeyUse.Sign) :\n                publicKey),\n            normalizeBase64ToBuf(sig),\n            normalizeUnicodeToBuf(msg, charSize)\n        )\n    },\n\n    sign: async function sign (\n        msg:Msg,\n        privateKey:CryptoKey,\n        charSize:CharSize = DEFAULT_CHAR_SIZE\n    ):Promise<ArrayBuffer> {\n        return webcrypto.subtle.sign(\n            { name: RSA_SIGN_ALGORITHM, saltLength: SALT_LENGTH },\n            privateKey,\n            normalizeUnicodeToBuf(msg, charSize)\n        )\n    },\n\n    /**\n     * Encrypt the given AES key *to* a given public key.\n     */\n    encrypt: async function rsaEncrypt (\n        msg:Msg,\n        publicKey:string|CryptoKey|Uint8Array,\n        charSize:CharSize = DEFAULT_CHAR_SIZE,\n        hashAlg:HashAlg = DEFAULT_HASH_ALGORITHM\n    ):Promise<ArrayBuffer> {\n        let pubKey:CryptoKey\n        if (typeof publicKey === 'string') {\n            pubKey = await importPublicKey(publicKey, hashAlg, KeyUse.Encrypt)\n        } else {\n            pubKey = publicKey instanceof Uint8Array ?\n                await importPublicKey(publicKey, hashAlg, KeyUse.Encrypt) :\n                publicKey\n        }\n\n        return webcrypto.subtle.encrypt(\n            { name: RSA_ALGORITHM },\n            pubKey,\n            normalizeUnicodeToBuf(msg, charSize)\n        )\n    },\n\n    /**\n     * Use RSA to decrypt the given data.\n     */\n    decrypt: async function rsaDecrypt (\n        _data:Uint8Array|string|ArrayBuffer,\n        privateKey:CryptoKey|Uint8Array|ArrayBuffer\n    ):Promise<Uint8Array> {\n        const key = isCryptoKey(privateKey) ?\n            privateKey :\n            await importRsaKey(privateKey, ['decrypt'])\n\n        let data:Uint8Array|ArrayBuffer\n        if (typeof _data === 'string') {\n            data = fromString(_data, 'base64pad')\n        } else {\n            data = _data\n        }\n\n        const arrayBuffer = await webcrypto.subtle.decrypt(\n            { name: RSA_ALGORITHM },\n            key,\n            data\n        )\n\n        const arr = new Uint8Array(arrayBuffer)\n\n        return arr\n    }\n}\n\nexport async function rsaVerify ({\n    message,\n    publicKey,\n    signature\n}:{\n    message: Uint8Array\n    publicKey: Uint8Array\n    signature: Uint8Array\n}):Promise<boolean> {\n    return rsaOperations.verify(\n        message,\n        signature,\n        await webcrypto.subtle.importKey(\n            'spki',\n            publicKey,\n            { name: RSA_SIGN_ALGORITHM, hash: RSA_HASHING_ALGORITHM },\n            false,\n            ['verify']\n        ),\n        8\n    )\n}\n\nexport async function importPublicKey (\n    base64Key:string|ArrayBuffer,\n    hashAlg:HashAlg,\n    use:KeyUse\n):Promise<CryptoKey> {\n    checkValidKeyUse(use)\n    const alg = (use === KeyUse.Encrypt ? RSA_ALGORITHM : RSA_SIGN_ALGORITHM)\n    const uses:KeyUsage[] = use === KeyUse.Encrypt ?\n        ['encrypt'] :\n        ['verify']\n    const buf = typeof base64Key === 'string' ?\n        base64ToArrBuf(stripKeyHeader(base64Key)) :\n        base64Key\n\n    return webcrypto.subtle.importKey('spki', buf, {\n        name: alg,\n        hash: { name: hashAlg }\n    }, true, uses)\n}\n\nexport const InvalidKeyUse = new Error(\"Invalid key use. Please use 'encryption' or 'signing\")\nexport const InvalidMaxValue = new Error('Max must be less than 256 and greater than 0')\n\nexport function checkValidKeyUse (use:KeyUse):void {\n    checkValid(use, [KeyUse.Sign, KeyUse.Encrypt], InvalidKeyUse)\n}\n\nfunction checkValid<T> (toCheck: T, opts: T[], error: Error): void {\n    const match = opts.some(opt => opt === toCheck)\n    if (!match) {\n        throw error\n    }\n}\n\nfunction stripKeyHeader (base64Key:string):string {\n    return base64Key\n        .replace('-----BEGIN PUBLIC KEY-----\\n', '')\n        .replace('\\n-----END PUBLIC KEY-----', '')\n}\n\nexport function base64ToArrBuf (string:string):ArrayBuffer {\n    return fromString(string, 'base64pad').buffer\n}\n\nexport const normalizeToBuf = (\n    msg:Msg,\n    strConv:(str:string)=>ArrayBuffer\n):ArrayBuffer => {\n    if (typeof msg === 'string') {\n        return strConv(msg)\n    } else if (typeof msg === 'object' && msg.byteLength !== undefined) {\n        // this is the best runtime check I could find for ArrayBuffer/Uint8Array\n        const temp = new Uint8Array(msg)\n        return temp.buffer\n    } else {\n        throw new Error('Improper value. Must be a string, ArrayBuffer, Uint8Array')\n    }\n}\n\nexport function normalizeBase64ToBuf (msg:Msg):ArrayBuffer {\n    return normalizeToBuf(msg, base64ToArrBuf)\n}\n\nexport const normalizeUtf8ToBuf = (msg:Msg): ArrayBuffer => {\n    return normalizeToBuf(msg, (str) => strToArrBuf(str, CharSize.B8))\n}\n\nexport function strToArrBuf (str:string, charSize:CharSize):ArrayBuffer {\n    const view = charSize === 8 ?\n        new Uint8Array(str.length) :\n        new Uint16Array(str.length)\n\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n        view[i] = str.charCodeAt(i)\n    }\n\n    return view.buffer\n}\n\nexport const normalizeUtf16ToBuf = (msg:Msg): ArrayBuffer => {\n    return normalizeToBuf(msg, (str) => strToArrBuf(str, CharSize.B16))\n}\n\nexport function normalizeUnicodeToBuf (msg:Msg, charSize:CharSize) {\n    switch (charSize) {\n        case 8: return normalizeUtf8ToBuf(msg)\n        default: return normalizeUtf16ToBuf(msg)\n    }\n}\n\nexport function importRsaKey (\n    key:Uint8Array|ArrayBuffer,\n    keyUsages:KeyUsage[]\n):Promise<CryptoKey> {\n    return webcrypto.subtle.importKey(\n        'spki',\n        key,\n        { name: RSA_ALGORITHM, hash: RSA_HASHING_ALGORITHM },\n        false,\n        keyUsages\n    )\n}\n\nexport function isCryptoKey (val:unknown):val is CryptoKey {\n    return (\n        hasProp(val, 'algorithm') &&\n        hasProp(val, 'extractable') &&\n        hasProp(val, 'type')\n    )\n}\n\nfunction hasProp<K extends PropertyKey> (\n    data:unknown,\n    prop:K\n): data is Record<K, unknown> {\n    return (typeof data === 'object' && data != null && prop in data)\n}\n\nexport async function getPublicKeyAsArrayBuffer (\n    keypair:CryptoKeyPair|CryptoKey\n):Promise<ArrayBuffer> {\n    const spki = (keypair instanceof CryptoKey ?\n        await webcrypto.subtle.exportKey(\n            'spki',\n            keypair\n        ) :\n        await webcrypto.subtle.exportKey(\n            'spki',\n            keypair.publicKey\n        )\n    )\n\n    return spki\n}\n\nexport async function getPublicKeyAsUint8Array (\n    keypair:CryptoKeyPair|CryptoKey\n):Promise<Uint8Array> {\n    const arr = await getPublicKeyAsArrayBuffer(keypair)\n    return new Uint8Array(arr)\n}\n\nexport function didToPublicKey (did:string):({\n    publicKey:Uint8Array,\n    type:'rsa' | 'ed25519' | 'bls12-381'\n}) {\n    if (!did.startsWith(BASE58_DID_PREFIX)) {\n        throw new Error(\n            'Please use a base58-encoded DID formatted `did:key:z...`')\n    }\n\n    const didWithoutPrefix = ('' + did.substring(BASE58_DID_PREFIX.length))\n    const magicalBuf = fromString(didWithoutPrefix, 'base58btc')\n    const { keyBuffer, type } = parseMagicBytes(magicalBuf)\n\n    return {\n        publicKey: new Uint8Array(keyBuffer),\n        type\n    }\n}\n\n/**\n * Parse magic bytes on prefixed key-buffer\n * to determine cryptosystem & the unprefixed key-buffer.\n */\nfunction parseMagicBytes (prefixedKey:ArrayBuffer) {\n    // RSA\n    if (hasPrefix(prefixedKey, RSA_DID_PREFIX)) {\n        return {\n            keyBuffer: prefixedKey.slice(RSA_DID_PREFIX.byteLength),\n            type: KEY_TYPE.RSA\n        }\n    // EDWARDS\n    } else if (hasPrefix(prefixedKey, EDWARDS_DID_PREFIX)) {\n        return {\n            keyBuffer: prefixedKey.slice(EDWARDS_DID_PREFIX.byteLength),\n            type: KEY_TYPE.Edwards\n        }\n    // BLS\n    } else if (hasPrefix(prefixedKey, BLS_DID_PREFIX)) {\n        return {\n            keyBuffer: prefixedKey.slice(BLS_DID_PREFIX.byteLength),\n            type: KEY_TYPE.BLS\n        }\n    }\n\n    throw new Error('Unsupported key algorithm. Try using RSA.')\n}\n\nconst arrBufs = {\n    equal: (aBuf:ArrayBuffer, bBuf:ArrayBuffer) => {\n        const a = new Uint8Array(aBuf)\n        const b = new Uint8Array(bBuf)\n        if (a.length !== b.length) return false\n        for (let i = 0; i < a.length; i++) {\n            if (a[i] !== b[i]) return false\n        }\n        return true\n    }\n}\n\nfunction hasPrefix (prefixedKey:ArrayBuffer, prefix:ArrayBuffer) {\n    return arrBufs.equal(prefix, prefixedKey.slice(0, prefix.byteLength))\n}\n\nexport function toBase64 (arr:Uint8Array|ArrayBuffer) {\n    return uToString(\n        arr instanceof ArrayBuffer ?\n            new Uint8Array(arr) :\n            arr,\n        'base64pad'\n    )\n}\n\nexport function fromBase64 (str:string) {\n    return fromString(str, 'base64pad')\n}\n\nexport async function importKey (\n    key:string|Uint8Array,\n    opts?:Partial<SymmKeyOpts>\n):Promise<SymmKey> {\n    const buf = typeof key === 'string' ? base64ToArrBuf(key) : key\n\n    return webcrypto.subtle.importKey(\n        'raw',\n        buf,\n        {\n            name: opts?.alg || DEFAULT_SYMM_ALGORITHM,\n            length: opts?.length || DEFAULT_SYMM_LENGTH,\n        },\n        true,\n        ['encrypt', 'decrypt']\n    )\n}\n\nexport function randomBuf (\n    length:number,\n    { max }:{ max:number } = { max: 255 }\n):ArrayBuffer {\n    if (max < 1 || max > 255) {\n        throw InvalidMaxValue\n    }\n\n    const arr = new Uint8Array(length)\n\n    if (max === 255) {\n        webcrypto.getRandomValues(arr)\n        return arr.buffer\n    }\n\n    let index = 0\n    const interval = max + 1\n    const divisibleMax = Math.floor(256 / interval) * interval\n    const tmp = new Uint8Array(1)\n\n    while (index < arr.length) {\n        webcrypto.getRandomValues(tmp)\n        if (tmp[0] < divisibleMax) {\n            arr[index] = tmp[0] % interval\n            index++\n        }\n    }\n\n    return arr.buffer\n}\n\nexport function joinBufs (fst:ArrayBuffer, snd:ArrayBuffer):ArrayBuffer {\n    const view1 = new Uint8Array(fst)\n    const view2 = new Uint8Array(snd)\n    const joined = new Uint8Array(view1.length + view2.length)\n    joined.set(view1)\n    joined.set(view2, view1.length)\n    return joined.buffer\n}\n"],
  "mappings": "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",
  "names": ["util_exports", "__export", "InvalidKeyUse", "InvalidMaxValue", "base64ToArrBuf", "checkValidKeyUse", "createDeviceName", "did", "didToPublicKey", "fromBase64", "getPublicKeyAsArrayBuffer", "getPublicKeyAsUint8Array", "importKey", "importPublicKey", "importRsaKey", "isCryptoKey", "joinBufs", "normalizeBase64ToBuf", "normalizeToBuf", "normalizeUnicodeToBuf", "normalizeUtf16ToBuf", "normalizeUtf8ToBuf", "publicKeyToDid", "randomBuf", "rsaOperations", "rsaVerify", "sha256", "strToArrBuf", "toBase64", "__toCommonJS", "import_one_webcrypto", "import_uint8arrays", "import_types", "import_constants", "did", "__name", "rsaVerify", "createDeviceName", "normalizedDid", "hashedUsername", "sha256", "uToString", "bytes", "publicKeyToDid", "_publicKey", "keyType", "publicKey", "getPublicKeyAsArrayBuffer", "prefix", "prefixedBuf", "rsaOperations", "msg", "sig", "charSize", "hashAlg", "importPublicKey", "normalizeBase64ToBuf", "normalizeUnicodeToBuf", "privateKey", "pubKey", "_data", "key", "isCryptoKey", "importRsaKey", "data", "arrayBuffer", "message", "signature", "base64Key", "use", "checkValidKeyUse", "alg", "uses", "buf", "base64ToArrBuf", "stripKeyHeader", "InvalidKeyUse", "InvalidMaxValue", "checkValid", "toCheck", "opts", "error", "opt", "string", "normalizeToBuf", "strConv", "normalizeUtf8ToBuf", "str", "strToArrBuf", "view", "i", "strLen", "normalizeUtf16ToBuf", "keyUsages", "val", "hasProp", "prop", "keypair", "getPublicKeyAsUint8Array", "arr", "didToPublicKey", "didWithoutPrefix", "magicalBuf", "keyBuffer", "type", "parseMagicBytes", "prefixedKey", "hasPrefix", "arrBufs", "aBuf", "bBuf", "a", "b", "toBase64", "fromBase64", "importKey", "randomBuf", "length", "max", "index", "interval", "divisibleMax", "tmp", "joinBufs", "fst", "snd", "view1", "view2", "joined"]
}