cipher-kit 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/validate-Cb7IOrPo.d.ts

@@ -0,0 +1,373 @@
+import nodeCrypto, { webcrypto } from 'node:crypto';
+
+/**
+ * Standardized error object for the `Result` type.
+ * Always has a brief `message` and a more detailed `description`.
+ */
+interface ResultErr {
+    readonly message: string;
+    readonly description: string;
+}
+/**
+ * Discriminated union for functions that can succeed or fail.
+ *
+ * - On **success**:
+ *   - If `T` is an object - properties of `T` are **spread** into the result
+ *     along with `success: true`.
+ *   - Otherwise - `{ success: true, result: T }`.
+ * - On **failure**: `{ success: false, error: E }`.
+ *
+ * @example
+ * ```ts
+ * // Primitive result
+ * function getNum(): Result<number> { return $ok(42); }
+ * const r1 = getNum();
+ * if (r1.success) console.log(r1.result); // 42
+ *
+ * // Object result (spread)
+ * function getPair(): Result<{ a: number; b: string }> {
+ *   return $ok({ a: 1, b: 'x' });
+ * }
+ * const r2 = getPair();
+ * if (r2.success) console.log(r2.a, r2.b); // 1 'x'
+ * ```
+ */
+type Result<T, E = ResultErr> = T extends object ? ({
+    readonly [K in keyof T]: T[K];
+} & {
+    readonly success: true;
+    readonly error?: undefined;
+}) | ({
+    readonly [K in keyof T]?: undefined;
+} & {
+    readonly success: false;
+    readonly error: E;
+}) : {
+    readonly success: true;
+    readonly result: T;
+    readonly error?: undefined;
+} | {
+    readonly success: false;
+    readonly error: E;
+    readonly result?: undefined;
+};
+
+declare const ENCODING: readonly ["base64", "base64url", "hex", "utf8", "latin1"];
+declare const CIPHER_ENCODING: readonly ["base64", "base64url", "hex"];
+declare const DIGEST_ALGORITHMS: Readonly<{
+    readonly sha256: {
+        readonly node: "sha256";
+        readonly web: "SHA-256";
+    };
+    readonly sha384: {
+        readonly node: "sha384";
+        readonly web: "SHA-384";
+    };
+    readonly sha512: {
+        readonly node: "sha512";
+        readonly web: "SHA-512";
+    };
+}>;
+declare const ENCRYPTION_ALGORITHMS: Readonly<{
+    readonly aes256gcm: {
+        readonly keyBytes: 32;
+        readonly ivLength: 12;
+        readonly node: "aes-256-gcm";
+        readonly web: "AES-GCM";
+    };
+    readonly aes192gcm: {
+        readonly keyBytes: 24;
+        readonly ivLength: 12;
+        readonly node: "aes-192-gcm";
+        readonly web: "AES-GCM";
+    };
+    readonly aes128gcm: {
+        readonly keyBytes: 16;
+        readonly ivLength: 12;
+        readonly node: "aes-128-gcm";
+        readonly web: "AES-GCM";
+    };
+}>;
+
+declare const __brand: unique symbol;
+type Brand<T> = {
+    readonly [__brand]: T;
+};
+/**
+ * A platform-specific secret key for encryption/decryption.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You have a treasure (your secret data) and want to keep it safe.
+ * For that you create a key (the secret key) and lock your treasure with it.
+ *
+ * @template Platform - 'web' or 'node' to specify the platform of the secret key.
+ */
+type SecretKey<Platform extends 'web' | 'node'> = {
+    readonly platform: Platform;
+    readonly digest: keyof typeof DIGEST_ALGORITHMS;
+    readonly algorithm: keyof typeof ENCRYPTION_ALGORITHMS;
+    readonly key: Platform extends 'web' ? webcrypto.CryptoKey : nodeCrypto.KeyObject;
+} & Brand<`secretKey-${Platform}`>;
+/** Supported **cipher text** encodings for encrypted/hash outputs. */
+type CipherEncoding = (typeof CIPHER_ENCODING)[number];
+/** Supported data encodings for **plain text/bytes** conversions. */
+type Encoding = (typeof ENCODING)[number];
+/** Supported symmetric encryption algorithms */
+type EncryptionAlgorithm = keyof typeof ENCRYPTION_ALGORITHMS;
+/** Supported digest algorithms for hashing */
+type DigestAlgorithm = keyof typeof DIGEST_ALGORITHMS;
+/**
+ * Options for creating a `SecretKey`
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You want to create a special key to lock your treasure box.
+ * You can choose how strong the lock is (algorithm), how to make the key (digest),
+ * and add some extra secret stuff (salt and info) to make your key unique.
+ *
+ * - `algorithm` (default: `'aes256gcm'`)
+ * - `digest` (HKDF hash; default: `'sha256'`)
+ * - `salt` (default: `'cipher-kit-salt'`, must be ≥ 8 chars)
+ * - `info` (default: `'cipher-kit'`)
+ */
+interface CreateSecretKeyOptions {
+    algorithm?: EncryptionAlgorithm;
+    digest?: DigestAlgorithm;
+    salt?: string;
+    info?: string;
+}
+/**
+ * Options for encryption.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * After locking your message, how should we write the locked message down?
+ *
+ * - `encoding`: output ciphertext encoding (`'base64' | 'base64url' | 'hex'`) (default: `'base64url'`)
+ */
+interface EncryptOptions {
+    /** Encoding format for the output ciphertext (default: `'base64url'`). */
+    encoding?: CipherEncoding;
+}
+/**
+ * Options for decryption.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * To unlock the message, we must know how it was written down.
+ *
+ * - `encoding`: input ciphertext encoding (`'base64' | 'base64url' | 'hex'`) (default: `'base64url'`)
+ */
+interface DecryptOptions {
+    /** Encoding format for the input ciphertext (default: `'base64url'`). */
+    encoding?: CipherEncoding;
+}
+/**
+ * Options for hashing arbitrary data.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You want to create a unique fingerprint (hash) of your data.
+ * You can choose how to create the fingerprint (digest) and how to write it down (encoding).
+ *
+ * - `digest`: `'sha256' | 'sha384' | 'sha512'` (default: `'sha256'`)
+ * - `encoding`: output ciphertext encoding for the hash (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`)
+ */
+interface HashOptions {
+    /** Digest algorithm to use (default: `'sha256'`). */
+    digest?: DigestAlgorithm;
+    /** Encoding format for the output hash (default: `'base64url'`). */
+    encoding?: CipherEncoding;
+}
+/**
+ * Options for password hashing (PBKDF2).
+ *
+ * ### 🍼 Explain Like I'm Five
+ * We turn your password into a strong secret by mixing it with salt,
+ * stirring many times (iterations), and making a long result (keyLength).
+ *
+ * - `digest`: `'sha256' | 'sha384' | 'sha512'` (default: `'sha512'`)
+ * - `encoding`: output ciphertext encoding for the hash (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`)
+ * - `saltLength`: size of the random salt in bytes (default: `16` bytes)
+ * - `iterations`: number of iterations (default: `320000`)
+ * - `keyLength`: length of the derived key in bytes (default: `64` bytes)
+ */
+interface HashPasswordOptions {
+    /** Digest algorithm to use (default: `'sha512'`). */
+    digest?: DigestAlgorithm;
+    /** Encoding format for the output hash (default: `'base64url'`). */
+    encoding?: CipherEncoding;
+    /** Length of the salt in bytes (default: `16` bytes, min: `8` bytes). */
+    saltLength?: number;
+    /** Number of iterations for key derivation (default: `320000`, min: `1000`). */
+    iterations?: number;
+    /** Length of the derived key in bytes (default: `64` bytes, min: `16` bytes). */
+    keyLength?: number;
+}
+/**
+ * Options for verifying a password hash (PBKDF2) (must match the parameters used to hash).
+ *
+ * ### 🍼 Explain Like I'm Five
+ * To check a password, we must use the same recipe—same mixer, same number of stirs,
+ * same size—so the new result matches the old one.
+ *
+ * - `digest`: `'sha256' | 'sha384' | 'sha512'` (default: `'sha512'`)
+ * - `encoding`: input ciphertext encoding for the hash (`'base64' | 'base64url' | 'hex'`; default: `'base64url'`)
+ * - `iterations`: number of iterations (default: `320000`)
+ * - `keyLength`: length of the derived key in bytes (default: `64` bytes)
+ */
+interface VerifyPasswordOptions {
+    /** Digest algorithm to use (default: `'sha512'`). */
+    digest?: DigestAlgorithm;
+    /** Encoding format of the input hash (default: `'base64url'`). */
+    encoding?: CipherEncoding;
+    /** Number of iterations for key derivation (default: `320000`). */
+    iterations?: number;
+    /** Length of the derived key in bytes (default: `64` bytes). */
+    keyLength?: number;
+}
+
+/**
+ * Safely serializes a plain object to JSON without throwing.
+ *
+ * Wraps `JSON.stringify` and returns a `Result` containing the JSON string or an error.
+ * Only plain objects (POJOs) are accepted. Class instances, Maps, Sets, etc. are rejected.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You have a box of toys (your object) and take a photo of it (a JSON string)
+ * so you can send it to a friend.
+ *
+ * @template T - Plain object type to serialize.
+ * @param obj - The object to stringify (must be a plain object).
+ * @returns A `Result` with the JSON string on success, or an error.
+ *
+ * @example
+ * ```ts
+ * const res = tryStringifyObj({ a: 1 });
+ * if (res.success) {
+ *   console.log(res.result); // {"a":1}
+ * } else {
+ *   console.error(res.error.message, res.error.description);
+ * }
+ * ```
+ */
+declare function tryStringifyObj<T extends object = Record<string, unknown>>(obj: T): Result<string>;
+/**
+ * Serializes a plain object to JSON (throwing).
+ *
+ * Wraps `JSON.stringify` and returns the result or throws an error.
+ * Only plain objects (POJOs) are accepted. Class instances, Maps, Sets, etc. are rejected.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You have a box of toys (your object) and take a photo of it (a JSON string)
+ * so you can send it to a friend.
+ *
+ * @template T - Plain object type to serialize.
+ * @param obj - The object to stringify (must be a plain object).
+ * @returns JSON string representation of the object.
+ * @throws {Error} If `obj` is not a plain object or serialization fails.
+ *
+ * @example
+ * ```ts
+ * try {
+ * const json = stringifyObj({ a: 1 }); // {"a":1}
+ * } catch (error: unknown) {
+ *   console.error(error);
+ * }
+ * ```
+ */
+declare function stringifyObj<T extends object = Record<string, unknown>>(obj: T): string;
+/**
+ * Safely parses a JSON string to a plain object (non-throwing).
+ *
+ * Wraps `JSON.parse` and returns a `Result` containing the parsed object, or an error.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You rebuild your toy box (an object) from a photo you took (a JSON string).
+ *
+ * @template T - The expected object type.
+ * @param str - The JSON string to parse.
+ * @returns A `Result` with the parsed object on success, or an error.
+ *
+ * @example
+ * ```ts
+ * const res = tryParseToObj<{ a: number }>('{"a":1}');
+ * if (res.success) {
+ *   console.log(res.result.a); // 1
+ * } else {
+ *   console.error(res.error.message, res.error.description);
+ * }
+ * ```
+ */
+declare function tryParseToObj<T extends object = Record<string, unknown>>(str: string): Result<{
+    result: T;
+}>;
+/**
+ * Parses a JSON string to a plain object (throwing).
+ *
+ * Wraps `JSON.parse` and returns the parsed object, or throws on failure.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You rebuild your toy box (an object) from a photo you took (a JSON string).
+ *
+ * @template T - The expected object type.
+ * @param str - The JSON string to parse.
+ * @returns The parsed plain object.
+ * @throws {Error} If the string can’t be parsed or doesn’t represent a plain object.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const obj = parseToObj<{ a: number }>('{"a":1}'); // obj.a === 1
+ * } catch (error: unknown) {
+ *   console.error(error);
+ * }
+ * ```
+ */
+declare function parseToObj<T extends object = Record<string, unknown>>(str: string): T;
+
+/**
+ * Regular expressions for encrypted data patterns.
+ *
+ * - **node**: `"iv.cipher.tag."` (three dot-separated parts plus a trailing dot)
+ * - **web**: `"iv.cipherWithTag."` (two parts plus a trailing dot)
+ * - **general**: accepts both shapes (2 or 3 parts) with a trailing dot
+ *
+ * Each part is any non-empty string without dots.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You have a secret code you want to check. Before you check it,
+ * you make sure it looks how a secret code should look.
+ */
+declare const ENCRYPTED_REGEX: Readonly<{
+    node: RegExp;
+    web: RegExp;
+    general: RegExp;
+}>;
+/**
+ * Checks if a string matches an expected encrypted payload shape.
+ *
+ * - **node**: `"iv.cipher.tag."` (three dot-separated parts plus a trailing dot)
+ * - **web**: `"iv.cipherWithTag."` (two parts plus a trailing dot)
+ * - **general**: accepts both shapes (2 or 3 parts) with a trailing dot
+ *
+ * Each part is any non-empty string without dots.
+ *
+ * This validates only the **shape**, not whether content is valid base64/hex, etc.
+ *
+ * ### 🍼 Explain Like I'm Five
+ * You have a secret code you want to check. Before you check it,
+ * you make sure it looks how a secret code should look.
+ *
+ * @param data - The string to test.
+ * @param format - Which layout to check: `'node'`, `'web'`, or `'general'`.
+ * @returns `true` if the string matches the pattern; otherwise `false`.
+ * @throws {Error} If an unknown `format` is provided.
+ *
+ * @example
+ * ```ts
+ * matchPattern("abc.def.ghi.", "node");    // true
+ * matchPattern("abc.def.", "web");         // true
+ * matchPattern("abc.def.", "node");        // false
+ * matchPattern("abc.def.ghi.", "general"); // true
+ * ```
+ */
+declare function matchPattern(data: string, format: 'general' | 'node' | 'web'): boolean;
+
+export { type CipherEncoding as C, type DigestAlgorithm as D, ENCRYPTED_REGEX as E, type HashOptions as H, type Result as R, type SecretKey as S, type VerifyPasswordOptions as V, tryStringifyObj as a, type Encoding as b, type EncryptionAlgorithm as c, type CreateSecretKeyOptions as d, type EncryptOptions as e, type DecryptOptions as f, type HashPasswordOptions as g, matchPattern as m, parseToObj as p, stringifyObj as s, tryParseToObj as t };

