react-native-quick-crypto 1.0.0-beta.2 → 1.0.0-beta.21

package/lib/typescript/cipher.d.ts

@@ -0,0 +1,60 @@
+import Stream, { type TransformOptions } from 'readable-stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, BinaryLikeNode, Encoding } from './utils';
+import type { CipherCCMOptions, CipherCCMTypes, CipherGCMTypes, CipherGCMOptions, CipherOCBOptions, CipherOCBTypes } from 'crypto';
+export type CipherOptions = CipherCCMOptions | CipherOCBOptions | CipherGCMOptions | TransformOptions;
+export declare function getCiphers(): string[];
+interface CipherArgs {
+    isCipher: boolean;
+    cipherType: string;
+    cipherKey: BinaryLikeNode;
+    iv: BinaryLike;
+    options?: CipherOptions;
+}
+declare class CipherCommon extends Stream.Transform {
+    private native;
+    constructor({ isCipher, cipherType, cipherKey, iv, options }: CipherArgs);
+    update(data: Buffer): Buffer;
+    update(data: BinaryLike, inputEncoding?: Encoding): Buffer;
+    update(data: BinaryLike, inputEncoding: Encoding, outputEncoding: Encoding): string;
+    final(): Buffer;
+    final(outputEncoding: BufferEncoding | 'buffer'): string;
+    _transform(chunk: BinaryLike, encoding: BufferEncoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+    setAutoPadding(autoPadding?: boolean): this;
+    setAAD(buffer: Buffer, options?: {
+        plaintextLength: number;
+    }): this;
+    getAuthTag(): Buffer;
+    setAuthTag(tag: Buffer): this;
+    getSupportedCiphers(): string[];
+}
+declare class Cipheriv extends CipherCommon {
+    constructor(cipherType: string, cipherKey: BinaryLikeNode, iv: BinaryLike, options?: CipherOptions);
+}
+export type Cipher = Cipheriv;
+declare class Decipheriv extends CipherCommon {
+    constructor(cipherType: string, cipherKey: BinaryLikeNode, iv: BinaryLike, options?: CipherOptions);
+}
+export type Decipher = Decipheriv;
+export declare function createDecipheriv(algorithm: CipherCCMTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherCCMOptions): Decipher;
+export declare function createDecipheriv(algorithm: CipherOCBTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherOCBOptions): Decipher;
+export declare function createDecipheriv(algorithm: CipherGCMTypes, key: BinaryLikeNode, iv: BinaryLike, options?: CipherGCMOptions): Decipher;
+export declare function createDecipheriv(algorithm: string, key: BinaryLikeNode, iv: BinaryLike, options?: TransformOptions): Decipher;
+export declare function createCipheriv(algorithm: CipherCCMTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherCCMOptions): Cipher;
+export declare function createCipheriv(algorithm: CipherOCBTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherOCBOptions): Cipher;
+export declare function createCipheriv(algorithm: CipherGCMTypes, key: BinaryLikeNode, iv: BinaryLike, options?: CipherGCMOptions): Cipher;
+export declare function createCipheriv(algorithm: string, key: BinaryLikeNode, iv: BinaryLike, options?: TransformOptions): Cipher;
+/**
+ * xsalsa20 stream encryption with @noble/ciphers compatible API
+ *
+ * @param key - 32 bytes
+ * @param nonce - 24 bytes
+ * @param data - data to encrypt
+ * @param output - unused
+ * @param counter - unused
+ * @returns encrypted data
+ */
+export declare function xsalsa20(key: Uint8Array, nonce: Uint8Array, data: Uint8Array, output?: Uint8Array | undefined, counter?: number): Uint8Array;
+export {};
+//# sourceMappingURL=cipher.d.ts.map

package/lib/typescript/cipher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cipher.d.ts","sourceRoot":"","sources":["../../src/cipher.ts"],"names":[],"mappings":"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"}

package/lib/typescript/ec.d.ts

@@ -0,0 +1,13 @@
+import type { EcKeyPair } from './specs/ecKeyPair.nitro';
+import { CryptoKey } from './keys';
+import type { CryptoKeyPair, KeyPairOptions, KeyUsage, SubtleAlgorithm, BufferLike, BinaryLike, JWK, ImportFormat } from './utils/types';
+export declare class Ec {
+    native: EcKeyPair;
+    constructor(curve: string);
+    generateKeyPair(): Promise<CryptoKeyPair>;
+    generateKeyPairSync(): CryptoKeyPair;
+}
+export declare function ecImportKey(format: ImportFormat, keyData: BufferLike | BinaryLike | JWK, algorithm: SubtleAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): CryptoKey;
+export declare const ecdsaSignVerify: (key: CryptoKey, data: BufferLike, { hash }: SubtleAlgorithm, signature?: BufferLike) => ArrayBuffer | boolean;
+export declare function ec_generateKeyPair(name: string, namedCurve: string, extractable: boolean, keyUsages: KeyUsage[], _options?: KeyPairOptions): Promise<CryptoKeyPair>;
+//# sourceMappingURL=ec.d.ts.map

package/lib/typescript/ec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ec.d.ts","sourceRoot":"","sources":["../../src/ec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EACL,SAAS,EAIV,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,QAAQ,EACR,eAAe,EACf,UAAU,EACV,UAAU,EACV,GAAG,EACH,YAAY,EACb,MAAM,eAAe,CAAC;AAavB,qBAAa,EAAE;IACb,MAAM,EAAE,SAAS,CAAC;gBAEN,KAAK,EAAE,MAAM;IAKnB,eAAe,IAAI,OAAO,CAAC,aAAa,CAAC;IAQ/C,mBAAmB,IAAI,aAAa;CAOrC;AAsDD,wBAAgB,WAAW,CACzB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAAG,UAAU,GAAG,GAAG,EACtC,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,SAAS,CAqEX;AAqGD,eAAO,MAAM,eAAe,GAC1B,KAAK,SAAS,EACd,MAAM,UAAU,EAChB,UAAU,eAAe,EACzB,YAAY,UAAU,KACrB,WAAW,GAAG,OAmDhB,CAAC;AAIF,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,EAErB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,aAAa,CAAC,CAiFxB"}

package/lib/typescript/ed.d.ts

@@ -0,0 +1,43 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { EdKeyPair } from './specs/edKeyPair.nitro';
+import type { BinaryLike, CFRGKeyPairType, DiffieHellmanCallback, DiffieHellmanOptions, GenerateKeyPairCallback, GenerateKeyPairReturn, Hex, KeyPairGenConfig, KeyPairType } from './utils';
+export declare class Ed {
+    type: CFRGKeyPairType;
+    config: KeyPairGenConfig;
+    native: EdKeyPair;
+    constructor(type: CFRGKeyPairType, config: KeyPairGenConfig);
+    /**
+     * Computes the Diffie-Hellman secret based on a privateKey and a publicKey.
+     * Both keys must have the same asymmetricKeyType, which must be one of 'dh'
+     * (for Diffie-Hellman), 'ec', 'x448', or 'x25519' (for ECDH).
+     *
+     * @api nodejs/node
+     *
+     * @param options `{ privateKey, publicKey }`, both of which are `KeyObject`s
+     * @param callback optional `(err, secret) => void`
+     * @returns `Buffer` if no callback, or `void` if callback is provided
+     */
+    diffieHellman(options: DiffieHellmanOptions, callback?: DiffieHellmanCallback): Buffer | void;
+    generateKeyPair(): Promise<void>;
+    generateKeyPairSync(): void;
+    getPublicKey(): ArrayBuffer;
+    getPrivateKey(): ArrayBuffer;
+    /**
+     * Computes the Diffie-Hellman shared secret based on a privateKey and a
+     * publicKey for key exchange
+     *
+     * @api \@paulmillr/noble-curves/ed25519
+     *
+     * @param privateKey
+     * @param publicKey
+     * @returns shared secret key
+     */
+    getSharedSecret(privateKey: Hex, publicKey: Hex): ArrayBuffer;
+    sign(message: BinaryLike, key?: BinaryLike): Promise<ArrayBuffer>;
+    signSync(message: BinaryLike, key?: BinaryLike): ArrayBuffer;
+    verify(signature: BinaryLike, message: BinaryLike, key?: BinaryLike): Promise<boolean>;
+    verifySync(signature: BinaryLike, message: BinaryLike, key?: BinaryLike): boolean;
+}
+export declare function diffieHellman(options: DiffieHellmanOptions, callback?: DiffieHellmanCallback): Buffer | void;
+export declare function ed_generateKeyPair(isAsync: boolean, type: KeyPairType, encoding: KeyPairGenConfig, callback: GenerateKeyPairCallback | undefined): GenerateKeyPairReturn | void;
+//# sourceMappingURL=ed.d.ts.map

package/lib/typescript/ed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed.d.ts","sourceRoot":"","sources":["../../src/ed.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,EACrB,GAAG,EACH,gBAAgB,EAChB,WAAW,EACZ,MAAM,SAAS,CAAC;AAGjB,qBAAa,EAAE;IACb,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,SAAS,CAAC;gBAEN,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB;IAO3D;;;;;;;;;;OAUG;IACH,aAAa,CACX,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,CAAC,EAAE,qBAAqB,GAC/B,MAAM,GAAG,IAAI;IAsCV,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtC,mBAAmB,IAAI,IAAI;IAW3B,YAAY,IAAI,WAAW;IAI3B,aAAa,IAAI,WAAW;IAI5B;;;;;;;;;OASG;IACH,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,WAAW;IAIvD,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;IAMvE,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,WAAW;IAMtD,MAAM,CACV,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE,UAAU,EACnB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO,CAAC,OAAO,CAAC;IAMnB,UAAU,CACR,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE,UAAU,EACnB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO;CAKX;AAGD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,CAAC,EAAE,qBAAqB,GAC/B,MAAM,GAAG,IAAI,CAKf;AAGD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,uBAAuB,GAAG,SAAS,GAC5C,qBAAqB,GAAG,IAAI,CAgC9B"}

package/lib/typescript/expo-plugin/@types.d.ts

@@ -0,0 +1,8 @@
+export type ConfigProps = {
+    /**
+     * Enable libsodium support
+     * @default false
+     */
+    sodiumEnabled?: boolean;
+};
+//# sourceMappingURL=@types.d.ts.map

package/lib/typescript/expo-plugin/@types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"@types.d.ts","sourceRoot":"","sources":["../../../src/expo-plugin/@types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC"}

package/lib/typescript/expo-plugin/withRNQC.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+export declare function createRNQCPlugin(name: string, version: string): ConfigPlugin<ConfigProps>;
+//# sourceMappingURL=withRNQC.d.ts.map

package/lib/typescript/expo-plugin/withRNQC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRNQC.d.ts","sourceRoot":"","sources":["../../../src/expo-plugin/withRNQC.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAkB5C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,6BAE7D"}

package/lib/typescript/expo-plugin/withSodiumAndroid.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+export declare const withSodiumAndroid: ConfigPlugin<ConfigProps>;
+//# sourceMappingURL=withSodiumAndroid.d.ts.map

package/lib/typescript/expo-plugin/withSodiumAndroid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withSodiumAndroid.d.ts","sourceRoot":"","sources":["../../../src/expo-plugin/withSodiumAndroid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAmBvD,CAAC"}

package/lib/typescript/expo-plugin/withSodiumIos.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+export declare const withSodiumIos: ConfigPlugin<ConfigProps>;
+//# sourceMappingURL=withSodiumIos.d.ts.map

package/lib/typescript/expo-plugin/withSodiumIos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withSodiumIos.d.ts","sourceRoot":"","sources":["../../../src/expo-plugin/withSodiumIos.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,WAAW,CAuBnD,CAAC"}

package/lib/typescript/expo-plugin/withXCode.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+/**
+ *  Workaround for some jank XCode releases that break React Native native modules
+ *
+ *  see: https://github.com/mrousavy/nitro/issues/422#issuecomment-2545988256
+ */
+export declare const withXCode: ConfigPlugin<ConfigProps>;
+//# sourceMappingURL=withXCode.d.ts.map

package/lib/typescript/expo-plugin/withXCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withXCode.d.ts","sourceRoot":"","sources":["../../../src/expo-plugin/withXCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAM5C;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,YAAY,CAAC,WAAW,CA0C/C,CAAC"}

package/lib/typescript/hash.d.ts

@@ -0,0 +1,122 @@
+import { Stream } from 'readable-stream';
+import type { TransformOptions } from 'readable-stream';
+import type { BinaryLike, Encoding, BufferLike, SubtleAlgorithm } from './utils';
+export declare function getHashes(): string[];
+interface HashOptions extends TransformOptions {
+    /**
+     * For XOF hash functions such as `shake256`, the
+     * outputLength option can be used to specify the desired output length in bytes.
+     */
+    outputLength?: number | undefined;
+}
+declare class Hash extends Stream.Transform {
+    private algorithm;
+    private options;
+    private native;
+    private validate;
+    /**
+     * @internal use `createHash()` instead
+     */
+    private constructor();
+    /**
+     * Updates the hash content with the given `data`, the encoding of which
+     * is given in `inputEncoding`.
+     * If `encoding` is not provided, and the `data` is a string, an
+     * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+     *
+     * This can be called many times with new data as it is streamed.
+     * @since v1.0.0
+     * @param inputEncoding The `encoding` of the `data` string.
+     */
+    update(data: BinaryLike): Hash;
+    update(data: BinaryLike, inputEncoding: Encoding): Buffer;
+    /**
+     * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
+     * If `encoding` is provided a string will be returned; otherwise
+     * a `Buffer` is returned.
+     *
+     * The `Hash` object can not be used again after `hash.digest()` method has been
+     * called. Multiple calls will cause an error to be thrown.
+     * @since v1.0.0
+     * @param encoding The `encoding` of the return value.
+     */
+    digest(): Buffer;
+    digest(encoding: Encoding): Buffer;
+    /**
+     * Creates a new `Hash` object that contains a deep copy of the internal state
+     * of the current `Hash` object.
+     *
+     * The optional `options` argument controls stream behavior. For XOF hash
+     * functions such as `'shake256'`, the `outputLength` option can be used to
+     * specify the desired output length in bytes.
+     *
+     * An error is thrown when an attempt is made to copy the `Hash` object after
+     * its `hash.digest()` method has been called.
+     *
+     * ```js
+     * // Calculate a rolling hash.
+     * import { createHash } from 'react-native-quick-crypto';
+     *
+     * const hash = createHash('sha256');
+     *
+     * hash.update('one');
+     * console.log(hash.copy().digest('hex'));
+     *
+     * hash.update('two');
+     * console.log(hash.copy().digest('hex'));
+     *
+     * hash.update('three');
+     * console.log(hash.copy().digest('hex'));
+     *
+     * // Etc.
+     * ```
+     * @since v1.0.0
+     * @param options `stream.transform` options
+     */
+    copy(): Hash;
+    copy(options: HashOptions): Hash;
+    /**
+     * Returns the OpenSSL version string
+     * @since v1.0.0
+     */
+    getOpenSSLVersion(): string;
+    _transform(chunk: BinaryLike, encoding: BufferEncoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+}
+/**
+ * Creates and returns a `Hash` object that can be used to generate hash digests
+ * using the given `algorithm`. Optional `options` argument controls stream
+ * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
+ * can be used to specify the desired output length in bytes.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 sum of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hash = crypto.createHash('sha256').update('Test123').digest('hex');
+ * console.log('SHA-256 of "Test123":', hash);
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export declare function createHash(algorithm: string, options?: HashOptions): Hash;
+/**
+ * Asynchronous digest function for WebCrypto SubtleCrypto API
+ * @param algorithm The hash algorithm to use
+ * @param data The data to hash
+ * @returns Promise resolving to the hash digest as ArrayBuffer
+ */
+export declare const asyncDigest: (algorithm: SubtleAlgorithm, data: BufferLike) => Promise<ArrayBuffer>;
+export declare const hashExports: {
+    createHash: typeof createHash;
+    getHashes: typeof getHashes;
+    asyncDigest: (algorithm: SubtleAlgorithm, data: BufferLike) => Promise<ArrayBuffer>;
+};
+export {};
+//# sourceMappingURL=hash.d.ts.map

package/lib/typescript/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,eAAe,EAChB,MAAM,SAAS,CAAC;AAiBjB,wBAAgB,SAAS,aAExB;AAED,UAAU,WAAY,SAAQ,gBAAgB;IAC5C;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAQD,cAAM,IAAK,SAAQ,MAAM,CAAC,SAAS;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAa;IAE3B,OAAO,CAAC,QAAQ;IAehB;;OAEG;IACH,OAAO;IAiBP;;;;;;;;;OASG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC9B,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,GAAG,MAAM;IAUzD;;;;;;;;;OASG;IACH,MAAM,IAAI,MAAM;IAChB,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAWlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,IAAI,IAAI,IAAI;IACZ,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAYhC;;;OAGG;IACH,iBAAiB,IAAI,MAAM;IAK3B,UAAU,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,MAAM,IAAI;IAKtB,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI;CAI5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAMzE;AAID;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,WAAW,eAAe,EAC1B,MAAM,UAAU,KACf,OAAO,CAAC,WAAW,CAkBrB,CAAC;AAgBF,eAAO,MAAM,WAAW;;;6BApCX,eAAe,QACpB,UAAU,KACf,OAAO,CAAC,WAAW,CAAC;CAsCtB,CAAC"}

package/lib/typescript/hmac.d.ts

@@ -0,0 +1,66 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { Stream } from 'readable-stream';
+import type { TransformOptions } from 'readable-stream';
+import type { BinaryLike, Encoding } from './utils/types';
+declare class Hmac extends Stream.Transform {
+    private algorithm;
+    private key;
+    private native;
+    private validate;
+    /**
+     * @internal use `createHmac()` instead
+     */
+    private constructor();
+    /**
+     * Updates the `Hmac` content with the given `data`, the encoding of which is given in `inputEncoding`.
+     * If `encoding` is not provided, and the `data` is a string, an encoding of `'utf8'` is enforced.
+     * If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+     *
+     * This can be called many times with new data as it is streamed.
+     * @since v1.0.0
+     * @param inputEncoding The `encoding` of the `data` string.
+     */
+    update(data: BinaryLike): Hmac;
+    update(data: BinaryLike, inputEncoding: Encoding): Hmac;
+    /**
+     * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
+     * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned;
+     *
+     * The `Hmac` object can not be used again after `hmac.digest()` has been
+     * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
+     * @since v1.0.0
+     * @param encoding The `encoding` of the return value.
+     */
+    digest(): Buffer;
+    digest(encoding: Encoding): string;
+    _transform(chunk: BinaryLike, encoding: BufferEncoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+}
+/**
+ * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
+ * Optional `options` argument controls stream behavior.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 HMAC of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hmac = crypto.createHmac('sha256', 'secret-key');
+ * hmac.update('message to hash');
+ * const digest = hmac.digest('hex');
+ * console.log(digest); // prints HMAC digest in hexadecimal format
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export declare function createHmac(algorithm: string, key: BinaryLike, options?: TransformOptions): Hmac;
+export declare const hmacExports: {
+    createHmac: typeof createHmac;
+};
+export {};
+//# sourceMappingURL=hmac.d.ts.map

package/lib/typescript/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/hmac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAS1D,cAAM,IAAK,SAAQ,MAAM,CAAC,SAAS;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,MAAM,CAAa;IAE3B,OAAO,CAAC,QAAQ;IAOhB;;OAEG;IACH,OAAO;IAYP;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC9B,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,GAAG,IAAI;IAUvD;;;;;;;;OAQG;IACH,MAAM,IAAI,MAAM;IAChB,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAYlC,UAAU,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,MAAM,IAAI;IAKtB,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI;CAI5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,UAAU,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,IAAI,CAON;AAED,eAAO,MAAM,WAAW;;CAEvB,CAAC"}

package/lib/typescript/index.d.ts

@@ -1,20 +1,68 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
+import * as keys from './keys';
+import * as blake3 from './blake3';
+import * as cipher from './cipher';
+import * as ed from './ed';
 import * as random from './random';
+import * as utils from './utils';
+import * as subtle from './subtle';
 /**
  * Loosely matches Node.js {crypto} with some unimplemented functionality.
  * See `docs/implementation-coverage.md` for status.
  */
 declare const QuickCrypto: {
-    utils: {
-        ab2str: typeof import("./utils/conversion").ab2str;
-        abvToArrayBuffer: (buffer: import("./utils/types").ArrayBufferView) => ArrayBufferLike;
+    isCryptoKeyPair(result: keys.CryptoKey | utils.CryptoKeyPair): result is utils.CryptoKeyPair;
+    Subtle: typeof subtle.Subtle;
+    subtle: subtle.Subtle;
+    toArrayBuffer(buf: Buffer | import("safe-buffer").Buffer | ArrayBufferView): ArrayBuffer;
+    bufferLikeToArrayBuffer(buf: utils.BufferLike): ArrayBuffer;
+    binaryLikeToArrayBuffer(input: utils.BinaryLikeNode, encoding?: string): ArrayBuffer;
+    ab2str(buf: ArrayBuffer, encoding?: string): string;
+    abvToArrayBuffer: (buf: utils.ABV) => ArrayBuffer;
+    kEmptyObject: any;
+    ensureBytes(title: string, hex: utils.Hex, expectedLength?: number): Uint8Array;
+    isBytes(a: unknown): a is Uint8Array;
+    hexToBytes(hex: string): Uint8Array;
+    lazyDOMException(message: string, domName: string | {
+        name: string;
+        cause: unknown;
+    }): Error;
+    normalizeHashName(algo: string | utils.HashAlgorithm | {
+        name: string;
+    } | undefined, context?: utils.HashContext): utils.HashAlgorithm;
+    HashContext: typeof utils.HashContext;
+    KFormatType: typeof utils.KFormatType;
+    KeyType: typeof utils.KeyType;
+    KeyEncoding: typeof utils.KeyEncoding;
+    KeyFormat: typeof utils.KeyFormat;
+    kNamedCurveAliases: {
+        readonly 'P-256': "prime256v1";
+        readonly 'P-384': "secp384r1";
+        readonly 'P-521': "secp521r1";
     };
-    randomFill<T extends import("./utils/types").ArrayBufferView>(buffer: T, callback: import("./utils/types").RandomCallback<T>): void;
-    randomFill<T_1 extends import("./utils/types").ArrayBufferView>(buffer: T_1, offset: number, callback: import("./utils/types").RandomCallback<T_1>): void;
-    randomFill<T_2 extends import("./utils/types").ArrayBufferView>(buffer: T_2, offset: number, size: number, callback: import("./utils/types").RandomCallback<T_2>): void;
-    randomFillSync<T_3 extends import("./utils/types").ArrayBufferView>(buffer: T_3, offset?: number | undefined, size?: number | undefined): T_3;
+    KeyVariant: typeof utils.KeyVariant;
+    validateFunction(f: unknown): boolean;
+    isStringOrBuffer(val: unknown): val is string | ArrayBuffer;
+    validateObject<T>(value: unknown, name: string, options?: {
+        allowArray: boolean;
+        allowFunction: boolean;
+        nullable: boolean;
+    } | null): value is T;
+    hasAnyNotIn(set: string[], checks: string[]): boolean;
+    validateMaxBufferLength: (data: utils.BinaryLike | utils.BufferLike, name: string) => void;
+    getUsagesUnion: (usageSet: utils.KeyUsage[], ...usages: utils.KeyUsage[]) => utils.KeyUsage[];
+    validateKeyOps: (keyOps: utils.KeyUsage[] | undefined, usagesSet: utils.KeyUsage[]) => void;
+    setDefaultEncoding(encoding: utils.Encoding): void;
+    getDefaultEncoding(): utils.Encoding;
+    normalizeEncoding(enc: string): "ascii" | "utf8" | "utf16le" | "base64" | "latin1" | "hex" | undefined;
+    validateEncoding(data: string, encoding: string): void;
+    getUIntOption(options: Record<string, any>, key: string): any;
+    randomFill<T extends utils.ABV>(buffer: T, callback: utils.RandomCallback<T>): void;
+    randomFill<T extends utils.ABV>(buffer: T, offset: number, callback: utils.RandomCallback<T>): void;
+    randomFill<T extends utils.ABV>(buffer: T, offset: number, size: number, callback: utils.RandomCallback<T>): void;
+    randomFillSync<T extends utils.ABV>(buffer: T, offset?: number, size?: number): T;
     randomBytes(size: number): Buffer;
-    randomBytes(size: number, callback: (err: Error | null, buf?: Buffer | undefined) => void): void;
+    randomBytes(size: number, callback: (err: Error | null, buf?: Buffer) => void): void;
     randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
     randomInt(max: number): number;
     randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
@@ -24,10 +72,63 @@ declare const QuickCrypto: {
     rng: typeof random.randomBytes;
     pseudoRandomBytes: typeof random.randomBytes;
     prng: typeof random.randomBytes;
+    pbkdf2(password: utils.BinaryLike, salt: utils.BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void): void;
+    pbkdf2Sync(password: utils.BinaryLike, salt: utils.BinaryLike, iterations: number, keylen: number, digest?: utils.HashAlgorithm): Buffer;
+    pbkdf2DeriveBits(algorithm: utils.SubtleAlgorithm, baseKey: keys.CryptoKey, length: number): Promise<ArrayBuffer>;
+    createHmac: typeof import("./hmac").createHmac;
+    createHash: typeof import("./hash").createHash;
+    getHashes: typeof import("./hash").getHashes;
+    asyncDigest: (algorithm: utils.SubtleAlgorithm, data: utils.BufferLike) => Promise<ArrayBuffer>;
+    diffieHellman(options: utils.DiffieHellmanOptions, callback?: utils.DiffieHellmanCallback): Buffer | void;
+    ed_generateKeyPair(isAsync: boolean, type: utils.KeyPairType, encoding: utils.KeyPairGenConfig, callback: utils.GenerateKeyPairCallback | undefined): utils.GenerateKeyPairReturn | void;
+    Ed: typeof ed.Ed;
+    getCiphers(): string[];
+    createDecipheriv(algorithm: import("crypto").CipherCCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherCCMOptions): cipher.Decipher;
+    createDecipheriv(algorithm: import("crypto").CipherOCBTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherOCBOptions): cipher.Decipher;
+    createDecipheriv(algorithm: import("crypto").CipherGCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("crypto").CipherGCMOptions): cipher.Decipher;
+    createDecipheriv(algorithm: string, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("readable-stream").TransformOptions): cipher.Decipher;
+    createCipheriv(algorithm: import("crypto").CipherCCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherCCMOptions): cipher.Cipher;
+    createCipheriv(algorithm: import("crypto").CipherOCBTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherOCBOptions): cipher.Cipher;
+    createCipheriv(algorithm: import("crypto").CipherGCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("crypto").CipherGCMOptions): cipher.Cipher;
+    createCipheriv(algorithm: string, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("readable-stream").TransformOptions): cipher.Cipher;
+    xsalsa20(key: Uint8Array, nonce: Uint8Array, data: Uint8Array, output?: Uint8Array | undefined, counter?: number): Uint8Array;
+    createBlake3(opts?: blake3.Blake3Options): blake3.Blake3;
+    blake3: typeof blake3.blake3;
+    Blake3: typeof blake3.Blake3;
+    blake3Exports: {
+        Blake3: typeof blake3.Blake3;
+        createBlake3: typeof blake3.createBlake3;
+        blake3: typeof blake3.blake3;
+    };
+    createSecretKey: typeof keys.createSecretKey;
+    CryptoKey: typeof keys.CryptoKey;
+    generateKeyPair: (type: utils.KeyPairType, options: utils.GenerateKeyPairOptions, callback: utils.GenerateKeyPairCallback) => void;
+    generateKeyPairSync: typeof keys.generateKeyPairSync;
+    AsymmetricKeyObject: typeof keys.AsymmetricKeyObject;
+    KeyObject: typeof keys.KeyObject;
+    parsePublicKeyEncoding: typeof keys.parsePublicKeyEncoding;
+    parsePrivateKeyEncoding: typeof keys.parsePrivateKeyEncoding;
+    parseKeyEncoding: typeof keys.parseKeyEncoding;
+    SecretKeyObject: typeof keys.SecretKeyObject;
+    PublicKeyObject: typeof keys.PublicKeyObject;
+    PrivateKeyObject: typeof keys.PrivateKeyObject;
+    isCryptoKey: (obj: any) => boolean;
 };
 /**
- * Optional. Patch global.crypto with quickcrypto and global.Buffer with react-native-buffer.
+ * Optional. Patch global.crypto with react-native-quick-crypto and
+ * global.Buffer with react-native-buffer.
  */
 export declare const install: () => void;
 export default QuickCrypto;
+export * from './blake3';
+export * from './cipher';
+export * from './ed';
+export * from './keys';
+export * from './hash';
+export * from './hmac';
+export * from './pbkdf2';
+export * from './random';
+export * from './utils';
+export * from './subtle';
+export { subtle, isCryptoKeyPair } from './subtle';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAGxD,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAKnC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;CA6BhB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,YAMnB,CAAC;AAKF,eAAe,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAGxD,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAI3B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAGnC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;uBAFd,cAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAkCD,yCACU,EAAC,YACT;qBAWS,0BACd,EAAC,2BAAsB;qBAAqiB,oCAAiC,EAAC,2BAAwB;;;;;;;;;;;+DAAtN,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAnCta,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,YAMnB,CAAC;AAMF,eAAe,WAAW,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}

package/lib/typescript/keys/classes.d.ts

@@ -0,0 +1,79 @@
+import { Buffer } from 'buffer';
+import type { AsymmetricKeyType, EncodingOptions, KeyDetail, KeyObjectHandle, KeyUsage, SubtleAlgorithm } from '../utils';
+export declare class CryptoKey {
+    keyObject: KeyObject;
+    keyAlgorithm: SubtleAlgorithm;
+    keyUsages: KeyUsage[];
+    keyExtractable: boolean;
+    constructor(keyObject: KeyObject, keyAlgorithm: SubtleAlgorithm, keyUsages: KeyUsage[], keyExtractable: boolean);
+    inspect(_depth: number, _options: unknown): unknown;
+    get type(): "public" | "secret" | "private";
+    get extractable(): boolean;
+    get algorithm(): SubtleAlgorithm;
+    get usages(): KeyUsage[];
+}
+export declare class KeyObject {
+    handle: KeyObjectHandle;
+    type: 'public' | 'secret' | 'private';
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): string | Buffer;
+    export(options?: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options?: {
+        format: 'jwk';
+    } & EncodingOptions): never;
+    export(options?: EncodingOptions): string | Buffer;
+    constructor(type: string, handle: KeyObjectHandle);
+    constructor(type: string, key: ArrayBuffer);
+    static createKeyObject(type: string, key: ArrayBuffer, format?: 'der' | 'pem', encoding?: 'pkcs8' | 'spki' | 'sec1'): KeyObject;
+    getAsymmetricKeyType(): undefined;
+    getAsymmetricKeyDetails(): undefined;
+}
+export declare class SecretKeyObject extends KeyObject {
+    constructor(handle: KeyObjectHandle);
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): never;
+    export(options: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'jwk';
+    } & EncodingOptions): never;
+    export(options?: EncodingOptions): Buffer;
+}
+export declare class AsymmetricKeyObject extends KeyObject {
+    constructor(type: string, handle: KeyObjectHandle);
+    private _asymmetricKeyType?;
+    get asymmetricKeyType(): AsymmetricKeyType;
+    private _asymmetricKeyDetails?;
+    get asymmetricKeyDetails(): KeyDetail;
+    get namedCurve(): string | undefined;
+}
+export declare class PublicKeyObject extends AsymmetricKeyObject {
+    constructor(handle: KeyObjectHandle);
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): string;
+    export(options: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'jwk';
+    } & EncodingOptions): never;
+}
+export declare class PrivateKeyObject extends AsymmetricKeyObject {
+    constructor(handle: KeyObjectHandle);
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): string;
+    export(options: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'jwk';
+    } & EncodingOptions): never;
+}
+//# sourceMappingURL=classes.d.ts.map

package/lib/typescript/keys/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../../src/keys/classes.ts"],"names":[],"mappings":"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"}

package/lib/typescript/keys/generateKeyPair.d.ts

@@ -0,0 +1,6 @@
+import { type CryptoKeyPair, type GenerateKeyPairCallback, type GenerateKeyPairOptions, type GenerateKeyPairPromiseReturn, type KeyPairType } from '../utils';
+export declare const generateKeyPair: (type: KeyPairType, options: GenerateKeyPairOptions, callback: GenerateKeyPairCallback) => void;
+export declare const generateKeyPairPromise: (type: KeyPairType, options: GenerateKeyPairOptions) => Promise<GenerateKeyPairPromiseReturn>;
+export declare function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
+export declare function generateKeyPairSync(type: KeyPairType, options: GenerateKeyPairOptions): CryptoKeyPair;
+//# sourceMappingURL=generateKeyPair.d.ts.map