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

package/dist/{chunk-ZIVTPFKN.cjs → chunk-RXXVBCWL.cjs}

@@ -13,7 +13,7 @@ var __export = (target, all) => {
 };
 
 // src/helpers/consts.ts
-var ENCODING_FORMATS = Object.freeze(["base64", "base64url", "hex", "utf8", "latin1"]);
+var ENCODINGS = Object.freeze(["base64", "base64url", "hex", "utf8", "latin1"]);
 var DIGEST_ALGORITHMS = Object.freeze({
   sha256: { node: "sha256", web: "SHA-256" },
   sha384: { node: "sha384", web: "SHA-384" },
@@ -24,9 +24,6 @@ var ENCRYPTION_ALGORITHMS = Object.freeze({
   aes192gcm: { name: "aes192gcm", keyBytes: 24, ivLength: 12, node: "aes-192-gcm", web: "AES-GCM" },
   aes128gcm: { name: "aes128gcm", keyBytes: 16, ivLength: 12, node: "aes-128-gcm", web: "AES-GCM" }
 });
-var PASSWORD_HASHING = Object.freeze({
-  pbkdf2: { saltLength: 16, iterations: 32e4, keyLength: 64 }
-});
 
 // src/helpers/validate.ts
 function $isStr(x, min = 1) {
@@ -148,10 +145,9 @@ exports.$ok = $ok;
 exports.$parseToObj = $parseToObj;
 exports.$stringifyObj = $stringifyObj;
 exports.DIGEST_ALGORITHMS = DIGEST_ALGORITHMS;
-exports.ENCODING_FORMATS = ENCODING_FORMATS;
+exports.ENCODINGS = ENCODINGS;
 exports.ENCRYPTED_REGEX = ENCRYPTED_REGEX;
 exports.ENCRYPTION_ALGORITHMS = ENCRYPTION_ALGORITHMS;
-exports.PASSWORD_HASHING = PASSWORD_HASHING;
 exports.__export = __export;
 exports.isSecretKey = isSecretKey;
 exports.matchPattern = matchPattern;
@@ -159,5 +155,5 @@ exports.parseToObj = parseToObj;
 exports.stringifyObj = stringifyObj;
 exports.tryParseToObj = tryParseToObj;
 exports.tryStringifyObj = tryStringifyObj;
-//# sourceMappingURL=chunk-ZIVTPFKN.cjs.map
-//# sourceMappingURL=chunk-ZIVTPFKN.cjs.map
+//# sourceMappingURL=chunk-RXXVBCWL.cjs.map
+//# sourceMappingURL=chunk-RXXVBCWL.cjs.map

package/dist/chunk-RXXVBCWL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helpers/consts.ts","../src/helpers/validate.ts","../src/helpers/error.ts","../src/helpers/object.ts"],"names":["nodeCrypto"],"mappings":"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","file":"chunk-RXXVBCWL.cjs","sourcesContent":["export const ENCODINGS = Object.freeze(['base64', 'base64url', 'hex', 'utf8', 'latin1'] as const);\r\n\r\nexport const DIGEST_ALGORITHMS = Object.freeze({\r\n  sha256: { node: 'sha256', web: 'SHA-256' },\r\n  sha384: { node: 'sha384', web: 'SHA-384' },\r\n  sha512: { node: 'sha512', web: 'SHA-512' },\r\n} as const);\r\n\r\nexport const ENCRYPTION_ALGORITHMS = Object.freeze({\r\n  aes256gcm: { name: 'aes256gcm', keyBytes: 32, ivLength: 12, node: 'aes-256-gcm', web: 'AES-GCM' },\r\n  aes192gcm: { name: 'aes192gcm', keyBytes: 24, ivLength: 12, node: 'aes-192-gcm', web: 'AES-GCM' },\r\n  aes128gcm: { name: 'aes128gcm', keyBytes: 16, ivLength: 12, node: 'aes-128-gcm', web: 'AES-GCM' },\r\n} as const);\r\n","import nodeCrypto from 'node:crypto';\r\nimport type { EncryptionAlgorithm, SecretKey } from '~/helpers/types';\r\nimport { DIGEST_ALGORITHMS, ENCRYPTION_ALGORITHMS } from './consts';\r\n\r\nexport function $isStr(x: unknown, min = 1): x is string {\r\n  return x !== null && x !== undefined && typeof x === 'string' && x.trim().length >= min;\r\n}\r\n\r\nexport function $isObj(x: unknown): x is Record<string, unknown> {\r\n  if (typeof x !== 'object' || x === null || x === undefined) return false;\r\n  const proto = Object.getPrototypeOf(x);\r\n  return proto === Object.prototype || proto === null;\r\n}\r\n\r\nexport function $isLooseObj(x: unknown): x is Record<string, unknown> {\r\n  return typeof x === 'object' && x !== null && x !== undefined;\r\n}\r\n\r\nconst expectedKeys = new Set(['platform', 'digest', 'algo', 'key']);\r\nconst expectedAlgoKeys = new Set(['name', 'keyBytes', 'ivLength', 'node', 'web']);\r\n\r\nexport function isSecretKey<Platform extends 'node' | 'web'>(x: unknown, platform: Platform): x is SecretKey<Platform> {\r\n  if (!$isLooseObj(x) || (platform !== 'node' && platform !== 'web') || x.platform !== platform) return false;\r\n\r\n  const keys = Object.keys(x);\r\n  if (keys.length !== expectedKeys.size) return false;\r\n  for (const key of keys) if (!expectedKeys.has(key)) return false;\r\n  for (const key of expectedKeys) if (!Object.hasOwn(x, key)) return false;\r\n\r\n  if (typeof x.digest !== 'string' || !(x.digest in DIGEST_ALGORITHMS)) return false;\r\n  if (!$isLooseObj(x.algo) || typeof x.algo.name !== 'string' || !(x.algo.name in ENCRYPTION_ALGORITHMS)) return false;\r\n\r\n  const algoKeys = Object.keys(x.algo);\r\n  if (algoKeys.length !== expectedAlgoKeys.size) return false;\r\n  for (const key of algoKeys) if (!expectedAlgoKeys.has(key)) return false;\r\n  for (const key of expectedAlgoKeys) if (!Object.hasOwn(x.algo, key)) return false;\r\n\r\n  const algo = ENCRYPTION_ALGORITHMS[x.algo.name as EncryptionAlgorithm];\r\n  if (\r\n    x.algo.keyBytes !== algo.keyBytes ||\r\n    x.algo.ivLength !== algo.ivLength ||\r\n    x.algo.node !== algo.node ||\r\n    x.algo.web !== algo.web\r\n  ) {\r\n    return false;\r\n  }\r\n\r\n  if (!$isLooseObj(x.key) || x.key.type !== 'secret') return false;\r\n\r\n  if (platform === 'node') {\r\n    if (\r\n      !(x.key instanceof nodeCrypto.KeyObject) ||\r\n      (typeof x.key.symmetricKeySize === 'number' && x.key.symmetricKeySize !== algo.keyBytes)\r\n    ) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  if (\r\n    !$isLooseObj(x.key.algorithm) ||\r\n    x.key.algorithm.name !== algo.web ||\r\n    (typeof x.key.algorithm.length === 'number' && x.key.algorithm.length !== algo.keyBytes * 8) ||\r\n    typeof x.key.extractable !== 'boolean' ||\r\n    !Array.isArray(x.key.usages) ||\r\n    x.key.usages.length !== 2 ||\r\n    !(x.key.usages.includes('encrypt') && x.key.usages.includes('decrypt'))\r\n  ) {\r\n    return false;\r\n  }\r\n  return true;\r\n}\r\n\r\n/** Regular expressions for encrypted data patterns */\r\nexport const ENCRYPTED_REGEX = Object.freeze({\r\n  general: /^(?:[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+(?:\\.[A-Za-z0-9_-]+)?\\.)$/,\r\n  node: /^([A-Za-z0-9_-]+)\\.([A-Za-z0-9_-]+)\\.([A-Za-z0-9_-]+)\\.$/,\r\n  web: /^([A-Za-z0-9_-]+)\\.([A-Za-z0-9_-]+)\\.$/,\r\n});\r\n\r\n/** Checks if the input string matches the specified encrypted data pattern. */\r\nexport function matchPattern(data: string, format: 'general' | 'node' | 'web'): boolean {\r\n  if (typeof data !== 'string') return false;\r\n  if (!(format in ENCRYPTED_REGEX)) throw new Error(`Unknown format: ${format}`);\r\n  return ENCRYPTED_REGEX[format].test(data);\r\n}\r\n","import { $isObj } from './validate';\r\n\r\nexport interface ResultErr {\r\n  readonly message: string;\r\n  readonly description: string;\r\n}\r\n\r\nexport type Result<T, E = ResultErr> = T extends object\r\n  ?\r\n      | ({ readonly [K in keyof T]: T[K] } & { readonly success: true; readonly error?: undefined })\r\n      | ({ readonly [K in keyof T]?: undefined } & { readonly success: false; readonly error: E })\r\n  :\r\n      | { readonly success: true; readonly result: T; readonly error?: undefined }\r\n      | { readonly success: false; readonly error: E; readonly result?: undefined };\r\n\r\nexport function $ok<T>(result?: T): Result<T> {\r\n  if ($isObj(result)) return { success: true, ...(result as T & object) } as Result<T>;\r\n  return { success: true, result } as Result<T>;\r\n}\r\n\r\nexport function $err(err: { msg: string; desc: string }): Result<never, ResultErr>;\r\nexport function $err(err: ResultErr): Result<never, ResultErr>;\r\nexport function $err(err: { msg: string; desc: string } | ResultErr): Result<never, ResultErr> {\r\n  return {\r\n    success: false,\r\n    error: {\r\n      message: 'msg' in err ? err.msg : err.message,\r\n      description: 'desc' in err ? err.desc : err.description,\r\n    },\r\n  } as Result<never, ResultErr>;\r\n}\r\n\r\nexport function $fmtError(error: unknown): string {\r\n  if (error instanceof Error) return error.message;\r\n  if (typeof error === 'string') return error;\r\n  return String(error);\r\n}\r\n\r\nexport function $fmtResultErr(err: ResultErr): string {\r\n  return `${err.message} - ${err.description}`;\r\n}\r\n","import { $err, $fmtError, $fmtResultErr, $ok, type Result } from './error';\r\nimport { $isObj, $isStr } from './validate';\r\n\r\nexport function $stringifyObj<T extends object = Record<string, unknown>>(obj: T): Result<string> {\r\n  try {\r\n    if (!$isObj(obj)) return $err({ msg: 'Invalid object', desc: 'Input is not a plain object' });\r\n    return $ok(JSON.stringify(obj));\r\n  } catch (error) {\r\n    return $err({ msg: 'Utility: Stringify error', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\n/**\r\n * Stringify an object.\r\n *\r\n * @param obj - The object to stringify.\r\n * @returns An JSON string.\r\n * @throws {Error} If the object cannot be stringified.\r\n */\r\nexport function stringifyObj<T extends object = Record<string, unknown>>(obj: T): string {\r\n  const { result, error } = $stringifyObj(obj);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Stringify an object.\r\n *\r\n * @param obj - The object to stringify.\r\n * @returns A Result containing the JSON string or an error.\r\n */\r\nexport function tryStringifyObj<T extends object = Record<string, unknown>>(obj: T): Result<string> {\r\n  return $stringifyObj(obj);\r\n}\r\n\r\nexport function $parseToObj<T extends object = Record<string, unknown>>(str: string): Result<{ result: T }> {\r\n  try {\r\n    if (!$isStr(str)) return $err({ msg: 'Utility: Invalid input', desc: 'Input is not a valid string' });\r\n    const obj = JSON.parse(str);\r\n\r\n    if (!$isObj(obj)) return $err({ msg: 'Utility: Invalid object format', desc: 'Parsed data is not a plain object' });\r\n    return $ok({ result: obj as T });\r\n  } catch (error) {\r\n    return $err({ msg: 'Utility: Invalid format', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\n/**\r\n * Parse a string to an object.\r\n *\r\n * @param str - The JSON string to parse.\r\n * @returns A Result containing the parsed object or an error.\r\n */\r\nexport function tryParseToObj<T extends object = Record<string, unknown>>(str: string): Result<{ result: T }> {\r\n  return $parseToObj<T>(str);\r\n}\r\n\r\n/**\r\n * Parse a string to an object.\r\n *\r\n * @param str - The JSON string to parse.\r\n * @returns A parsed object.\r\n * @throws {Error} If the string cannot be parsed or is not a valid object.\r\n */\r\nexport function parseToObj<T extends object = Record<string, unknown>>(str: string): T {\r\n  const { result, error } = $parseToObj<T>(str);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n"]}

package/dist/{chunk-SRGSVNQ2.js → chunk-SUGN4VDZ.js}

@@ -1,10 +1,10 @@
-import { __export, $fmtResultErr, $ok, $err, $fmtError, $isStr, ENCRYPTION_ALGORITHMS, DIGEST_ALGORITHMS, isSecretKey, matchPattern, $stringifyObj, $parseToObj, PASSWORD_HASHING, ENCODING_FORMATS } from './chunk-6HNTSQAP.js';
+import { __export, $fmtResultErr, $ok, $err, $fmtError, $isStr, ENCRYPTION_ALGORITHMS, DIGEST_ALGORITHMS, ENCODINGS, isSecretKey, matchPattern, $stringifyObj, $parseToObj } from './chunk-LOJKJJX5.js';
 
 // src/web/kit.ts
 var kit_exports = {};
 __export(kit_exports, {
   convertBytesToStr: () => convertBytesToStr,
-  convertFormat: () => convertFormat,
+  convertEncoding: () => convertEncoding,
   convertStrToBytes: () => convertStrToBytes,
   createSecretKey: () => createSecretKey,
   decrypt: () => decrypt,
@@ -15,7 +15,7 @@ __export(kit_exports, {
   hash: () => hash,
   hashPassword: () => hashPassword,
   tryConvertBytesToStr: () => tryConvertBytesToStr,
-  tryConvertFormat: () => tryConvertFormat,
+  tryConvertEncoding: () => tryConvertEncoding,
   tryConvertStrToBytes: () => tryConvertStrToBytes,
   tryCreateSecretKey: () => tryCreateSecretKey,
   tryDecrypt: () => tryDecrypt,
@@ -31,57 +31,57 @@ __export(kit_exports, {
 // src/web/web-encode.ts
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
-function $convertStrToBytes(data, format = "utf8") {
+function $convertStrToBytes(data, inputEncoding = "utf8") {
   if (!$isStr(data)) {
     return $err({
       msg: "Crypto Web API - String to Bytes: Empty data",
       desc: "Data must be a non-empty string"
     });
   }
-  if (!ENCODING_FORMATS.includes(format)) {
+  if (!ENCODINGS.includes(inputEncoding)) {
     return $err({
-      msg: `Crypto Web API - String to Bytes: Unsupported encode format: ${format}`,
+      msg: `Crypto Web API - String to Bytes: Unsupported encoding: ${inputEncoding}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
   try {
-    const bytes = strToBytes[format](data);
+    const bytes = strToBytes[inputEncoding](data);
     return $ok({ result: bytes });
   } catch (error) {
     return $err({ msg: "Crypto Web API - String to Bytes: Failed to convert data", desc: $fmtError(error) });
   }
 }
-function $convertBytesToStr(data, format = "utf8") {
+function $convertBytesToStr(data, outputEncoding = "utf8") {
   if (!(data instanceof ArrayBuffer || data instanceof Uint8Array)) {
     return $err({
       msg: "Crypto Web API - Bytes to String: Invalid data type",
       desc: "Data must be an ArrayBuffer or Uint8Array"
     });
   }
-  if (!ENCODING_FORMATS.includes(format)) {
+  if (!ENCODINGS.includes(outputEncoding)) {
     return $err({
-      msg: `Crypto Web API - Bytes to String: Unsupported format: ${format}`,
+      msg: `Crypto Web API - Bytes to String: Unsupported encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
   try {
     const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-    const str = bytesToStr[format](bytes);
+    const str = bytesToStr[outputEncoding](bytes);
     return $ok(str);
   } catch (error) {
     return $err({ msg: "Crypto Web API - Bytes to String: Failed to convert data", desc: $fmtError(error) });
   }
 }
-function $convertFormat(data, from, to) {
+function $convertEncoding(data, from, to) {
   if (!$isStr(data)) {
     return $err({
       msg: "Crypto Web API - Convert Format: Empty data",
       desc: "Data must be a non-empty string"
     });
   }
-  if (!ENCODING_FORMATS.includes(from) || !ENCODING_FORMATS.includes(to)) {
+  if (!ENCODINGS.includes(from) || !ENCODINGS.includes(to)) {
     return $err({
-      msg: `Crypto Web API - Convert Format: Unsupported format: from ${from} to ${to}`,
+      msg: `Crypto Web API - Convert Format: Unsupported encoding: from ${from} to ${to}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
@@ -224,30 +224,34 @@ async function $createSecretKey(secret, options = {}) {
     });
   }
 }
-async function $encrypt(data, secretKey) {
+async function $encrypt(data, secretKey, options = {}) {
   if (!$isStr(data)) {
     return $err({
       msg: "Crypto Web API - Encryption: Empty data for encryption",
       desc: "Data must be a non-empty string"
     });
   }
+  const inputEncoding = options.inputEncoding ?? "utf8";
+  const outputEncoding = options.outputEncoding ?? "base64url";
+  if (!ENCODINGS.includes(inputEncoding) || !ENCODINGS.includes(outputEncoding)) {
+    return $err({
+      msg: `Crypto Web API - Encryption: Unsupported encoding: input ${inputEncoding} or output ${outputEncoding}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
   if (!isSecretKey(secretKey, "web")) {
     return $err({
       msg: "Crypto Web API - Encryption: Invalid Secret Key",
       desc: "Expected a Web SecretKey"
     });
   }
-  const bytes = $convertStrToBytes(data, "utf8");
-  if (bytes.error) return $err(bytes.error);
+  const { result, error } = $convertStrToBytes(data, inputEncoding);
+  if (error) return $err(error);
   try {
     const iv = crypto.getRandomValues(new Uint8Array(secretKey.algo.ivLength));
-    const cipherWithTag = await crypto.subtle.encrypt(
-      { name: secretKey.algo.web, iv },
-      secretKey.key,
-      bytes.result
-    );
-    const ivStr = $convertBytesToStr(iv, "base64url");
-    const cipherStr = $convertBytesToStr(cipherWithTag, "base64url");
+    const cipherWithTag = await crypto.subtle.encrypt({ name: secretKey.algo.web, iv }, secretKey.key, result);
+    const ivStr = $convertBytesToStr(iv, outputEncoding);
+    const cipherStr = $convertBytesToStr(cipherWithTag, outputEncoding);
     if (ivStr.error || cipherStr.error) {
       return $err({
         msg: "Crypto Web API - Encryption: Failed to convert IV or encrypted data",
@@ -255,17 +259,25 @@ async function $encrypt(data, secretKey) {
       });
     }
     return $ok(`${ivStr.result}.${cipherStr.result}.`);
-  } catch (error) {
-    return $err({ msg: "Crypto Web API - Encryption: Failed to encrypt data", desc: $fmtError(error) });
+  } catch (error2) {
+    return $err({ msg: "Crypto Web API - Encryption: Failed to encrypt data", desc: $fmtError(error2) });
   }
 }
-async function $decrypt(encrypted, secretKey) {
+async function $decrypt(encrypted, secretKey, options = {}) {
   if (matchPattern(encrypted, "web") === false) {
     return $err({
       msg: "Crypto Web API - Decryption: Invalid encrypted data format",
       desc: 'Encrypted data must be in the format "iv.cipherWithTag."'
     });
   }
+  const inputEncoding = options.inputEncoding ?? "base64url";
+  const outputEncoding = options.outputEncoding ?? "utf8";
+  if (!ENCODINGS.includes(inputEncoding) || !ENCODINGS.includes(outputEncoding)) {
+    return $err({
+      msg: `Crypto Web API - Decryption: Unsupported encoding: input ${inputEncoding} or output ${outputEncoding}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
   const [iv, encryptedWithTag] = encrypted.split(".", 3);
   if (!$isStr(iv) || !$isStr(encryptedWithTag)) {
     return $err({
@@ -279,8 +291,8 @@ async function $decrypt(encrypted, secretKey) {
       desc: "Expected a Web SecretKey"
     });
   }
-  const ivBytes = $convertStrToBytes(iv, "base64url");
-  const cipherWithTagBytes = $convertStrToBytes(encryptedWithTag, "base64url");
+  const ivBytes = $convertStrToBytes(iv, inputEncoding);
+  const cipherWithTagBytes = $convertStrToBytes(encryptedWithTag, inputEncoding);
   if (ivBytes.error || cipherWithTagBytes.error) {
     return $err({
       msg: "Crypto Web API - Decryption: Failed to convert IV or encrypted data",
@@ -298,38 +310,90 @@ async function $decrypt(encrypted, secretKey) {
     return $err({ msg: "Crypto Web API - Decryption: Failed to decrypt data", desc: $fmtError(error) });
   }
 }
-async function $encryptObj(data, secretKey) {
+async function $encryptObj(data, secretKey, options = {}) {
   const { result, error } = $stringifyObj(data);
   if (error) return $err(error);
-  return await $encrypt(result, secretKey);
+  return await $encrypt(result, secretKey, options);
 }
-async function $decryptObj(encrypted, secretKey) {
-  const { result, error } = await $decrypt(encrypted, secretKey);
+async function $decryptObj(encrypted, secretKey, options = {}) {
+  const { result, error } = await $decrypt(encrypted, secretKey, options);
   if (error) return $err(error);
   return $parseToObj(result);
 }
-async function $hash(data) {
-  if (!$isStr(data, 0)) {
+async function $hash(data, options = {}) {
+  if (!$isStr(data)) {
     return $err({ msg: "Crypto Web API - Hashing: Empty data for hashing", desc: "Data must be a non-empty string" });
   }
-  const bytes = $convertStrToBytes(data, "utf8");
-  if (bytes.error) return $err(bytes.error);
+  const inputEncoding = options.inputEncoding ?? "utf8";
+  const outputEncoding = options.outputEncoding ?? "base64url";
+  if (!ENCODINGS.includes(inputEncoding) || !ENCODINGS.includes(outputEncoding)) {
+    return $err({
+      msg: `Crypto Web API - Hashing: Unsupported input encoding: ${inputEncoding} or output encoding: ${outputEncoding}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
+  const digest = options.digest ?? "sha256";
+  if (!(digest in DIGEST_ALGORITHMS)) {
+    return $err({
+      msg: `Crypto Web API - Hashing: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(DIGEST_ALGORITHMS).join(", ")}`
+    });
+  }
+  const digestAlgo = DIGEST_ALGORITHMS[digest];
+  const { result, error } = $convertStrToBytes(data, inputEncoding);
+  if (error) return $err(error);
   try {
-    const hashed = await crypto.subtle.digest(DIGEST_ALGORITHMS.sha256.web, bytes.result);
-    return $convertBytesToStr(hashed, "base64url");
-  } catch (error) {
-    return $err({ msg: "Crypto Web API - Hashing: Failed to hash data", desc: $fmtError(error) });
+    const hashed = await crypto.subtle.digest(digestAlgo.web, result);
+    return $convertBytesToStr(hashed, outputEncoding);
+  } catch (error2) {
+    return $err({ msg: "Crypto Web API - Hashing: Failed to hash data", desc: $fmtError(error2) });
   }
 }
-async function $hashPassword(password) {
+async function $hashPassword(password, options = {}) {
   if (!$isStr(password)) {
     return $err({
       msg: "Crypto Web API - Password Hashing: Empty password",
       desc: "Password must be a non-empty string"
     });
   }
+  const digest = options.digest ?? "sha512";
+  if (!(digest in DIGEST_ALGORITHMS)) {
+    return $err({
+      msg: `Crypto Web API - Password Hashing: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(DIGEST_ALGORITHMS).join(", ")}`
+    });
+  }
+  const digestAlgo = DIGEST_ALGORITHMS[digest];
+  const outputEncoding = options.outputEncoding ?? "base64url";
+  if (!ENCODINGS.includes(outputEncoding)) {
+    return $err({
+      msg: `Crypto Web API - Password Hashing: Unsupported output encoding: ${outputEncoding}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
+  const saltLength = options.saltLength ?? 16;
+  if (typeof saltLength !== "number" || saltLength < 8) {
+    return $err({
+      msg: "Crypto Web API - 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 $err({
+      msg: "Crypto Web API - 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 $err({
+      msg: "Crypto Web API - Password Hashing: Weak key length",
+      desc: "Key length must be a number and at least 16 bytes (recommended 64)"
+    });
+  }
   try {
-    const salt = crypto.getRandomValues(new Uint8Array(16));
+    const salt = crypto.getRandomValues(new Uint8Array(saltLength));
     const baseKey = await crypto.subtle.importKey(
       "raw",
       textEncoder.encode(password.normalize("NFKC")),
@@ -338,25 +402,34 @@ async function $hashPassword(password) {
       ["deriveBits"]
     );
     const bits = await crypto.subtle.deriveBits(
-      { name: "PBKDF2", salt, iterations: PASSWORD_HASHING.pbkdf2.iterations, hash: DIGEST_ALGORITHMS.sha512.web },
+      { name: "PBKDF2", salt, iterations, hash: digestAlgo.web },
       baseKey,
-      PASSWORD_HASHING.pbkdf2.keyLength * 8
+      keyLength * 8
     );
-    const saltStr = $convertBytesToStr(salt, "base64url");
+    const saltStr = $convertBytesToStr(salt, outputEncoding);
     if (saltStr.error) return $err(saltStr.error);
-    const hashedPasswordStr = $convertBytesToStr(bits, "base64url");
+    const hashedPasswordStr = $convertBytesToStr(bits, outputEncoding);
     if (hashedPasswordStr.error) return $err(hashedPasswordStr.error);
     return $ok({ hash: hashedPasswordStr.result, salt: saltStr.result });
   } catch (error) {
     return $err({ msg: "Crypto Web API - Password Hashing: Failed to hash password", desc: $fmtError(error) });
   }
 }
-async function $verifyPassword(password, hashedPassword, salt) {
+async function $verifyPassword(password, hashedPassword, salt, options = {}) {
   if (!$isStr(password) || !$isStr(hashedPassword) || !$isStr(salt)) return false;
+  const digest = options.digest ?? "sha512";
+  if (!(digest in DIGEST_ALGORITHMS)) return false;
+  const digestAlgo = DIGEST_ALGORITHMS[digest];
+  const inputEncoding = options.inputEncoding ?? "base64url";
+  if (!ENCODINGS.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, "base64url");
   if (saltBytes.error) return false;
-  const { result: hashedPasswordBytes, error: hashedPasswordError } = $convertStrToBytes(hashedPassword, "base64url");
-  if (hashedPasswordError) return false;
+  const hashedPasswordBytes = $convertStrToBytes(hashedPassword, "base64url");
+  if (hashedPasswordBytes.error) return false;
   try {
     const baseKey = await crypto.subtle.importKey(
       "raw",
@@ -370,17 +443,17 @@ async function $verifyPassword(password, hashedPassword, salt) {
         {
           name: "PBKDF2",
           salt: saltBytes.result,
-          iterations: PASSWORD_HASHING.pbkdf2.iterations,
-          hash: DIGEST_ALGORITHMS.sha512.web
+          iterations,
+          hash: digestAlgo.web
         },
         baseKey,
-        PASSWORD_HASHING.pbkdf2.keyLength * 8
+        keyLength * 8
       )
     );
-    if (bits.length !== hashedPasswordBytes.length) return false;
+    if (bits.length !== hashedPasswordBytes.result.length) return false;
     let isMatch = true;
     for (let i = 0; i < bits.length; i++) {
-      if (bits[i] !== hashedPasswordBytes[i]) isMatch = false;
+      if (bits[i] !== hashedPasswordBytes.result[i]) isMatch = false;
     }
     return isMatch;
   } catch {
@@ -405,82 +478,82 @@ async function createSecretKey(secret, options = {}) {
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-async function tryEncrypt(data, secretKey) {
-  return await $encrypt(data, secretKey);
+async function tryEncrypt(data, secretKey, options = {}) {
+  return await $encrypt(data, secretKey, options);
 }
-async function encrypt(data, secretKey) {
+async function encrypt(data, secretKey, options = {}) {
   const { result, error } = await $encrypt(data, secretKey);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-async function tryDecrypt(encrypted, secretKey) {
-  return await $decrypt(encrypted, secretKey);
+async function tryDecrypt(encrypted, secretKey, options = {}) {
+  return await $decrypt(encrypted, secretKey, options);
 }
-async function decrypt(encrypted, secretKey) {
-  const { result, error } = await $decrypt(encrypted, secretKey);
+async function decrypt(encrypted, secretKey, options = {}) {
+  const { result, error } = await $decrypt(encrypted, secretKey, options);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-async function tryEncryptObj(data, secretKey) {
-  return await $encryptObj(data, secretKey);
+async function tryEncryptObj(data, secretKey, options = {}) {
+  return await $encryptObj(data, secretKey, options);
 }
-async function encryptObj(data, secretKey) {
-  const { result, error } = await $encryptObj(data, secretKey);
+async function encryptObj(data, secretKey, options = {}) {
+  const { result, error } = await $encryptObj(data, secretKey, options);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-async function tryDecryptObj(encrypted, secretKey) {
-  return await $decryptObj(encrypted, secretKey);
+async function tryDecryptObj(encrypted, secretKey, options = {}) {
+  return await $decryptObj(encrypted, secretKey, options);
 }
-async function decryptObj(encrypted, secretKey) {
-  const { result, error } = await $decryptObj(encrypted, secretKey);
+async function decryptObj(encrypted, secretKey, options = {}) {
+  const { result, error } = await $decryptObj(encrypted, secretKey, options);
   if (error) throw new Error($fmtResultErr(error));
-  return { result };
+  return result;
 }
-async function tryHash(data) {
-  return await $hash(data);
+async function tryHash(data, options = {}) {
+  return await $hash(data, options);
 }
-async function hash(data) {
-  const { result, error } = await $hash(data);
+async function hash(data, options = {}) {
+  const { result, error } = await $hash(data, options);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-async function tryHashPassword(password) {
-  return await $hashPassword(password);
+async function tryHashPassword(password, options = {}) {
+  return await $hashPassword(password, options);
 }
-async function hashPassword(password) {
-  const { hash: hash2, salt, error } = await $hashPassword(password);
+async function hashPassword(password, options = {}) {
+  const { hash: hash2, salt, error } = await $hashPassword(password, options);
   if (error) throw new Error($fmtResultErr(error));
   return { hash: hash2, salt };
 }
-async function verifyPassword(password, hashedPassword, salt) {
-  return await $verifyPassword(password, hashedPassword, salt);
+async function verifyPassword(password, hashedPassword, salt, options = {}) {
+  return await $verifyPassword(password, hashedPassword, salt, options);
 }
-function tryConvertStrToBytes(data, format = "utf8") {
-  return $convertStrToBytes(data, format);
+function tryConvertStrToBytes(data, inputEncoding = "utf8") {
+  return $convertStrToBytes(data, inputEncoding);
 }
-function convertStrToBytes(data, format = "utf8") {
-  const { result, error } = $convertStrToBytes(data, format);
+function convertStrToBytes(data, inputEncoding = "utf8") {
+  const { result, error } = $convertStrToBytes(data, inputEncoding);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-function tryConvertBytesToStr(data, format = "utf8") {
-  return $convertBytesToStr(data, format);
+function tryConvertBytesToStr(data, outputEncoding = "utf8") {
+  return $convertBytesToStr(data, outputEncoding);
 }
-function convertBytesToStr(data, format = "utf8") {
-  const { result, error } = $convertBytesToStr(data, format);
+function convertBytesToStr(data, outputEncoding = "utf8") {
+  const { result, error } = $convertBytesToStr(data, outputEncoding);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
-function tryConvertFormat(data, from, to) {
-  return $convertFormat(data, from, to);
+function tryConvertEncoding(data, from, to) {
+  return $convertEncoding(data, from, to);
 }
-function convertFormat(data, from, to) {
-  const { result, error } = $convertFormat(data, from, to);
+function convertEncoding(data, from, to) {
+  const { result, error } = $convertEncoding(data, from, to);
   if (error) throw new Error($fmtResultErr(error));
   return result;
 }
 
-export { convertBytesToStr, convertFormat, convertStrToBytes, createSecretKey, decrypt, decryptObj, encrypt, encryptObj, generateUuid, hash, hashPassword, kit_exports, tryConvertBytesToStr, tryConvertFormat, tryConvertStrToBytes, tryCreateSecretKey, tryDecrypt, tryDecryptObj, tryEncrypt, tryEncryptObj, tryGenerateUuid, tryHash, tryHashPassword, verifyPassword };
-//# sourceMappingURL=chunk-SRGSVNQ2.js.map
-//# sourceMappingURL=chunk-SRGSVNQ2.js.map
+export { convertBytesToStr, convertEncoding, convertStrToBytes, createSecretKey, decrypt, decryptObj, encrypt, encryptObj, generateUuid, hash, hashPassword, kit_exports, tryConvertBytesToStr, tryConvertEncoding, tryConvertStrToBytes, tryCreateSecretKey, tryDecrypt, tryDecryptObj, tryEncrypt, tryEncryptObj, tryGenerateUuid, tryHash, tryHashPassword, verifyPassword };
+//# sourceMappingURL=chunk-SUGN4VDZ.js.map
+//# sourceMappingURL=chunk-SUGN4VDZ.js.map