package/dist/web-api.cjs

@@ -1,129 +1,129 @@
 'use strict';
 
-var chunkWIZT7AYM_cjs = require('./chunk-WIZT7AYM.cjs');
-var chunkRXXVBCWL_cjs = require('./chunk-RXXVBCWL.cjs');
+var chunkXIWV7XVI_cjs = require('./chunk-XIWV7XVI.cjs');
+var chunkUIV6DG54_cjs = require('./chunk-UIV6DG54.cjs');
 
 
 
 Object.defineProperty(exports, "convertBytesToStr", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.convertBytesToStr; }
+  get: function () { return chunkXIWV7XVI_cjs.convertBytesToStr; }
 });
 Object.defineProperty(exports, "convertEncoding", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.convertEncoding; }
+  get: function () { return chunkXIWV7XVI_cjs.convertEncoding; }
 });
 Object.defineProperty(exports, "convertStrToBytes", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.convertStrToBytes; }
+  get: function () { return chunkXIWV7XVI_cjs.convertStrToBytes; }
 });
 Object.defineProperty(exports, "createSecretKey", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.createSecretKey; }
+  get: function () { return chunkXIWV7XVI_cjs.createSecretKey; }
 });
 Object.defineProperty(exports, "decrypt", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.decrypt; }
+  get: function () { return chunkXIWV7XVI_cjs.decrypt; }
 });
 Object.defineProperty(exports, "decryptObj", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.decryptObj; }
