@enbox/crypto 0.0.1

package/dist/types/primitives/x25519.d.ts

@@ -0,0 +1,283 @@
+import type { Jwk } from '../jose/jwk.js';
+import type { ComputePublicKeyParams, GetPublicKeyParams } from '../types/params-direct.js';
+/**
+ * The `X25519` class provides a comprehensive suite of utilities for working with the X25519
+ * elliptic curve, widely used for key agreement protocols and cryptographic applications. It
+ * provides methods for key generation, conversion, and Elliptic Curve Diffie-Hellman (ECDH)
+ * key agreement,  all aligned with standard cryptographic practices.
+ *
+ * The class supports conversions between raw byte formats and JSON Web Key (JWK) formats,
+ * making it versatile for various cryptographic tasks. It adheres to RFC6090 for ECDH, ensuring
+ * secure and effective handling of keys and cryptographic operations.
+ *
+ * Key Features:
+ * - Key Generation: Generate X25519 private keys in JWK format.
+ * - Key Conversion: Transform keys between raw byte arrays and JWK formats.
+ * - Public Key Derivation: Derive public keys from private keys.
+ * - ECDH Shared Secret Computation: Securely derive shared secrets using private and public keys.
+ *
+ * The methods in this class are asynchronous, returning Promises to accommodate various
+ * JavaScript environments.
+ *
+ * @example
+ * ```ts
+ * // Key Generation
+ * const privateKey = await X25519.generateKey();
+ *
+ * // Public Key Derivation
+ * const publicKey = await X25519.computePublicKey({ key: privateKey });
+ * console.log(publicKey === await X25519.getPublicKey({ key: privateKey })); // Output: true
+ *
+ * // ECDH Shared Secret Computation
+ * const sharedSecret = await X25519.sharedSecret({
+ *   privateKeyA: privateKey,
+ *   publicKeyB: anotherPublicKey
+ * });
+ *
+ * // Key Conversion
+ * const publicKeyBytes = await X25519.publicKeyToBytes({ publicKey });
+ * const privateKeyBytes = await X25519.privateKeyToBytes({ privateKey });
+ * ```
+ */
+export declare class X25519 {
+    /**
+     * Converts a raw private key in bytes to its corresponding JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method accepts a private key as a byte array (Uint8Array) for the X25519 elliptic curve
+     * and transforms it into a JWK object. The process involves first deriving the public key from
+     * the private key, then encoding both the private and public keys into base64url format.
+     *
+     * The resulting JWK object includes the following properties:
+     * - `kty`: Key Type, set to 'OKP' for Octet Key Pair.
+     * - `crv`: Curve Name, set to 'X25519'.
+     * - `d`: The private key component, base64url-encoded.
+     * - `x`: The derived public key, base64url-encoded.
+     *
+     * This method is useful for converting raw public keys into a standardized
+     * JSON format, facilitating their use in cryptographic operations and making
+     * them easy to share and store.
+     *
+     * @example
+     * ```ts
+     * const privateKeyBytes = new Uint8Array([...]); // Replace with actual private key bytes
+     * const privateKey = await X25519.bytesToPrivateKey({ privateKeyBytes });
+     * ```
+     *
+     * @param params - The parameters for the private key conversion.
+     * @param params.privateKeyBytes - The raw private key as a Uint8Array.
+     *
+     * @returns A Promise that resolves to the private key in JWK format.
+     */
+    static bytesToPrivateKey({ privateKeyBytes }: {
+        privateKeyBytes: Uint8Array;
+    }): Promise<Jwk>;
+    /**
+     * Converts a raw public key in bytes to its corresponding JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method accepts a public key as a byte array (Uint8Array) for the X25519 elliptic curve
+     * and transforms it into a JWK object. The conversion process involves encoding the public
+     * key bytes into base64url format.
+     *
+     * The resulting JWK object includes the following properties:
+     * - `kty`: Key Type, set to 'OKP' for Octet Key Pair.
+     * - `crv`: Curve Name, set to 'X25519'.
+     * - `x`: The public key, base64url-encoded.
+     *
+     * This method is useful for converting raw public keys into a standardized
+     * JSON format, facilitating their use in cryptographic operations and making
+     * them easy to share and store.
+     *
+     * @example
+     * ```ts
+     * const publicKeyBytes = new Uint8Array([...]); // Replace with actual public key bytes
+     * const publicKey = await X25519.bytesToPublicKey({ publicKeyBytes });
+     * ```
+     *
+     * @param params - The parameters for the public key conversion.
+     * @param params.publicKeyBytes - The raw public key as a Uint8Array.
+     *
+     * @returns A Promise that resolves to the public key in JWK format.
+     */
+    static bytesToPublicKey({ publicKeyBytes }: {
+        publicKeyBytes: Uint8Array;
+    }): Promise<Jwk>;
+    /**
+     * Derives the public key in JWK format from a given X25519 private key.
+     *
+     * @remarks
+     * This method takes a private key in JWK format and derives its corresponding public key,
+     * also in JWK format.  The derivation process involves converting the private key to a
+     * raw byte array and then computing the corresponding public key on the Curve25519 curve.
+     * The public key is then encoded into base64url format to construct a JWK representation.
+     *
+     * The process ensures that the derived public key correctly corresponds to the given private key,
+     * adhering to the Curve25519 elliptic curve in Twisted Edwards form standards. This method is
+     * useful in cryptographic operations where a public key is needed for operations like signature
+     * verification, but only the private key is available.
+     *
+     * @example
+     * ```ts
+     * const privateKey = { ... }; // A Jwk object representing an X25519 private key
+     * const publicKey = await X25519.computePublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for the public key derivation.
+     * @param params.key - The private key in JWK format from which to derive the public key.
+     *
+     * @returns A Promise that resolves to the derived public key in JWK format.
+     */
+    static computePublicKey({ key }: ComputePublicKeyParams): Promise<Jwk>;
+    /**
+     * Generates an X25519 private key in JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method creates a new private key suitable for use with the X25519 elliptic curve.
+     * The key generation process involves using cryptographically secure random number generation
+     * to ensure the uniqueness and security of the key. The resulting private key adheres to the
+     * JWK format making it compatible with common cryptographic standards and easy to use in various
+     * cryptographic processes.
+     *
+     * The generated private key in JWK format includes the following components:
+     * - `kty`: Key Type, set to 'OKP' for Octet Key Pair.
+     * - `crv`: Curve Name, set to 'X25519'.
+     * - `d`: The private key component, base64url-encoded.
+     * - `x`: The derived public key, base64url-encoded.
+     *
+     * The key is returned in a format suitable for direct use in key agreement operations.
+     *
+     * @example
+     * ```ts
+     * const privateKey = await X25519.generateKey();
+     * ```
+     *
+     * @returns A Promise that resolves to the generated private key in JWK format.
+     */
+    static generateKey(): Promise<Jwk>;
+    /**
+     * Retrieves the public key properties from a given private key in JWK format.
+     *
+     * @remarks
+     * This method extracts the public key portion from an X25519 private key in JWK format. It does
+     * so by removing the private key property 'd' and making a shallow copy, effectively yielding the
+     * public key. The method sets the 'kid' (key ID) property using the JWK thumbprint if it is not
+     * already defined. This approach is used under the assumption that a private key in JWK format
+     * always contains the corresponding public key properties.
+     *
+     * Note: This method offers a significant performance advantage, being about 500 times faster
+     * than `computePublicKey()`. However, it does not mathematically validate the private key, nor
+     * does it derive the public key from the private key. It simply extracts existing public key
+     * properties from the private key object. This makes it suitable for scenarios where speed is
+     * critical and the private key's integrity is already assured.
+     *
+     * @example
+     * ```ts
+     * const privateKey = { ... }; // A Jwk object representing an X25519 private key
+     * const publicKey = await X25519.getPublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for retrieving the public key properties.
+     * @param params.key - The private key in JWK format.
+     *
+     * @returns A Promise that resolves to the public key in JWK format.
+     */
+    static getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
+    /**
+     * Converts a private key from JSON Web Key (JWK) format to a raw byte array (Uint8Array).
+     *
+     * @remarks
+     * This method accepts a private key in JWK format and extracts its raw byte representation.
+     *
+     * This method accepts a public key in JWK format and converts it into its raw binary
+     * form. The conversion process involves decoding the 'd' parameter of the JWK
+     * from base64url format into a byte array.
+     *
+     * This conversion is essential for operations that require the private key in its raw
+     * binary form, such as certain low-level cryptographic operations or when interfacing
+     * with systems and libraries that expect keys in a byte array format.
+     *
+     * @example
+     * ```ts
+     * const privateKey = { ... }; // An X25519 private key in JWK format
+     * const privateKeyBytes = await X25519.privateKeyToBytes({ privateKey });
+     * ```
+     *
+     * @param params - The parameters for the private key conversion.
+     * @param params.privateKey - The private key in JWK format.
+     *
+     * @returns A Promise that resolves to the private key as a Uint8Array.
+     */
+    static privateKeyToBytes({ privateKey }: {
+        privateKey: Jwk;
+    }): Promise<Uint8Array>;
+    /**
+     * Converts a public key from JSON Web Key (JWK) format to a raw byte array (Uint8Array).
+     *
+     * @remarks
+     * This method accepts a public key in JWK format and converts it into its raw binary form.
+     * The conversion process involves decoding the 'x' parameter of the JWK (which represent the
+     * x coordinate of the elliptic curve point) from base64url format into a byte array.
+     *
+     * This conversion is essential for operations that require the public key in its raw
+     * binary form, such as certain low-level cryptographic operations or when interfacing
+     * with systems and libraries that expect keys in a byte array format.
+     *
+     * @example
+     * ```ts
+     * const publicKey = { ... }; // An X25519 public key in JWK format
+     * const publicKeyBytes = await X25519.publicKeyToBytes({ publicKey });
+     * ```
+     *
+     * @param params - The parameters for the public key conversion.
+     * @param params.publicKey - The public key in JWK format.
+     *
+     * @returns A Promise that resolves to the public key as a Uint8Array.
+     */
+    static publicKeyToBytes({ publicKey }: {
+        publicKey: Jwk;
+    }): Promise<Uint8Array>;
+    /**
+     * Computes an RFC6090-compliant Elliptic Curve Diffie-Hellman (ECDH) shared secret
+     * using secp256k1 private and public keys in JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method facilitates the ECDH key agreement protocol, which is a method of securely
+     * deriving a shared secret between two parties based on their private and public keys.
+     * It takes the private key of one party (privateKeyA) and the public key of another
+     * party (publicKeyB) to compute a shared secret. The shared secret is derived from the
+     * x-coordinate of the elliptic curve point resulting from the multiplication of the
+     * public key with the private key.
+     *
+     * Note: When performing Elliptic Curve Diffie-Hellman (ECDH) key agreement,
+     * the resulting shared secret is a point on the elliptic curve, which
+     * consists of an x-coordinate and a y-coordinate. With a 256-bit curve like
+     * secp256k1, each of these coordinates is 32 bytes (256 bits) long. However,
+     * in the ECDH process, it's standard practice to use only the x-coordinate
+     * of the shared secret point as the resulting shared key. This is because
+     * the y-coordinate does not add to the entropy of the key, and both parties
+     * can independently compute the x-coordinate.  Consquently, this implementation
+     * omits the y-coordinate for simplicity and standard compliance.
+     *
+     * @example
+     * ```ts
+     * const privateKeyA = { ... }; // A Jwk object for party A
+     * const publicKeyB = { ... }; // A PublicKeyJwk object for party B
+     * const sharedSecret = await Secp256k1.sharedSecret({
+     *   privateKeyA,
+     *   publicKeyB
+     * });
+     * ```
+     *
+     * @param params - The parameters for the shared secret computation.
+     * @param params.privateKeyA - The private key in JWK format of one party.
+     * @param params.publicKeyB - The public key in JWK format of the other party.
+     *
+     * @returns A Promise that resolves to the computed shared secret as a Uint8Array.
+     */
+    static sharedSecret({ privateKeyA, publicKeyB }: {
+        privateKeyA: Jwk;
+        publicKeyB: Jwk;
+    }): Promise<Uint8Array>;
+}
+//# sourceMappingURL=x25519.d.ts.map

