react-native-quick-crypto 1.0.0-beta.8 → 1.0.0

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/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const constants: {
+    readonly RSA_PKCS1_PADDING: 1;
+    readonly RSA_NO_PADDING: 3;
+    readonly RSA_PKCS1_OAEP_PADDING: 4;
+    readonly RSA_X931_PADDING: 5;
+    readonly RSA_PKCS1_PSS_PADDING: 6;
+    readonly RSA_PSS_SALTLEN_DIGEST: -1;
+    readonly RSA_PSS_SALTLEN_MAX_SIGN: -2;
+    readonly RSA_PSS_SALTLEN_AUTO: -2;
+    readonly POINT_CONVERSION_COMPRESSED: 2;
+    readonly POINT_CONVERSION_UNCOMPRESSED: 4;
+    readonly POINT_CONVERSION_HYBRID: 6;
+    readonly DH_CHECK_P_NOT_PRIME: 1;
+    readonly DH_CHECK_P_NOT_SAFE_PRIME: 2;
+    readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
+    readonly DH_NOT_SUITABLE_GENERATOR: 8;
+    readonly OPENSSL_VERSION_NUMBER: 805306368;
+};
+export declare const defaultCoreCipherList = "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256";
+export declare const defaultCipherList = "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;CA0BZ,CAAC;AAEX,eAAO,MAAM,qBAAqB,+EAC4C,CAAC;AAC/E,eAAO,MAAM,iBAAiB,+EACgD,CAAC"}

package/lib/typescript/ec.d.ts

@@ -0,0 +1,22 @@
+import type { EcKeyPair } from './specs/ecKeyPair.nitro';
+import { CryptoKey, PublicKeyObject, PrivateKeyObject } from './keys';
+import type { CryptoKeyPair, KeyPairOptions, KeyUsage, SubtleAlgorithm, BufferLike, BinaryLike, JWK, ImportFormat, GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';
+import { Buffer } from 'buffer';
+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>;
+export declare function ec_generateKeyPairNode(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): Promise<{
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+}>;
+export declare function ec_generateKeyPairNodeSync(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): {
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+};
+//# 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;AAEzD,OAAO,EACL,SAAS,EAET,eAAe,EACf,gBAAgB,EACjB,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,QAAQ,EACR,eAAe,EACf,UAAU,EACV,UAAU,EACV,GAAG,EACH,YAAY,EAEZ,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAYvB,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,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,CAyKX;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,CAgFxB;AAmGD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,sBAAsB,GAAG,SAAS,EAC3C,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC;IACT,SAAS,EAAE,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;IAC3D,UAAU,EAAE,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;CAC9D,CAAC,CAID;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,sBAAsB,GAAG,SAAS,EAC3C,QAAQ,EAAE,gBAAgB,GACzB;IACD,SAAS,EAAE,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;IAC3D,UAAU,EAAE,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;CAC9D,CAIA"}

package/lib/typescript/ed.d.ts

@@ -1,17 +1,44 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
 import type { EdKeyPair } from './specs/edKeyPair.nitro';
-import type { BinaryLike, CFRGKeyPairType, KeyPairGenConfig } from './utils';
+import type { BinaryLike, CFRGKeyPairType, CryptoKeyPair, DiffieHellmanCallback, DiffieHellmanOptions, GenerateKeyPairCallback, GenerateKeyPairReturn, Hex, KeyPairGenConfig, KeyUsage } 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: CFRGKeyPairType, encoding: KeyPairGenConfig, callback: GenerateKeyPairCallback | undefined): GenerateKeyPairReturn | void;
+export declare function ed_generateKeyPairWebCrypto(type: 'ed25519' | 'ed448', extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
 //# sourceMappingURL=ed.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ed.d.ts","sourceRoot":"","sources":["../../src/ed.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE7E,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;IAOrD,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtC,mBAAmB,IAAI,IAAI;IAW3B,YAAY,IAAI,WAAW;IAI3B,aAAa,IAAI,WAAW;IAItB,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"}
+{"version":3,"file":"ed.d.ts","sourceRoot":"","sources":["../../src/ed.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAQxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,EACrB,GAAG,EACH,gBAAgB,EAChB,QAAQ,EAET,MAAM,SAAS,CAAC;AAUjB,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,eAAe,EACrB,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,uBAAuB,GAAG,SAAS,GAC5C,qBAAqB,GAAG,IAAI,CAgE9B;AAkDD,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,SAAS,GAAG,OAAO,EACzB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,aAAa,CAAC,CAsDxB"}

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,29 +1,63 @@
-/// <reference types="safe-buffer" />
 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: {
+    constants: {
+        readonly RSA_PKCS1_PADDING: 1;
+        readonly RSA_NO_PADDING: 3;
+        readonly RSA_PKCS1_OAEP_PADDING: 4;
+        readonly RSA_X931_PADDING: 5;
+        readonly RSA_PKCS1_PSS_PADDING: 6;
+        readonly RSA_PSS_SALTLEN_DIGEST: -1;
+        readonly RSA_PSS_SALTLEN_MAX_SIGN: -2;
+        readonly RSA_PSS_SALTLEN_AUTO: -2;
+        readonly POINT_CONVERSION_COMPRESSED: 2;
+        readonly POINT_CONVERSION_UNCOMPRESSED: 4;
+        readonly POINT_CONVERSION_HYBRID: 6;
+        readonly DH_CHECK_P_NOT_PRIME: 1;
+        readonly DH_CHECK_P_NOT_SAFE_PRIME: 2;
+        readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
+        readonly DH_NOT_SUITABLE_GENERATOR: 8;
+        readonly OPENSSL_VERSION_NUMBER: 805306368;
+    };
+    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 | undefined, context?: utils.HashContext): utils.HashAlgorithm;
+    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";
+    };
     KeyVariant: typeof utils.KeyVariant;
     validateFunction(f: unknown): boolean;
     isStringOrBuffer(val: unknown): val is string | ArrayBuffer;
@@ -31,13 +65,22 @@ declare const QuickCrypto: {
         allowArray: boolean;
         allowFunction: boolean;
         nullable: boolean;
-    } | null | undefined): value is T;
-    randomFill<T_1 extends utils.ABV>(buffer: T_1, callback: utils.RandomCallback<T_1>): void;
-    randomFill<T_2 extends utils.ABV>(buffer: T_2, offset: number, callback: utils.RandomCallback<T_2>): void;
-    randomFill<T_3 extends utils.ABV>(buffer: T_3, offset: number, size: number, callback: utils.RandomCallback<T_3>): void;
-    randomFillSync<T_4 extends utils.ABV>(buffer: T_4, offset?: number | undefined, size?: number | undefined): T_4;
+    } | 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;
@@ -47,12 +90,53 @@ 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 | undefined) => void): void;
-    pbkdf2Sync(password: utils.BinaryLike, salt: utils.BinaryLike, iterations: number, keylen: number, digest?: utils.HashAlgorithm | undefined): ArrayBuffer;
+    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.CFRGKeyPairType, encoding: utils.KeyPairGenConfig, callback: utils.GenerateKeyPairCallback | undefined): utils.GenerateKeyPairReturn | void;
+    ed_generateKeyPairWebCrypto(type: "ed25519" | "ed448", extractable: boolean, keyUsages: utils.KeyUsage[]): Promise<utils.CryptoKeyPair>;
     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;