+  get: function () { return chunkXIWV7XVI_cjs.decryptObj; }
 });
 Object.defineProperty(exports, "encrypt", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.encrypt; }
+  get: function () { return chunkXIWV7XVI_cjs.encrypt; }
 });
 Object.defineProperty(exports, "encryptObj", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.encryptObj; }
+  get: function () { return chunkXIWV7XVI_cjs.encryptObj; }
 });
 Object.defineProperty(exports, "generateUuid", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.generateUuid; }
+  get: function () { return chunkXIWV7XVI_cjs.generateUuid; }
 });
 Object.defineProperty(exports, "hash", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.hash; }
+  get: function () { return chunkXIWV7XVI_cjs.hash; }
 });
 Object.defineProperty(exports, "hashPassword", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.hashPassword; }
+  get: function () { return chunkXIWV7XVI_cjs.hashPassword; }
+});
+Object.defineProperty(exports, "isWebSecretKey", {
+  enumerable: true,
+  get: function () { return chunkXIWV7XVI_cjs.isWebSecretKey; }
 });
 Object.defineProperty(exports, "tryConvertBytesToStr", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryConvertBytesToStr; }
+  get: function () { return chunkXIWV7XVI_cjs.tryConvertBytesToStr; }
 });
 Object.defineProperty(exports, "tryConvertEncoding", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryConvertEncoding; }