package/dist/types/primitives/x25519.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x25519.d.ts","sourceRoot":"","sources":["../../../src/primitives/x25519.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAI5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,MAAM;IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;WACiB,iBAAiB,CAAC,EAAE,eAAe,EAAE,EAAE;QACzD,eAAe,EAAE,UAAU,CAAC;KAC7B,GAAG,OAAO,CAAC,GAAG,CAAC;IAkBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACiB,gBAAgB,CAAC,EAAE,cAAc,EAAE,EAAE;QACvD,cAAc,EAAE,UAAU,CAAC;KAC5B,GAAG,OAAO,CAAC,GAAG,CAAC;IAchB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,gBAAgB,CAAC,EAAE,GAAG,EAAE,EAC1C,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAoBf;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC;IAa/C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;WACiB,YAAY,CAAC,EAAE,GAAG,EAAE,EACtC,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAef;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE;QACpD,UAAU,EAAE,GAAG,CAAC;KACjB,GAAG,OAAO,CAAC,UAAU,CAAC;IAYvB;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACiB,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE;QAClD,SAAS,EAAE,GAAG,CAAC;KAChB,GAAG,OAAO,CAAC,UAAU,CAAC;IAYvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;WACiB,YAAY,CAAC,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE;QAC5D,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,GAAG,CAAC;KACjB,GAAG,OAAO,CAAC,UAAU,CAAC;CAexB"}