+    createPublicKey: typeof keys.createPublicKey;
+    createPrivateKey: typeof keys.createPrivateKey;
     CryptoKey: typeof keys.CryptoKey;
+    generateKey: typeof keys.generateKey;
+    generateKeySync: typeof keys.generateKeySync;
+    generateKeyPair: (type: utils.KeyPairType, options: utils.GenerateKeyPairOptions, callback: utils.GenerateKeyPairCallback) => void;
+    generateKeyPairSync: typeof keys.generateKeyPairSync;
+    AsymmetricKeyObject: typeof keys.AsymmetricKeyObject;
     KeyObject: typeof keys.KeyObject;
+    createSign: typeof keys.createSign;
+    createVerify: typeof keys.createVerify;
+    Sign: typeof keys.Sign;
+    Verify: typeof keys.Verify;
+    publicEncrypt: typeof keys.publicEncrypt;
+    publicDecrypt: typeof keys.publicDecrypt;
+    privateEncrypt: typeof keys.privateEncrypt;
+    privateDecrypt: typeof keys.privateDecrypt;
     parsePublicKeyEncoding: typeof keys.parsePublicKeyEncoding;
     parsePrivateKeyEncoding: typeof keys.parsePrivateKeyEncoding;
     parseKeyEncoding: typeof keys.parseKeyEncoding;
@@ -67,8 +151,16 @@ declare const QuickCrypto: {
  */
 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';
+export { constants } from './constants';
 //# 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,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAE3B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAGnC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,YAMnB,CAAC;AAMF,eAAe,WAAW,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,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;AAInC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;uBAHmB,cAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAkCrC,yCACM,EAAC,YACX;qBAWuC,0BAC7B,EAAE,2BACT;qBAE6d,oCAAiC,EAAC,2BAAwB;;;;;;;;;;;+DAAtN,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CApCvU,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;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}