+  get: function () { return chunkXIWV7XVI_cjs.tryConvertEncoding; }
 });
 Object.defineProperty(exports, "tryConvertStrToBytes", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryConvertStrToBytes; }
+  get: function () { return chunkXIWV7XVI_cjs.tryConvertStrToBytes; }
 });
 Object.defineProperty(exports, "tryCreateSecretKey", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryCreateSecretKey; }
+  get: function () { return chunkXIWV7XVI_cjs.tryCreateSecretKey; }
 });
 Object.defineProperty(exports, "tryDecrypt", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryDecrypt; }
+  get: function () { return chunkXIWV7XVI_cjs.tryDecrypt; }
 });
 Object.defineProperty(exports, "tryDecryptObj", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryDecryptObj; }
+  get: function () { return chunkXIWV7XVI_cjs.tryDecryptObj; }
 });
 Object.defineProperty(exports, "tryEncrypt", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryEncrypt; }
+  get: function () { return chunkXIWV7XVI_cjs.tryEncrypt; }
 });
 Object.defineProperty(exports, "tryEncryptObj", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryEncryptObj; }
+  get: function () { return chunkXIWV7XVI_cjs.tryEncryptObj; }
 });
 Object.defineProperty(exports, "tryGenerateUuid", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryGenerateUuid; }