package/dist/types/primitives/xchacha20-poly1305.d.ts

@@ -0,0 +1,210 @@
+import type { Jwk } from '../jose/jwk.js';
+/**
+ * Constant defining the length of the authentication tag in bytes for XChaCha20-Poly1305.
+ *
+ * @remarks
+ * The `POLY1305_TAG_LENGTH` is set to 16 bytes (128 bits), which is the standard size for the
+ * Poly1305 authentication tag in XChaCha20-Poly1305 encryption. This tag length ensures
+ * a strong level of security for message authentication, verifying the integrity and
+ * authenticity of the data during decryption.
+ */
+export declare const POLY1305_TAG_LENGTH = 16;
+/**
+ * The `XChaCha20Poly1305` class provides a suite of utilities for cryptographic operations
+ * using the XChaCha20-Poly1305 algorithm, a combination of the XChaCha20 stream cipher and the
+ * Poly1305 message authentication code (MAC). This class encompasses methods for key generation,
+ * encryption, decryption, and conversions between raw byte arrays and JSON Web Key (JWK) formats.
+ *
+ * XChaCha20-Poly1305 is renowned for its high security and efficiency, especially in scenarios
+ * involving large data volumes or where data integrity and confidentiality are paramount. The
+ * extended nonce size of XChaCha20 reduces the risks of nonce reuse, while Poly1305 provides
+ * a strong MAC ensuring data integrity.
+ *
+ * Key Features:
+ * - Key Generation: Generate XChaCha20-Poly1305 symmetric keys in JWK format.
+ * - Key Conversion: Transform keys between raw byte arrays and JWK formats.
+ * - Encryption: Encrypt data using XChaCha20-Poly1305, returning both ciphertext and MAC tag.
+ * - Decryption: Decrypt data and verify integrity using the XChaCha20-Poly1305 algorithm.
+ *
+ * The methods in this class are asynchronous, returning Promises to accommodate various
+ * JavaScript environments.
+ *
+ * @example
+ * ```ts
+ * // Key Generation
+ * const privateKey = await XChaCha20Poly1305.generateKey();
+ *
+ * // Encryption
+ * const data = new TextEncoder().encode('Messsage');
+ * const nonce = utils.randomBytes(24); // 24-byte nonce
+ * const additionalData = new TextEncoder().encode('Associated data');
+ * const { ciphertext, tag } = await XChaCha20Poly1305.encrypt({
+ *   data,
+ *   nonce,
+ *   additionalData,
+ *   key: privateKey
+ * });
+ *
+ * // Decryption
+ * const decryptedData = await XChaCha20Poly1305.decrypt({
+ *   data: ciphertext,
+ *   nonce,
+ *   tag,
+ *   additionalData,
+ *   key: privateKey
+ * });
+ *
+ * // Key Conversion
+ * const privateKeyBytes = await XChaCha20Poly1305.privateKeyToBytes({ privateKey });
+ * ```
+ */
+export declare class XChaCha20Poly1305 {
+    /**
+     * Converts a raw private key in bytes to its corresponding JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method takes a symmetric key represented as a byte array (Uint8Array) and converts it into
+     * a JWK object for use with the XChaCha20-Poly1305 algorithm. The process involves encoding the
+     * key into base64url format and setting the appropriate JWK parameters.
+     *
+     * The resulting JWK object includes the following properties:
+     * - `kty`: Key Type, set to 'oct' for Octet Sequence (representing a symmetric key).
+     * - `k`: The symmetric key, base64url-encoded.
+     * - `kid`: Key ID, generated based on the JWK thumbprint.
+     *
+     * @example
+     * ```ts
+     * const privateKeyBytes = new Uint8Array([...]); // Replace with actual symmetric key bytes
+     * const privateKey = await XChaCha20Poly1305.bytesToPrivateKey({ privateKeyBytes });
+     * ```
+     *
+     * @param params - The parameters for the symmetric key conversion.
+     * @param params.privateKeyBytes - The raw symmetric key as a Uint8Array.
+     *
+     * @returns A Promise that resolves to the symmetric key in JWK format.
+     */
+    static bytesToPrivateKey({ privateKeyBytes }: {
+        privateKeyBytes: Uint8Array;
+    }): Promise<Jwk>;
+    /**
+     * Decrypts the provided data using XChaCha20-Poly1305.
+     *
+     * @remarks
+     * This method performs XChaCha20-Poly1305 decryption on the given encrypted data using the
+     * specified key, nonce, and authentication tag. It supports optional additional authenticated
+     * data (AAD) for enhanced security. The nonce must be 24 bytes long, consistent with XChaCha20's
+     * specifications.
+     *
+     * @example
+     * ```ts
+     * const encryptedData = new Uint8Array([...]); // Encrypted data
+     * const nonce = new Uint8Array(24); // 24-byte nonce
+     * const additionalData = new Uint8Array([...]); // Optional AAD
+     * const key = { ... }; // A Jwk object representing the XChaCha20-Poly1305 key
+     * const decryptedData = await XChaCha20Poly1305.decrypt({
+     *   data: encryptedData,
+     *   nonce,
+     *   additionalData,
+     *   key
+     * });
+     * ```
+     *
+     * @param params - The parameters for the decryption operation.
+     * @param params.data - The encrypted data to decrypt including the authentication tag,
+     *                      represented as a Uint8Array.
+     * @param params.key - The key to use for decryption, represented in JWK format.
+     * @param params.nonce - The nonce used during the encryption process.
+     * @param params.additionalData - Optional additional authenticated data.
+     *
+     * @returns A Promise that resolves to the decrypted data as a Uint8Array.
+     */
+    static decrypt({ data, key, nonce, additionalData }: {
+        additionalData?: Uint8Array;
+        data: Uint8Array;
+        key: Jwk;
+        nonce: Uint8Array;
+    }): Promise<Uint8Array>;
+    /**
+     * Encrypts the provided data using XChaCha20-Poly1305.
+     *
+     * @remarks
+     * This method performs XChaCha20-Poly1305 encryption on the given data using the specified key
+     * and nonce. It supports optional additional authenticated data (AAD) for enhanced security. The
+     * nonce must be 24 bytes long, as per XChaCha20's specifications. The method returns the
+     * encrypted data along with an authentication tag as a Uint8Array, ensuring both confidentiality
+     * and integrity of the data.
+     *
+     * @example
+     * ```ts
+     * const data = new TextEncoder().encode('Messsage');
+     * const nonce = utils.randomBytes(24); // 24-byte nonce
+     * const additionalData = new TextEncoder().encode('Associated data'); // Optional AAD
+     * const key = { ... }; // A Jwk object representing an XChaCha20-Poly1305 key
+     * const encryptedData = await XChaCha20Poly1305.encrypt({
+     *   data,
+     *   nonce,
+     *   additionalData,
+     *   key
+     * });
+     * ```
+     *
+     * @param params - The parameters for the encryption operation.
+     * @param params.data - The data to encrypt, represented as a Uint8Array.
+     * @param params.key - The key to use for encryption, represented in JWK format.
+     * @param params.nonce - A 24-byte nonce for the encryption process.
+     * @param params.additionalData - Optional additional authenticated data.
+     *
+     * @returns A Promise that resolves to a byte array containing the encrypted data and the
+     *          authentication tag.
+     */
+    static encrypt({ data, key, nonce, additionalData }: {
+        additionalData?: Uint8Array;
+        data: Uint8Array;
+        key: Jwk;
+        nonce: Uint8Array;
+    }): Promise<Uint8Array>;
+    /**
+     * Generates a symmetric key for XChaCha20-Poly1305 in JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method creates a new symmetric key suitable for use with the XChaCha20-Poly1305 algorithm.
+     * The key is generated using cryptographically secure random number generation to ensure its
+     * uniqueness and security. The XChaCha20-Poly1305 algorithm requires a 256-bit key (32 bytes),
+     * and this method adheres to that specification.
+     *
+     * Key components included in the JWK:
+     * - `kty`: Key Type, set to 'oct' for Octet Sequence.
+     * - `k`: The symmetric key component, base64url-encoded.
+     * - `kid`: Key ID, generated based on the JWK thumbprint.
+     *
+     * @example
+     * ```ts
+     * const privateKey = await XChaCha20Poly1305.generateKey();
+     * ```
+     *
+     * @returns A Promise that resolves to the generated symmetric key in JWK format.
+     */
+    static generateKey(): Promise<Jwk>;
+    /**
+     * Converts a private key from JSON Web Key (JWK) format to a raw byte array (Uint8Array).
+     *
+     * This method takes a symmetric key in JWK format and extracts its raw byte representation.
+     * It decodes the 'k' parameter of the JWK value, which represents the symmetric key in base64url
+     * encoding, into a byte array.
+     *
+     * @example
+     * ```ts
+     * const privateKey = { ... }; // A symmetric key in JWK format
+     * const privateKeyBytes = await XChaCha20Poly1305.privateKeyToBytes({ privateKey });
+     * ```
+     *
+     * @param params - The parameters for the symmetric key conversion.
+     * @param params.privateKey - The symmetric key in JWK format.
+     *
+     * @returns A Promise that resolves to the symmetric key as a Uint8Array.
+     */
+    static privateKeyToBytes({ privateKey }: {
+        privateKey: Jwk;
+    }): Promise<Uint8Array>;
+}
+//# sourceMappingURL=xchacha20-poly1305.d.ts.map

