cipher-kit 2.0.0 → 2.1.0

package/dist/{chunk-CVCDAHDW.cjs → chunk-UVEMRK5F.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunk3UX5MZ2P_cjs = require('./chunk-3UX5MZ2P.cjs');
+var chunkBHG5RSUV_cjs = require('./chunk-BHG5RSUV.cjs');
 
 // src/web/kit.ts
 var kit_exports = {};
-chunk3UX5MZ2P_cjs.__export(kit_exports, {
+chunkBHG5RSUV_cjs.__export(kit_exports, {
   convertBytesToStr: () => convertBytesToStr,
   convertEncoding: () => convertEncoding,
   convertStrToBytes: () => convertStrToBytes,
@@ -35,34 +35,34 @@ chunk3UX5MZ2P_cjs.__export(kit_exports, {
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
 function $convertStrToBytes(data, inputEncoding = "utf8") {
-  if (!chunk3UX5MZ2P_cjs.$isStr(data)) {
-    return chunk3UX5MZ2P_cjs.$err({
+  if (!chunkBHG5RSUV_cjs.$isStr(data)) {
+    return chunkBHG5RSUV_cjs.$err({
       msg: "Crypto Web API - String to Bytes: Empty data",
       desc: "Data must be a non-empty string"
     });
   }
-  if (!chunk3UX5MZ2P_cjs.ENCODING.includes(inputEncoding)) {
-    return chunk3UX5MZ2P_cjs.$err({
+  if (!chunkBHG5RSUV_cjs.ENCODING.includes(inputEncoding)) {
+    return chunkBHG5RSUV_cjs.$err({
       msg: `Crypto Web API - String to Bytes: Unsupported encoding: ${inputEncoding}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
   try {
     const bytes = strToBytes[inputEncoding](data);
-    return chunk3UX5MZ2P_cjs.$ok({ result: bytes });
+    return chunkBHG5RSUV_cjs.$ok({ result: bytes });
   } catch (error) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: "Crypto Web API - String to Bytes: Failed to convert data", desc: chunk3UX5MZ2P_cjs.$fmtError(error) });
+    return chunkBHG5RSUV_cjs.$err({ msg: "Crypto Web API - String to Bytes: Failed to convert data", desc: chunkBHG5RSUV_cjs.$fmtError(error) });
   }
 }
 function $convertBytesToStr(data, outputEncoding = "utf8") {
   if (!(data instanceof ArrayBuffer || data instanceof Uint8Array)) {
-    return chunk3UX5MZ2P_cjs.$err({
+    return chunkBHG5RSUV_cjs.$err({
       msg: "Crypto Web API - Bytes to String: Invalid data type",
       desc: "Data must be an ArrayBuffer or Uint8Array"
     });
   }
-  if (!chunk3UX5MZ2P_cjs.ENCODING.includes(outputEncoding)) {
-    return chunk3UX5MZ2P_cjs.$err({
+  if (!chunkBHG5RSUV_cjs.ENCODING.includes(outputEncoding)) {
+    return chunkBHG5RSUV_cjs.$err({
       msg: `Crypto Web API - Bytes to String: Unsupported encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
@@ -70,29 +70,29 @@ function $convertBytesToStr(data, outputEncoding = "utf8") {
   try {
     const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
     const str = bytesToStr[outputEncoding](bytes);
-    return chunk3UX5MZ2P_cjs.$ok(str);
+    return chunkBHG5RSUV_cjs.$ok(str);
   } catch (error) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: "Crypto Web API - Bytes to String: Failed to convert data", desc: chunk3UX5MZ2P_cjs.$fmtError(error) });
+    return chunkBHG5RSUV_cjs.$err({ msg: "Crypto Web API - Bytes to String: Failed to convert data", desc: chunkBHG5RSUV_cjs.$fmtError(error) });
   }
 }
 function $convertEncoding(data, from, to) {
-  if (!chunk3UX5MZ2P_cjs.$isStr(data)) {
-    return chunk3UX5MZ2P_cjs.$err({
+  if (!chunkBHG5RSUV_cjs.$isStr(data)) {
+    return chunkBHG5RSUV_cjs.$err({
       msg: "Crypto Web API - Convert Format: Empty data",
       desc: "Data must be a non-empty string"
     });
   }
-  if (!chunk3UX5MZ2P_cjs.ENCODING.includes(from) || !chunk3UX5MZ2P_cjs.ENCODING.includes(to)) {
-    return chunk3UX5MZ2P_cjs.$err({
+  if (!chunkBHG5RSUV_cjs.ENCODING.includes(from) || !chunkBHG5RSUV_cjs.ENCODING.includes(to)) {
+    return chunkBHG5RSUV_cjs.$err({
       msg: `Crypto Web API - Convert Format: Unsupported encoding: from ${from} to ${to}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
   const bytes = $convertStrToBytes(data, from);
-  if (bytes.error) return chunk3UX5MZ2P_cjs.$err({ msg: bytes.error.message, desc: bytes.error.description });
+  if (bytes.error) return chunkBHG5RSUV_cjs.$err({ msg: bytes.error.message, desc: bytes.error.description });
   const str = $convertBytesToStr(bytes.result, to);
-  if (str.error) return chunk3UX5MZ2P_cjs.$err({ msg: str.error.message, desc: str.error.description });
-  return chunk3UX5MZ2P_cjs.$ok({ result: str.result });
+  if (str.error) return chunkBHG5RSUV_cjs.$err({ msg: str.error.message, desc: str.error.description });
+  return chunkBHG5RSUV_cjs.$ok({ result: str.result });
 }
 var strToBytes = {
   base64: $fromBase64,
@@ -158,45 +158,54 @@ function $fromHex(data) {
 // src/web/web-encrypt.ts
 function $generateUuid() {
   try {
-    return chunk3UX5MZ2P_cjs.$ok(crypto.randomUUID());
+    return chunkBHG5RSUV_cjs.$ok(crypto.randomUUID());
   } catch (error) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "UUID Generation")}: Failed to generate UUID`, desc: chunk3UX5MZ2P_cjs.$fmtError(error) });
+    return chunkBHG5RSUV_cjs.$err({ msg: `${chunkBHG5RSUV_cjs.title("web", "UUID Generation")}: Failed to generate UUID`, desc: chunkBHG5RSUV_cjs.$fmtError(error) });
   }
 }
-async function $createSecretKey(secret, options = {}) {
-  if (!chunk3UX5MZ2P_cjs.$isStr(secret)) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "Key Generation")}: Empty Secret`, desc: "Secret must be a non-empty string" });
+async function $createSecretKey(secret, options) {
+  if (!chunkBHG5RSUV_cjs.$isStr(secret, 8)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Empty Secret`,
+      desc: "Secret must be a non-empty string with at least 8 characters"
+    });
+  }
+  if (!chunkBHG5RSUV_cjs.$isPlainObj(options)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Invalid options`,
+      desc: "Options must be an object"
+    });
   }
   const algorithm = options.algorithm ?? "aes256gcm";
-  if (!(algorithm in chunk3UX5MZ2P_cjs.ENCRYPTION_ALGORITHMS)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Key Generation")}: Unsupported algorithm: ${algorithm}`,
-      desc: `Supported algorithms are: ${Object.keys(chunk3UX5MZ2P_cjs.ENCRYPTION_ALGORITHMS).join(", ")}`
+  if (!(algorithm in chunkBHG5RSUV_cjs.ENCRYPTION_ALGORITHMS)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Unsupported algorithm: ${algorithm}`,
+      desc: `Supported algorithms are: ${Object.keys(chunkBHG5RSUV_cjs.ENCRYPTION_ALGORITHMS).join(", ")}`
     });
   }
   const digest = options.digest ?? "sha256";
-  if (!(digest in chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Key Generation")}: Unsupported digest: ${digest}`,
-      desc: `Supported digests are: ${Object.keys(chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS).join(", ")}`
+  if (!(digest in chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS).join(", ")}`
     });
   }
   const salt = options.salt ?? "cipher-kit-salt";
-  if (!chunk3UX5MZ2P_cjs.$isStr(salt, 8)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Key Generation")}: Weak salt`,
+  if (!chunkBHG5RSUV_cjs.$isStr(salt, 8)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Weak salt`,
       desc: "Salt must be a non-empty string with at least 8 characters"
     });
   }
   const info = options.info ?? "cipher-kit";
-  if (!chunk3UX5MZ2P_cjs.$isStr(info)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Key Generation")}: Invalid info`,
+  if (!chunkBHG5RSUV_cjs.$isStr(info)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Invalid info`,
       desc: "Info must be a non-empty string"
     });
   }
-  const encryptAlgo = chunk3UX5MZ2P_cjs.ENCRYPTION_ALGORITHMS[algorithm];
-  const digestAlgo = chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS[digest];
+  const encryptAlgo = chunkBHG5RSUV_cjs.ENCRYPTION_ALGORITHMS[algorithm];
+  const digestAlgo = chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS[digest];
   try {
     const ikm = await crypto.subtle.importKey("raw", textEncoder.encode(secret.normalize("NFKC")), "HKDF", false, [
       "deriveKey"
@@ -219,37 +228,43 @@ async function $createSecretKey(secret, options = {}) {
       algorithm,
       key
     });
-    return chunk3UX5MZ2P_cjs.$ok({ result: secretKey });
+    return chunkBHG5RSUV_cjs.$ok({ result: secretKey });
   } catch (error) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Key Generation")}: Failed to create secret key`,
-      desc: chunk3UX5MZ2P_cjs.$fmtError(error)
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Key Generation")}: Failed to create secret key`,
+      desc: chunkBHG5RSUV_cjs.$fmtError(error)
     });
   }
 }
-async function $encrypt(data, secretKey, options = {}) {
-  if (!chunk3UX5MZ2P_cjs.$isStr(data)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Encryption")}: Empty data for encryption`,
+async function $encrypt(data, secretKey, options) {
+  if (!chunkBHG5RSUV_cjs.$isStr(data)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Encryption")}: Empty data for encryption`,
       desc: "Data must be a non-empty string"
     });
   }
-  const encoding = options.encoding ?? "base64url";
-  if (!chunk3UX5MZ2P_cjs.CIPHER_ENCODING.includes(encoding)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Encryption")}: Unsupported output encoding: ${encoding}`,
+  if (!chunkBHG5RSUV_cjs.$isPlainObj(options)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Encryption")}: Invalid options`,
+      desc: "Options must be an object"
+    });
+  }
+  const outputEncoding = options.outputEncoding ?? "base64url";
+  if (!chunkBHG5RSUV_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Encryption")}: Unsupported output encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
-  const injectedKey = chunk3UX5MZ2P_cjs.$isSecretKey(secretKey, "web");
+  const injectedKey = chunkBHG5RSUV_cjs.$isSecretKey(secretKey, "web");
   if (!injectedKey) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Encryption")}: Invalid Secret Key`,
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Encryption")}: Invalid Secret Key`,
       desc: "Expected a Web SecretKey"
     });
   }
   const { result, error } = $convertStrToBytes(data, "utf8");
-  if (error) return chunk3UX5MZ2P_cjs.$err(error);
+  if (error) return chunkBHG5RSUV_cjs.$err(error);
   try {
     const iv = crypto.getRandomValues(new Uint8Array(injectedKey.injected.ivLength));
     const cipherWithTag = await crypto.subtle.encrypt(
@@ -257,53 +272,59 @@ async function $encrypt(data, secretKey, options = {}) {
       injectedKey.key,
       result
     );
-    const ivStr = $convertBytesToStr(iv, encoding);
-    const cipherStr = $convertBytesToStr(cipherWithTag, encoding);
+    const ivStr = $convertBytesToStr(iv, outputEncoding);
+    const cipherStr = $convertBytesToStr(cipherWithTag, outputEncoding);
     if (ivStr.error || cipherStr.error) {
-      return chunk3UX5MZ2P_cjs.$err({
-        msg: `${chunk3UX5MZ2P_cjs.title("web", "Encryption")}: Failed to convert IV or encrypted data`,
-        desc: `Conversion error: ${chunk3UX5MZ2P_cjs.$fmtResultErr(ivStr.error || cipherStr.error)}`
+      return chunkBHG5RSUV_cjs.$err({
+        msg: `${chunkBHG5RSUV_cjs.title("web", "Encryption")}: Failed to convert IV or encrypted data`,
+        desc: `Conversion error: ${chunkBHG5RSUV_cjs.$fmtResultErr(ivStr.error || cipherStr.error)}`
       });
     }
-    return chunk3UX5MZ2P_cjs.$ok(`${ivStr.result}.${cipherStr.result}.`);
+    return chunkBHG5RSUV_cjs.$ok(`${ivStr.result}.${cipherStr.result}.`);
   } catch (error2) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "Encryption")}: Failed to encrypt data`, desc: chunk3UX5MZ2P_cjs.$fmtError(error2) });
+    return chunkBHG5RSUV_cjs.$err({ msg: `${chunkBHG5RSUV_cjs.title("web", "Encryption")}: Failed to encrypt data`, desc: chunkBHG5RSUV_cjs.$fmtError(error2) });
   }
 }
-async function $decrypt(encrypted, secretKey, options = {}) {
-  if (chunk3UX5MZ2P_cjs.matchPattern(encrypted, "web") === false) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Decryption")}: Invalid encrypted data format`,
+async function $decrypt(encrypted, secretKey, options) {
+  if (!chunkBHG5RSUV_cjs.matchEncryptedPattern(encrypted, "web")) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Invalid encrypted data format`,
       desc: 'Encrypted data must be in the format "iv.cipherWithTag."'
     });
   }
-  const encoding = options.encoding ?? "base64url";
-  if (!chunk3UX5MZ2P_cjs.CIPHER_ENCODING.includes(encoding)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Decryption")}: Unsupported input encoding: ${encoding}`,
+  if (!chunkBHG5RSUV_cjs.$isPlainObj(options)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Invalid options`,
+      desc: "Options must be an object"
+    });
+  }
+  const inputEncoding = options.inputEncoding ?? "base64url";
+  if (!chunkBHG5RSUV_cjs.CIPHER_ENCODING.includes(inputEncoding)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Unsupported input encoding: ${inputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
   const [iv, encryptedWithTag] = encrypted.split(".", 3);
-  if (!chunk3UX5MZ2P_cjs.$isStr(iv) || !chunk3UX5MZ2P_cjs.$isStr(encryptedWithTag)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Decryption")}: Invalid encrypted data`,
+  if (!chunkBHG5RSUV_cjs.$isStr(iv) || !chunkBHG5RSUV_cjs.$isStr(encryptedWithTag)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Invalid encrypted data`,
       desc: "Encrypted data must contain valid IV, encrypted and tag components"
     });
   }
-  const injectedKey = chunk3UX5MZ2P_cjs.$isSecretKey(secretKey, "web");
+  const injectedKey = chunkBHG5RSUV_cjs.$isSecretKey(secretKey, "web");
   if (!injectedKey) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Decryption")}: Invalid Secret Key`,
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Invalid Secret Key`,
       desc: "Expected a Web SecretKey"
     });
   }
-  const ivBytes = $convertStrToBytes(iv, encoding);
-  const cipherWithTagBytes = $convertStrToBytes(encryptedWithTag, encoding);
+  const ivBytes = $convertStrToBytes(iv, inputEncoding);
+  const cipherWithTagBytes = $convertStrToBytes(encryptedWithTag, inputEncoding);
   if (ivBytes.error || cipherWithTagBytes.error) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Decryption")}: Failed to convert IV or encrypted data`,
-      desc: `Conversion error: ${chunk3UX5MZ2P_cjs.$fmtResultErr(ivBytes.error || cipherWithTagBytes.error)}`
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Failed to convert IV or encrypted data`,
+      desc: `Conversion error: ${chunkBHG5RSUV_cjs.$fmtResultErr(ivBytes.error || cipherWithTagBytes.error)}`
     });
   }
   try {
@@ -314,87 +335,99 @@ async function $decrypt(encrypted, secretKey, options = {}) {
     );
     return $convertBytesToStr(decrypted, "utf8");
   } catch (error) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "Decryption")}: Failed to decrypt data`, desc: chunk3UX5MZ2P_cjs.$fmtError(error) });
+    return chunkBHG5RSUV_cjs.$err({ msg: `${chunkBHG5RSUV_cjs.title("web", "Decryption")}: Failed to decrypt data`, desc: chunkBHG5RSUV_cjs.$fmtError(error) });
   }
 }
-async function $encryptObj(data, secretKey, options = {}) {
-  const { result, error } = chunk3UX5MZ2P_cjs.$stringifyObj(data);
-  if (error) return chunk3UX5MZ2P_cjs.$err(error);
+async function $encryptObj(data, secretKey, options) {
+  const { result, error } = chunkBHG5RSUV_cjs.$stringifyObj(data);
+  if (error) return chunkBHG5RSUV_cjs.$err(error);
   return await $encrypt(result, secretKey, options);
 }
-async function $decryptObj(encrypted, secretKey, options = {}) {
+async function $decryptObj(encrypted, secretKey, options) {
   const { result, error } = await $decrypt(encrypted, secretKey, options);
-  if (error) return chunk3UX5MZ2P_cjs.$err(error);
-  return chunk3UX5MZ2P_cjs.$parseToObj(result);
+  if (error) return chunkBHG5RSUV_cjs.$err(error);
+  return chunkBHG5RSUV_cjs.$parseToObj(result);
 }
-async function $hash(data, options = {}) {
-  if (!chunk3UX5MZ2P_cjs.$isStr(data)) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "Hashing")}: Empty data for hashing`, desc: "Data must be a non-empty string" });
+async function $hash(data, options) {
+  if (!chunkBHG5RSUV_cjs.$isStr(data)) {
+    return chunkBHG5RSUV_cjs.$err({ msg: `${chunkBHG5RSUV_cjs.title("web", "Hashing")}: Empty data for hashing`, desc: "Data must be a non-empty string" });
   }
-  const encoding = options.encoding ?? "base64url";
-  if (!chunk3UX5MZ2P_cjs.CIPHER_ENCODING.includes(encoding)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Hashing")}: Unsupported output encoding: ${encoding}`,
+  if (!chunkBHG5RSUV_cjs.$isPlainObj(options)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Hashing")}: Invalid options`,
+      desc: "Options must be an object"
+    });
+  }
+  const outputEncoding = options.outputEncoding ?? "base64url";
+  if (!chunkBHG5RSUV_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Hashing")}: Unsupported output encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
   const digest = options.digest ?? "sha256";
-  if (!(digest in chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Hashing")}: Unsupported digest: ${digest}`,
-      desc: `Supported digests are: ${Object.keys(chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS).join(", ")}`
+  if (!(digest in chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Hashing")}: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS).join(", ")}`
     });
   }
-  const digestAlgo = chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS[digest];
+  const digestAlgo = chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS[digest];
   const { result, error } = $convertStrToBytes(data, "utf8");
-  if (error) return chunk3UX5MZ2P_cjs.$err(error);
+  if (error) return chunkBHG5RSUV_cjs.$err(error);
   try {
     const hashed = await crypto.subtle.digest(digestAlgo.web, result);
-    return $convertBytesToStr(hashed, encoding);
+    return $convertBytesToStr(hashed, outputEncoding);
   } catch (error2) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "Hashing")}: Failed to hash data`, desc: chunk3UX5MZ2P_cjs.$fmtError(error2) });
+    return chunkBHG5RSUV_cjs.$err({ msg: `${chunkBHG5RSUV_cjs.title("web", "Hashing")}: Failed to hash data`, desc: chunkBHG5RSUV_cjs.$fmtError(error2) });
   }
 }
-async function $hashPassword(password, options = {}) {
-  if (!chunk3UX5MZ2P_cjs.$isStr(password)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Empty password`,
+async function $hashPassword(password, options) {
+  if (!chunkBHG5RSUV_cjs.$isStr(password)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Empty password`,
       desc: "Password must be a non-empty string"
     });
   }
+  if (!chunkBHG5RSUV_cjs.$isPlainObj(options)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Invalid options`,
+      desc: "Options must be an object"
+    });
+  }
   const digest = options.digest ?? "sha512";
-  if (!(digest in chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Unsupported digest: ${digest}`,
-      desc: `Supported digests are: ${Object.keys(chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS).join(", ")}`
+  if (!(digest in chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS).join(", ")}`
     });
   }
-  const digestAlgo = chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS[digest];
-  const encoding = options.encoding ?? "base64url";
-  if (!chunk3UX5MZ2P_cjs.CIPHER_ENCODING.includes(encoding)) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Unsupported output encoding: ${encoding}`,
+  const digestAlgo = chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS[digest];
+  const outputEncoding = options.outputEncoding ?? "base64url";
+  if (!chunkBHG5RSUV_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Unsupported output encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
   const saltLength = options.saltLength ?? 16;
   if (typeof saltLength !== "number" || saltLength < 8) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Weak salt length`,
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Weak salt length`,
       desc: "Salt length must be a number and at least 8 bytes (recommended 16)"
     });
   }
   const iterations = options.iterations ?? 32e4;
   if (typeof iterations !== "number" || iterations < 1e3) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Weak iteration count`,
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Weak iteration count`,
       desc: "Iterations must be a number and at least 1000 (recommended 320,000 or more)"
     });
   }
   const keyLength = options.keyLength ?? 64;
   if (typeof keyLength !== "number" || keyLength < 16) {
-    return chunk3UX5MZ2P_cjs.$err({
-      msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Weak key length`,
+    return chunkBHG5RSUV_cjs.$err({
+      msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Weak key length`,
       desc: "Key length must be a number and at least 16 bytes (recommended 64)"
     });
   }
@@ -412,29 +445,31 @@ async function $hashPassword(password, options = {}) {
       baseKey,
       keyLength * 8
     );
-    const saltStr = $convertBytesToStr(salt, encoding);
-    if (saltStr.error) return chunk3UX5MZ2P_cjs.$err(saltStr.error);
-    const hashedPasswordStr = $convertBytesToStr(bits, encoding);
-    if (hashedPasswordStr.error) return chunk3UX5MZ2P_cjs.$err(hashedPasswordStr.error);
-    return chunk3UX5MZ2P_cjs.$ok({ hash: hashedPasswordStr.result, salt: saltStr.result });
+    const saltStr = $convertBytesToStr(salt, outputEncoding);
+    if (saltStr.error) return chunkBHG5RSUV_cjs.$err(saltStr.error);
+    const hashedPasswordStr = $convertBytesToStr(bits, outputEncoding);
+    if (hashedPasswordStr.error) return chunkBHG5RSUV_cjs.$err(hashedPasswordStr.error);
+    return chunkBHG5RSUV_cjs.$ok({ result: hashedPasswordStr.result, salt: saltStr.result });
   } catch (error) {
-    return chunk3UX5MZ2P_cjs.$err({ msg: `${chunk3UX5MZ2P_cjs.title("web", "Password Hashing")}: Failed to hash password`, desc: chunk3UX5MZ2P_cjs.$fmtError(error) });
+    return chunkBHG5RSUV_cjs.$err({ msg: `${chunkBHG5RSUV_cjs.title("web", "Password Hashing")}: Failed to hash password`, desc: chunkBHG5RSUV_cjs.$fmtError(error) });
   }
 }
-async function $verifyPassword(password, hashedPassword, salt, options = {}) {
-  if (!chunk3UX5MZ2P_cjs.$isStr(password) || !chunk3UX5MZ2P_cjs.$isStr(hashedPassword) || !chunk3UX5MZ2P_cjs.$isStr(salt)) return false;
+async function $verifyPassword(password, hashedPassword, salt, options) {
+  if (!chunkBHG5RSUV_cjs.$isStr(password) || !chunkBHG5RSUV_cjs.$isStr(hashedPassword) || !chunkBHG5RSUV_cjs.$isStr(salt) || !chunkBHG5RSUV_cjs.$isPlainObj(options)) {
+    return false;
+  }
   const digest = options.digest ?? "sha512";
-  if (!(digest in chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS)) return false;
-  const digestAlgo = chunk3UX5MZ2P_cjs.DIGEST_ALGORITHMS[digest];
-  const encoding = options.encoding ?? "base64url";
-  if (!chunk3UX5MZ2P_cjs.CIPHER_ENCODING.includes(encoding)) return false;
+  if (!(digest in chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS)) return false;
+  const digestAlgo = chunkBHG5RSUV_cjs.DIGEST_ALGORITHMS[digest];
+  const inputEncoding = options.inputEncoding ?? "base64url";
+  if (!chunkBHG5RSUV_cjs.CIPHER_ENCODING.includes(inputEncoding)) return false;
   const iterations = options.iterations ?? 32e4;
   if (typeof iterations !== "number" || iterations < 1e3) return false;
   const keyLength = options.keyLength ?? 64;
   if (typeof keyLength !== "number" || keyLength < 16) return false;
-  const saltBytes = $convertStrToBytes(salt, encoding);
+  const saltBytes = $convertStrToBytes(salt, inputEncoding);
   if (saltBytes.error) return false;
-  const hashedPasswordBytes = $convertStrToBytes(hashedPassword, encoding);
+  const hashedPasswordBytes = $convertStrToBytes(hashedPassword, inputEncoding);
   if (hashedPasswordBytes.error) return false;
   try {
     const baseKey = await crypto.subtle.importKey(
@@ -470,14 +505,14 @@ async function $verifyPassword(password, hashedPassword, salt, options = {}) {
 
 // src/web/kit.ts
 function isWebSecretKey(x) {
-  return chunk3UX5MZ2P_cjs.$isSecretKey(x, "web") !== null;
+  return chunkBHG5RSUV_cjs.$isSecretKey(x, "web") !== null;
 }
 function tryGenerateUuid() {
   return $generateUuid();
 }
 function generateUuid() {
   const { result, error } = $generateUuid();
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryCreateSecretKey(secret, options = {}) {
@@ -485,7 +520,7 @@ async function tryCreateSecretKey(secret, options = {}) {
 }
 async function createSecretKey(secret, options = {}) {
   const { result, error } = await $createSecretKey(secret, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryEncrypt(data, secretKey, options = {}) {
@@ -493,7 +528,7 @@ async function tryEncrypt(data, secretKey, options = {}) {
 }
 async function encrypt(data, secretKey, options = {}) {
   const { result, error } = await $encrypt(data, secretKey, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryDecrypt(encrypted, secretKey, options = {}) {
@@ -501,7 +536,7 @@ async function tryDecrypt(encrypted, secretKey, options = {}) {
 }
 async function decrypt(encrypted, secretKey, options = {}) {
   const { result, error } = await $decrypt(encrypted, secretKey, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryEncryptObj(data, secretKey, options = {}) {
@@ -509,7 +544,7 @@ async function tryEncryptObj(data, secretKey, options = {}) {
 }
 async function encryptObj(data, secretKey, options = {}) {
   const { result, error } = await $encryptObj(data, secretKey, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryDecryptObj(encrypted, secretKey, options = {}) {
@@ -517,7 +552,7 @@ async function tryDecryptObj(encrypted, secretKey, options = {}) {
 }
 async function decryptObj(encrypted, secretKey, options = {}) {
   const { result, error } = await $decryptObj(encrypted, secretKey, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryHash(data, options = {}) {
@@ -525,16 +560,16 @@ async function tryHash(data, options = {}) {
 }
 async function hash(data, options = {}) {
   const { result, error } = await $hash(data, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 async function tryHashPassword(password, options = {}) {
   return await $hashPassword(password, options);
 }
 async function hashPassword(password, options = {}) {
-  const { hash: hash2, salt, error } = await $hashPassword(password, options);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
-  return { hash: hash2, salt };
+  const { result, salt, error } = await $hashPassword(password, options);
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
+  return { result, salt };
 }
 async function verifyPassword(password, hashedPassword, salt, options = {}) {
   return await $verifyPassword(password, hashedPassword, salt, options);
@@ -544,7 +579,7 @@ function tryConvertStrToBytes(data, inputEncoding = "utf8") {
 }
 function convertStrToBytes(data, inputEncoding = "utf8") {
   const { result, error } = $convertStrToBytes(data, inputEncoding);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 function tryConvertBytesToStr(data, outputEncoding = "utf8") {
@@ -552,7 +587,7 @@ function tryConvertBytesToStr(data, outputEncoding = "utf8") {
 }
 function convertBytesToStr(data, outputEncoding = "utf8") {
   const { result, error } = $convertBytesToStr(data, outputEncoding);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 function tryConvertEncoding(data, from, to) {
@@ -560,7 +595,7 @@ function tryConvertEncoding(data, from, to) {
 }
 function convertEncoding(data, from, to) {
   const { result, error } = $convertEncoding(data, from, to);
-  if (error) throw new Error(chunk3UX5MZ2P_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkBHG5RSUV_cjs.$fmtResultErr(error));
   return result;
 }
 
@@ -589,5 +624,5 @@ exports.tryGenerateUuid = tryGenerateUuid;
 exports.tryHash = tryHash;
 exports.tryHashPassword = tryHashPassword;
 exports.verifyPassword = verifyPassword;
-//# sourceMappingURL=chunk-CVCDAHDW.cjs.map
-//# sourceMappingURL=chunk-CVCDAHDW.cjs.map
+//# sourceMappingURL=chunk-UVEMRK5F.cjs.map
+//# sourceMappingURL=chunk-UVEMRK5F.cjs.map