+  get: function () { return chunkXIWV7XVI_cjs.tryGenerateUuid; }
 });
 Object.defineProperty(exports, "tryHash", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryHash; }
+  get: function () { return chunkXIWV7XVI_cjs.tryHash; }
 });
 Object.defineProperty(exports, "tryHashPassword", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.tryHashPassword; }
+  get: function () { return chunkXIWV7XVI_cjs.tryHashPassword; }
 });
 Object.defineProperty(exports, "verifyPassword", {
   enumerable: true,
-  get: function () { return chunkWIZT7AYM_cjs.verifyPassword; }
+  get: function () { return chunkXIWV7XVI_cjs.verifyPassword; }
 });
 Object.defineProperty(exports, "ENCRYPTED_REGEX", {
   enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.ENCRYPTED_REGEX; }
-});
-Object.defineProperty(exports, "isSecretKey", {
-  enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.isSecretKey; }
+  get: function () { return chunkUIV6DG54_cjs.ENCRYPTED_REGEX; }
 });
 Object.defineProperty(exports, "matchPattern", {
   enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.matchPattern; }
+  get: function () { return chunkUIV6DG54_cjs.matchPattern; }
 });
 Object.defineProperty(exports, "parseToObj", {
   enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.parseToObj; }
+  get: function () { return chunkUIV6DG54_cjs.parseToObj; }
 });
 Object.defineProperty(exports, "stringifyObj", {
   enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.stringifyObj; }
+  get: function () { return chunkUIV6DG54_cjs.stringifyObj; }
 });
 Object.defineProperty(exports, "tryParseToObj", {
   enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.tryParseToObj; }
+  get: function () { return chunkUIV6DG54_cjs.tryParseToObj; }
 });
 Object.defineProperty(exports, "tryStringifyObj", {
   enumerable: true,
-  get: function () { return chunkRXXVBCWL_cjs.tryStringifyObj; }
+  get: function () { return chunkUIV6DG54_cjs.tryStringifyObj; }
 });
 //# sourceMappingURL=web-api.cjs.map
 //# sourceMappingURL=web-api.cjs.map