package/dist/types/primitives/xchacha20-poly1305.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xchacha20-poly1305.d.ts","sourceRoot":"","sources":["../../../src/primitives/xchacha20-poly1305.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAI1C;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACiB,iBAAiB,CAAC,EAAE,eAAe,EAAE,EAAE;QACzD,eAAe,EAAE,UAAU,CAAC;KAC7B,GAAG,OAAO,CAAC,GAAG,CAAC;IAahB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACiB,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE;QAChE,cAAc,CAAC,EAAE,UAAU,CAAC;QAC5B,IAAI,EAAE,UAAU,CAAC;QACjB,GAAG,EAAE,GAAG,CAAC;QACT,KAAK,EAAE,UAAU,CAAC;KACnB,GAAG,OAAO,CAAC,UAAU,CAAC;IAUvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACiB,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,cAAc,EAAC,EAAE;QAC/D,cAAc,CAAC,EAAE,UAAU,CAAC;QAC5B,IAAI,EAAE,UAAU,CAAC;QACjB,GAAG,EAAE,GAAG,CAAC;QACT,KAAK,EAAE,UAAU,CAAC;KACnB,GAAG,OAAO,CAAC,UAAU,CAAC;IAUvB;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC;IAkB/C;;;;;;;;;;;;;;;;;OAiBG;WACiB,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE;QACpD,UAAU,EAAE,GAAG,CAAC;KACjB,GAAG,OAAO,CAAC,UAAU,CAAC;CAWxB"}