package/dist/web-api.d.cts

@@ -1,3 +1,3 @@
-export { C as CreateSecretKeyOptions, e as DecryptOptions, D as DigestAlgorithm, E as ENCRYPTED_REGEX, b as Encoding, d as EncryptOptions, c as EncryptionAlgorithm, H as HashOptions, f as HashPasswordOptions, S as SecretKey, V as VerifyPasswordOptions, i as isSecretKey, m as matchPattern, p as parseToObj, s as stringifyObj, t as tryParseToObj, a as tryStringifyObj } from './validate-CS4PFmY1.cjs';
-export { u as convertBytesToStr, x as convertEncoding, r as convertStrToBytes, c as createSecretKey, f as decrypt, l as decryptObj, e as encrypt, i as encryptObj, g as generateUuid, n as hash, p as hashPassword, s as tryConvertBytesToStr, w as tryConvertEncoding, q as tryConvertStrToBytes, a as tryCreateSecretKey, d as tryDecrypt, j as tryDecryptObj, b as tryEncrypt, h as tryEncryptObj, t as tryGenerateUuid, m as tryHash, o as tryHashPassword, v as verifyPassword } from './export-LPOfeH2z.cjs';
+export { C as CipherEncoding, d as CreateSecretKeyOptions, f as DecryptOptions, D as DigestAlgorithm, E as ENCRYPTED_REGEX, b as Encoding, e as EncryptOptions, c as EncryptionAlgorithm, H as HashOptions, g as HashPasswordOptions, S as SecretKey, V as VerifyPasswordOptions, m as matchPattern, p as parseToObj, s as stringifyObj, t as tryParseToObj, a as tryStringifyObj } from './validate-Cb7IOrPo.cjs';
+export { u as convertBytesToStr, y as convertEncoding, r as convertStrToBytes, c as createSecretKey, f as decrypt, l as decryptObj, e as encrypt, j as encryptObj, g as generateUuid, n as hash, p as hashPassword, i as isWebSecretKey, s as tryConvertBytesToStr, x as tryConvertEncoding, q as tryConvertStrToBytes, a as tryCreateSecretKey, d as tryDecrypt, k as tryDecryptObj, b as tryEncrypt, h as tryEncryptObj, t as tryGenerateUuid, m as tryHash, o as tryHashPassword, v as verifyPassword } from './export-Gd8hafl6.cjs';
 import 'node:crypto';

package/dist/web-api.d.ts

@@ -1,3 +1,3 @@
-export { C as CreateSecretKeyOptions, e as DecryptOptions, D as DigestAlgorithm, E as ENCRYPTED_REGEX, b as Encoding, d as EncryptOptions, c as EncryptionAlgorithm, H as HashOptions, f as HashPasswordOptions, S as SecretKey, V as VerifyPasswordOptions, i as isSecretKey, m as matchPattern, p as parseToObj, s as stringifyObj, t as tryParseToObj, a as tryStringifyObj } from './validate-CS4PFmY1.js';
-export { u as convertBytesToStr, x as convertEncoding, r as convertStrToBytes, c as createSecretKey, f as decrypt, l as decryptObj, e as encrypt, i as encryptObj, g as generateUuid, n as hash, p as hashPassword, s as tryConvertBytesToStr, w as tryConvertEncoding, q as tryConvertStrToBytes, a as tryCreateSecretKey, d as tryDecrypt, j as tryDecryptObj, b as tryEncrypt, h as tryEncryptObj, t as tryGenerateUuid, m as tryHash, o as tryHashPassword, v as verifyPassword } from './export-C0WDJZUy.js';
+export { C as CipherEncoding, d as CreateSecretKeyOptions, f as DecryptOptions, D as DigestAlgorithm, E as ENCRYPTED_REGEX, b as Encoding, e as EncryptOptions, c as EncryptionAlgorithm, H as HashOptions, g as HashPasswordOptions, S as SecretKey, V as VerifyPasswordOptions, m as matchPattern, p as parseToObj, s as stringifyObj, t as tryParseToObj, a as tryStringifyObj } from './validate-Cb7IOrPo.js';
+export { u as convertBytesToStr, y as convertEncoding, r as convertStrToBytes, c as createSecretKey, f as decrypt, l as decryptObj, e as encrypt, j as encryptObj, g as generateUuid, n as hash, p as hashPassword, i as isWebSecretKey, s as tryConvertBytesToStr, x as tryConvertEncoding, q as tryConvertStrToBytes, a as tryCreateSecretKey, d as tryDecrypt, k as tryDecryptObj, b as tryEncrypt, h as tryEncryptObj, t as tryGenerateUuid, m as tryHash, o as tryHashPassword, v as verifyPassword } from './export-DGrELdz_.js';
 import 'node:crypto';

package/dist/web-api.js

@@ -1,4 +1,4 @@
-export { convertBytesToStr, convertEncoding, convertStrToBytes, createSecretKey, decrypt, decryptObj, encrypt, encryptObj, generateUuid, hash, hashPassword, tryConvertBytesToStr, tryConvertEncoding, tryConvertStrToBytes, tryCreateSecretKey, tryDecrypt, tryDecryptObj, tryEncrypt, tryEncryptObj, tryGenerateUuid, tryHash, tryHashPassword, verifyPassword } from './chunk-SUGN4VDZ.js';
-export { ENCRYPTED_REGEX, isSecretKey, matchPattern, parseToObj, stringifyObj, tryParseToObj, tryStringifyObj } from './chunk-LOJKJJX5.js';
+export { convertBytesToStr, convertEncoding, convertStrToBytes, createSecretKey, decrypt, decryptObj, encrypt, encryptObj, generateUuid, hash, hashPassword, isWebSecretKey, tryConvertBytesToStr, tryConvertEncoding, tryConvertStrToBytes, tryCreateSecretKey, tryDecrypt, tryDecryptObj, tryEncrypt, tryEncryptObj, tryGenerateUuid, tryHash, tryHashPassword, verifyPassword } from './chunk-LHB5NXYW.js';
+export { ENCRYPTED_REGEX, matchPattern, parseToObj, stringifyObj, tryParseToObj, tryStringifyObj } from './chunk-YMNOTRET.js';
 //# sourceMappingURL=web-api.js.map
 //# sourceMappingURL=web-api.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cipher-kit",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.4",
   "description": "🔐 Secure, Lightweight, and Cross-Platform Encryption, Decryption, and Hashing for Web, Node.js, Deno, Bun, and Cloudflare Workers",
   "homepage": "https://github.com/WolfieLeader/npm/tree/main/packages/cipher-kit#readme",
   "repository": {