cipher-kit 2.1.1 → 2.1.2

package/dist/{chunk-56PVVFVM.cjs → chunk-ZNM5M6RD.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkX4CS7UXE_cjs = require('./chunk-X4CS7UXE.cjs');
+var chunkHTRGOBZF_cjs = require('./chunk-HTRGOBZF.cjs');
 var buffer = require('buffer');
 var nodeCrypto = require('crypto');
 
@@ -10,7 +10,7 @@ var nodeCrypto__default = /*#__PURE__*/_interopDefault(nodeCrypto);
 
 // src/node/kit.ts
 var kit_exports = {};
-chunkX4CS7UXE_cjs.__export(kit_exports, {
+chunkHTRGOBZF_cjs.__export(kit_exports, {
   convertBytesToStr: () => convertBytesToStr,
   convertEncoding: () => convertEncoding,
   convertStrToBytes: () => convertStrToBytes,
@@ -22,7 +22,6 @@ chunkX4CS7UXE_cjs.__export(kit_exports, {
   generateUuid: () => generateUuid,
   hash: () => hash,
   hashPassword: () => hashPassword,
-  isNodeSecretKey: () => isNodeSecretKey,
   tryConvertBytesToStr: () => tryConvertBytesToStr,
   tryConvertEncoding: () => tryConvertEncoding,
   tryConvertStrToBytes: () => tryConvertStrToBytes,
@@ -37,112 +36,112 @@ chunkX4CS7UXE_cjs.__export(kit_exports, {
   verifyPassword: () => verifyPassword
 });
 function $convertStrToBytes(data, inputEncoding = "utf8") {
-  if (!chunkX4CS7UXE_cjs.$isStr(data)) {
-    return chunkX4CS7UXE_cjs.$err({
+  if (!chunkHTRGOBZF_cjs.$isStr(data)) {
+    return chunkHTRGOBZF_cjs.$err({
       msg: "Crypto NodeJS API - String to Bytes: Empty data",
       desc: "Data must be a non-empty string"
     });
   }
-  if (!chunkX4CS7UXE_cjs.ENCODING.includes(inputEncoding)) {
-    return chunkX4CS7UXE_cjs.$err({
+  if (!chunkHTRGOBZF_cjs.ENCODING.includes(inputEncoding)) {
+    return chunkHTRGOBZF_cjs.$err({
       msg: `Crypto NodeJS API - String to Bytes: Unsupported encoding: ${inputEncoding}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
   try {
-    return chunkX4CS7UXE_cjs.$ok({ result: buffer.Buffer.from(data, inputEncoding) });
+    return chunkHTRGOBZF_cjs.$ok({ result: buffer.Buffer.from(data, inputEncoding) });
   } catch (error) {
-    return chunkX4CS7UXE_cjs.$err({ msg: "Crypto NodeJS API - String to Bytes: Failed to convert data", desc: chunkX4CS7UXE_cjs.$fmtError(error) });
+    return chunkHTRGOBZF_cjs.$err({ msg: "Crypto NodeJS API - String to Bytes: Failed to convert data", desc: chunkHTRGOBZF_cjs.$fmtError(error) });
   }
 }
 function $convertBytesToStr(data, outputEncoding = "utf8") {
   if (!(data instanceof buffer.Buffer)) {
-    return chunkX4CS7UXE_cjs.$err({
+    return chunkHTRGOBZF_cjs.$err({
       msg: "Crypto NodeJS API - Bytes to String: Invalid data type",
       desc: "Data must be a Buffer"
     });
   }
-  if (!chunkX4CS7UXE_cjs.ENCODING.includes(outputEncoding)) {
-    return chunkX4CS7UXE_cjs.$err({
+  if (!chunkHTRGOBZF_cjs.ENCODING.includes(outputEncoding)) {
+    return chunkHTRGOBZF_cjs.$err({
       msg: `Crypto NodeJS API - Bytes to String: Unsupported encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, hex, utf8, or latin1"
     });
   }
   try {
-    return chunkX4CS7UXE_cjs.$ok(buffer.Buffer.from(data).toString(outputEncoding));
+    return chunkHTRGOBZF_cjs.$ok(buffer.Buffer.from(data).toString(outputEncoding));
   } catch (error) {
-    return chunkX4CS7UXE_cjs.$err({ msg: "Crypto NodeJS API - Bytes to String: Failed to convert data", desc: chunkX4CS7UXE_cjs.$fmtError(error) });
+    return chunkHTRGOBZF_cjs.$err({ msg: "Crypto NodeJS API - Bytes to String: Failed to convert data", desc: chunkHTRGOBZF_cjs.$fmtError(error) });
   }
 }
 function $convertEncoding(data, from, to) {
-  if (!chunkX4CS7UXE_cjs.$isStr(data)) {
-    return chunkX4CS7UXE_cjs.$err({
+  if (!chunkHTRGOBZF_cjs.$isStr(data)) {
+    return chunkHTRGOBZF_cjs.$err({
       msg: "Crypto NodeJS API - Convert Format: Empty data",
       desc: "Data must be a non-empty string"
     });
   }
-  if (!chunkX4CS7UXE_cjs.ENCODING.includes(from) || !chunkX4CS7UXE_cjs.ENCODING.includes(to)) {
-    return chunkX4CS7UXE_cjs.$err({
+  if (!chunkHTRGOBZF_cjs.ENCODING.includes(from) || !chunkHTRGOBZF_cjs.ENCODING.includes(to)) {
+    return chunkHTRGOBZF_cjs.$err({
       msg: `Crypto NodeJS 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 chunkX4CS7UXE_cjs.$err({ msg: bytes.error.message, desc: bytes.error.description });
+  if (bytes.error) return chunkHTRGOBZF_cjs.$err({ msg: bytes.error.message, desc: bytes.error.description });
   const str = $convertBytesToStr(bytes.result, to);
-  if (str.error) return chunkX4CS7UXE_cjs.$err({ msg: str.error.message, desc: str.error.description });
-  return chunkX4CS7UXE_cjs.$ok({ result: str.result });
+  if (str.error) return chunkHTRGOBZF_cjs.$err({ msg: str.error.message, desc: str.error.description });
+  return chunkHTRGOBZF_cjs.$ok({ result: str.result });
 }
 function $generateUuid() {
   try {
-    return chunkX4CS7UXE_cjs.$ok(nodeCrypto__default.default.randomUUID());
+    return chunkHTRGOBZF_cjs.$ok(nodeCrypto__default.default.randomUUID());
   } catch (error) {
-    return chunkX4CS7UXE_cjs.$err({ msg: `${chunkX4CS7UXE_cjs.title("node", "UUID Generation")}: Failed to generate UUID`, desc: chunkX4CS7UXE_cjs.$fmtError(error) });
+    return chunkHTRGOBZF_cjs.$err({ msg: `${chunkHTRGOBZF_cjs.title("node", "UUID Generation")}: Failed to generate UUID`, desc: chunkHTRGOBZF_cjs.$fmtError(error) });
   }
 }
 function $createSecretKey(secret, options) {
-  if (!chunkX4CS7UXE_cjs.$isStr(secret, 8)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Empty Secret`,
+  if (!chunkHTRGOBZF_cjs.$isStr(secret, 8)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Empty Secret`,
       desc: "Secret must be a non-empty string with at least 8 characters"
     });
   }
-  if (!chunkX4CS7UXE_cjs.$isPlainObj(options)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Invalid options`,
+  if (!chunkHTRGOBZF_cjs.$isPlainObj(options)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Invalid options`,
       desc: "Options must be an object"
     });
   }
   const algorithm = options.algorithm ?? "aes256gcm";
-  if (!(algorithm in chunkX4CS7UXE_cjs.ENCRYPTION_ALGORITHMS)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Unsupported algorithm: ${algorithm}`,
-      desc: `Supported algorithms are: ${Object.keys(chunkX4CS7UXE_cjs.ENCRYPTION_ALGORITHMS).join(", ")}`
+  if (!(algorithm in chunkHTRGOBZF_cjs.ENCRYPTION_ALGORITHMS)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Unsupported algorithm: ${algorithm}`,
+      desc: `Supported algorithms are: ${Object.keys(chunkHTRGOBZF_cjs.ENCRYPTION_ALGORITHMS).join(", ")}`
     });
   }
   const digest = options.digest ?? "sha256";
-  if (!(digest in chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Unsupported digest: ${digest}`,
-      desc: `Supported digests are: ${Object.keys(chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS).join(", ")}`
+  if (!(digest in chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS).join(", ")}`
     });
   }
   const salt = options.salt ?? "cipher-kit-salt";
-  if (!chunkX4CS7UXE_cjs.$isStr(salt, 8)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Weak salt`,
+  if (!chunkHTRGOBZF_cjs.$isStr(salt, 8)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Weak salt`,
       desc: "Salt must be a non-empty string with at least 8 characters"
     });
   }
   const info = options.info ?? "cipher-kit";
-  if (!chunkX4CS7UXE_cjs.$isStr(info)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Invalid info`,
+  if (!chunkHTRGOBZF_cjs.$isStr(info)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Invalid info`,
       desc: "Info must be a non-empty string"
     });
   }
-  const encryptAlgo = chunkX4CS7UXE_cjs.ENCRYPTION_ALGORITHMS[algorithm];
-  const digestAlgo = chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS[digest];
+  const encryptAlgo = chunkHTRGOBZF_cjs.ENCRYPTION_ALGORITHMS[algorithm];
+  const digestAlgo = chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS[digest];
   try {
     const derivedKey = nodeCrypto__default.default.hkdfSync(
       digestAlgo.node,
@@ -158,40 +157,40 @@ function $createSecretKey(secret, options) {
       algorithm,
       key
     });
-    return chunkX4CS7UXE_cjs.$ok({ result: secretKey });
+    return chunkHTRGOBZF_cjs.$ok({ result: secretKey });
   } catch (error) {
-    return chunkX4CS7UXE_cjs.$err({ msg: `${chunkX4CS7UXE_cjs.title("node", "Key Generation")}: Failed to create secret key`, desc: chunkX4CS7UXE_cjs.$fmtError(error) });
+    return chunkHTRGOBZF_cjs.$err({ msg: `${chunkHTRGOBZF_cjs.title("node", "Key Generation")}: Failed to create secret key`, desc: chunkHTRGOBZF_cjs.$fmtError(error) });
   }
 }
 function $encrypt(data, secretKey, options) {
-  if (!chunkX4CS7UXE_cjs.$isStr(data)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Encryption")}: Empty data for encryption`,
+  if (!chunkHTRGOBZF_cjs.$isStr(data)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Encryption")}: Empty data for encryption`,
       desc: "Data must be a non-empty string"
     });
   }
-  if (!chunkX4CS7UXE_cjs.$isPlainObj(options)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Encryption")}: Invalid options`,
+  if (!chunkHTRGOBZF_cjs.$isPlainObj(options)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Encryption")}: Invalid options`,
       desc: "Options must be an object"
     });
   }
   const outputEncoding = options.outputEncoding ?? "base64url";
-  if (!chunkX4CS7UXE_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Encryption")}: Unsupported output encoding: ${outputEncoding}`,
+  if (!chunkHTRGOBZF_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Encryption")}: Unsupported output encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
-  const injectedKey = chunkX4CS7UXE_cjs.$isSecretKey(secretKey, "node");
+  const injectedKey = chunkHTRGOBZF_cjs.$isSecretKey(secretKey, "node");
   if (!injectedKey) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Encryption")}: Invalid Secret Key`,
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Encryption")}: Invalid Secret Key`,
       desc: "Expected a Node SecretKey"
     });
   }
   const { result, error } = $convertStrToBytes(data, "utf8");
-  if (error) return chunkX4CS7UXE_cjs.$err(error);
+  if (error) return chunkHTRGOBZF_cjs.$err(error);
   try {
     const iv = nodeCrypto__default.default.randomBytes(injectedKey.injected.ivLength);
     const cipher = nodeCrypto__default.default.createCipheriv(injectedKey.injected.node, injectedKey.key, iv);
@@ -201,46 +200,46 @@ function $encrypt(data, secretKey, options) {
     const cipherStr = $convertBytesToStr(encrypted, outputEncoding);
     const tagStr = $convertBytesToStr(tag, outputEncoding);
     if (ivStr.error || cipherStr.error || tagStr.error) {
-      return chunkX4CS7UXE_cjs.$err({
+      return chunkHTRGOBZF_cjs.$err({
         msg: "Crypto NodeJS API - Encryption: Failed to convert IV or encrypted data or tag",
-        desc: `Conversion error: ${chunkX4CS7UXE_cjs.$fmtResultErr(ivStr.error || cipherStr.error || tagStr.error)}`
+        desc: `Conversion error: ${chunkHTRGOBZF_cjs.$fmtResultErr(ivStr.error || cipherStr.error || tagStr.error)}`
       });
     }
-    return chunkX4CS7UXE_cjs.$ok(`${ivStr.result}.${cipherStr.result}.${tagStr.result}.`);
+    return chunkHTRGOBZF_cjs.$ok(`${ivStr.result}.${cipherStr.result}.${tagStr.result}.`);
   } catch (error2) {
-    return chunkX4CS7UXE_cjs.$err({ msg: `${chunkX4CS7UXE_cjs.title("node", "Encryption")}: Failed to encrypt data`, desc: chunkX4CS7UXE_cjs.$fmtError(error2) });
+    return chunkHTRGOBZF_cjs.$err({ msg: `${chunkHTRGOBZF_cjs.title("node", "Encryption")}: Failed to encrypt data`, desc: chunkHTRGOBZF_cjs.$fmtError(error2) });
   }
 }
 function $decrypt(encrypted, secretKey, options) {
-  if (!chunkX4CS7UXE_cjs.matchEncryptedPattern(encrypted, "node")) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Decryption")}: Invalid encrypted data format`,
+  if (!chunkHTRGOBZF_cjs.matchEncryptedPattern(encrypted, "node")) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Decryption")}: Invalid encrypted data format`,
       desc: 'Encrypted data must be in the format "iv.cipher.tag."'
     });
   }
-  if (!chunkX4CS7UXE_cjs.$isPlainObj(options)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Decryption")}: Invalid options`,
+  if (!chunkHTRGOBZF_cjs.$isPlainObj(options)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Decryption")}: Invalid options`,
       desc: "Options must be an object"
     });
   }
   const inputEncoding = options.inputEncoding ?? "base64url";
-  if (!chunkX4CS7UXE_cjs.CIPHER_ENCODING.includes(inputEncoding)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Decryption")}: Unsupported input encoding: ${inputEncoding}`,
+  if (!chunkHTRGOBZF_cjs.CIPHER_ENCODING.includes(inputEncoding)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Decryption")}: Unsupported input encoding: ${inputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
   const [iv, cipher, tag] = encrypted.split(".", 4);
-  if (!chunkX4CS7UXE_cjs.$isStr(iv) || !chunkX4CS7UXE_cjs.$isStr(cipher) || !chunkX4CS7UXE_cjs.$isStr(tag)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Decryption")}: Invalid encrypted data`,
+  if (!chunkHTRGOBZF_cjs.$isStr(iv) || !chunkHTRGOBZF_cjs.$isStr(cipher) || !chunkHTRGOBZF_cjs.$isStr(tag)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Decryption")}: Invalid encrypted data`,
       desc: "Encrypted data must contain valid IV, encrypted data, and tag components"
     });
   }
-  const injectedKey = chunkX4CS7UXE_cjs.$isSecretKey(secretKey, "node");
+  const injectedKey = chunkHTRGOBZF_cjs.$isSecretKey(secretKey, "node");
   if (!injectedKey) {
-    return chunkX4CS7UXE_cjs.$err({
+    return chunkHTRGOBZF_cjs.$err({
       msg: "Crypto NodeJS API - Decryption: Invalid Secret Key",
       desc: "Expected a Node SecretKey"
     });
@@ -249,9 +248,9 @@ function $decrypt(encrypted, secretKey, options) {
   const cipherBytes = $convertStrToBytes(cipher, inputEncoding);
   const tagBytes = $convertStrToBytes(tag, inputEncoding);
   if (ivBytes.error || cipherBytes.error || tagBytes.error) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Decryption")}: Failed to convert IV or encrypted data or tag`,
-      desc: `Conversion error: ${chunkX4CS7UXE_cjs.$fmtResultErr(ivBytes.error || cipherBytes.error || tagBytes.error)}`
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Decryption")}: Failed to convert IV or encrypted data or tag`,
+      desc: `Conversion error: ${chunkHTRGOBZF_cjs.$fmtResultErr(ivBytes.error || cipherBytes.error || tagBytes.error)}`
     });
   }
   try {
@@ -260,122 +259,122 @@ function $decrypt(encrypted, secretKey, options) {
     const decrypted = buffer.Buffer.concat([decipher.update(cipherBytes.result), decipher.final()]);
     return $convertBytesToStr(decrypted, "utf8");
   } catch (error) {
-    return chunkX4CS7UXE_cjs.$err({ msg: `${chunkX4CS7UXE_cjs.title("node", "Decryption")}: Failed to decrypt data`, desc: chunkX4CS7UXE_cjs.$fmtError(error) });
+    return chunkHTRGOBZF_cjs.$err({ msg: `${chunkHTRGOBZF_cjs.title("node", "Decryption")}: Failed to decrypt data`, desc: chunkHTRGOBZF_cjs.$fmtError(error) });
   }
 }
 function $encryptObj(data, secretKey, options) {
-  const { result, error } = chunkX4CS7UXE_cjs.$stringifyObj(data);
-  if (error) return chunkX4CS7UXE_cjs.$err(error);
+  const { result, error } = chunkHTRGOBZF_cjs.$stringifyObj(data);
+  if (error) return chunkHTRGOBZF_cjs.$err(error);
   return $encrypt(result, secretKey, options);
 }
 function $decryptObj(encrypted, secretKey, options) {
   const { result, error } = $decrypt(encrypted, secretKey, options);
-  if (error) return chunkX4CS7UXE_cjs.$err(error);
-  return chunkX4CS7UXE_cjs.$parseToObj(result);
+  if (error) return chunkHTRGOBZF_cjs.$err(error);
+  return chunkHTRGOBZF_cjs.$parseToObj(result);
 }
 function $hash(data, options = {}) {
-  if (!chunkX4CS7UXE_cjs.$isStr(data)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Hashing")}: Empty data for hashing`,
+  if (!chunkHTRGOBZF_cjs.$isStr(data)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Hashing")}: Empty data for hashing`,
       desc: "Data must be a non-empty string"
     });
   }
-  if (!chunkX4CS7UXE_cjs.$isPlainObj(options)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Hashing")}: Invalid options`,
+  if (!chunkHTRGOBZF_cjs.$isPlainObj(options)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Hashing")}: Invalid options`,
       desc: "Options must be an object"
     });
   }
   const outputEncoding = options.outputEncoding ?? "base64url";
-  if (!chunkX4CS7UXE_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Hashing")}: Unsupported output encoding: ${outputEncoding}`,
+  if (!chunkHTRGOBZF_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Hashing")}: Unsupported output encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
   const digest = options.digest ?? "sha256";
-  if (!(digest in chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Hashing")}: Unsupported digest: ${digest}`,
-      desc: `Supported digests are: ${Object.keys(chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS).join(", ")}`
+  if (!(digest in chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Hashing")}: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS).join(", ")}`
     });
   }
-  const digestAlgo = chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS[digest];
+  const digestAlgo = chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS[digest];
   const { result, error } = $convertStrToBytes(data, "utf8");
-  if (error) return chunkX4CS7UXE_cjs.$err(error);
+  if (error) return chunkHTRGOBZF_cjs.$err(error);
   try {
     const hashed = nodeCrypto__default.default.createHash(digestAlgo.node).update(result).digest();
     return $convertBytesToStr(hashed, outputEncoding);
   } catch (error2) {
-    return chunkX4CS7UXE_cjs.$err({ msg: `${chunkX4CS7UXE_cjs.title("node", "Hashing")}: Failed to hash data with Crypto NodeJS`, desc: chunkX4CS7UXE_cjs.$fmtError(error2) });
+    return chunkHTRGOBZF_cjs.$err({ msg: `${chunkHTRGOBZF_cjs.title("node", "Hashing")}: Failed to hash data with Crypto NodeJS`, desc: chunkHTRGOBZF_cjs.$fmtError(error2) });
   }
 }
 function $hashPassword(password, options) {
-  if (!chunkX4CS7UXE_cjs.$isStr(password)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Empty password for hashing`,
+  if (!chunkHTRGOBZF_cjs.$isStr(password)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Empty password for hashing`,
       desc: "Password must be a non-empty string"
     });
   }
-  if (!chunkX4CS7UXE_cjs.$isPlainObj(options)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Invalid options`,
+  if (!chunkHTRGOBZF_cjs.$isPlainObj(options)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Invalid options`,
       desc: "Options must be an object"
     });
   }
   const digest = options.digest ?? "sha512";
-  if (!(digest in chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Unsupported digest: ${digest}`,
-      desc: `Supported digests are: ${Object.keys(chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS).join(", ")}`
+  if (!(digest in chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Unsupported digest: ${digest}`,
+      desc: `Supported digests are: ${Object.keys(chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS).join(", ")}`
     });
   }
-  const digestAlgo = chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS[digest];
+  const digestAlgo = chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS[digest];
   const outputEncoding = options.outputEncoding ?? "base64url";
-  if (!chunkX4CS7UXE_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Unsupported encoding: ${outputEncoding}`,
+  if (!chunkHTRGOBZF_cjs.CIPHER_ENCODING.includes(outputEncoding)) {
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Unsupported encoding: ${outputEncoding}`,
       desc: "Use base64, base64url, or hex"
     });
   }
   const saltLength = options.saltLength ?? 16;
   if (typeof saltLength !== "number" || saltLength < 8) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Weak salt length`,
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Weak salt length`,
       desc: "Salt length must be a number and at least 8 bytes (recommended 16 or more)"
     });
   }
   const iterations = options.iterations ?? 32e4;
   if (typeof iterations !== "number" || iterations < 1e3) {
-    return chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Weak iterations count`,
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Weak iterations 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 chunkX4CS7UXE_cjs.$err({
-      msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Invalid key length`,
+    return chunkHTRGOBZF_cjs.$err({
+      msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Invalid key length`,
       desc: "Key length must be a number and at least 16 bytes (recommended 64 or more)"
     });
   }
   try {
     const salt = nodeCrypto__default.default.randomBytes(saltLength);
     const hash2 = nodeCrypto__default.default.pbkdf2Sync(password.normalize("NFKC"), salt, iterations, keyLength, digestAlgo.node);
-    return chunkX4CS7UXE_cjs.$ok({ result: hash2.toString(outputEncoding), salt: salt.toString(outputEncoding) });
+    return chunkHTRGOBZF_cjs.$ok({ result: hash2.toString(outputEncoding), salt: salt.toString(outputEncoding) });
   } catch (error) {
-    return chunkX4CS7UXE_cjs.$err({ msg: `${chunkX4CS7UXE_cjs.title("node", "Password Hashing")}: Failed to hash password`, desc: chunkX4CS7UXE_cjs.$fmtError(error) });
+    return chunkHTRGOBZF_cjs.$err({ msg: `${chunkHTRGOBZF_cjs.title("node", "Password Hashing")}: Failed to hash password`, desc: chunkHTRGOBZF_cjs.$fmtError(error) });
   }
 }
 function $verifyPassword(password, hashedPassword, salt, options) {
-  if (!chunkX4CS7UXE_cjs.$isStr(password) || !chunkX4CS7UXE_cjs.$isStr(hashedPassword) || !chunkX4CS7UXE_cjs.$isStr(salt) || !chunkX4CS7UXE_cjs.$isPlainObj(options)) {
+  if (!chunkHTRGOBZF_cjs.$isStr(password) || !chunkHTRGOBZF_cjs.$isStr(hashedPassword) || !chunkHTRGOBZF_cjs.$isStr(salt) || !chunkHTRGOBZF_cjs.$isPlainObj(options)) {
     return false;
   }
   const digest = options.digest ?? "sha512";
-  if (!(digest in chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS)) return false;
-  const digestAlgo = chunkX4CS7UXE_cjs.DIGEST_ALGORITHMS[digest];
+  if (!(digest in chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS)) return false;
+  const digestAlgo = chunkHTRGOBZF_cjs.DIGEST_ALGORITHMS[digest];
   const inputEncoding = options.inputEncoding ?? "base64url";
-  if (!chunkX4CS7UXE_cjs.CIPHER_ENCODING.includes(inputEncoding)) return false;
+  if (!chunkHTRGOBZF_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;
@@ -395,15 +394,12 @@ function $verifyPassword(password, hashedPassword, salt, options) {
 }
 
 // src/node/kit.ts
-function isNodeSecretKey(x) {
-  return chunkX4CS7UXE_cjs.$isSecretKey(x, "node") !== null;
-}
 function tryGenerateUuid() {
   return $generateUuid();
 }
 function generateUuid() {
   const { result, error } = $generateUuid();
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryCreateSecretKey(secret, options = {}) {
@@ -411,7 +407,7 @@ function tryCreateSecretKey(secret, options = {}) {
 }
 function createSecretKey(secret, options = {}) {
   const { result, error } = $createSecretKey(secret, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryEncrypt(data, secretKey, options = {}) {
@@ -419,7 +415,7 @@ function tryEncrypt(data, secretKey, options = {}) {
 }
 function encrypt(data, secretKey, options = {}) {
   const { result, error } = $encrypt(data, secretKey, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryDecrypt(encrypted, secretKey, options = {}) {
@@ -427,7 +423,7 @@ function tryDecrypt(encrypted, secretKey, options = {}) {
 }
 function decrypt(encrypted, secretKey, options = {}) {
   const { result, error } = $decrypt(encrypted, secretKey, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryEncryptObj(obj, secretKey, options = {}) {
@@ -435,7 +431,7 @@ function tryEncryptObj(obj, secretKey, options = {}) {
 }
 function encryptObj(obj, secretKey, options = {}) {
   const { result, error } = $encryptObj(obj, secretKey, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryDecryptObj(encrypted, secretKey, options = {}) {
@@ -443,7 +439,7 @@ function tryDecryptObj(encrypted, secretKey, options = {}) {
 }
 function decryptObj(encrypted, secretKey, options = {}) {
   const { result, error } = $decryptObj(encrypted, secretKey, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryHash(data, options = {}) {
@@ -451,7 +447,7 @@ function tryHash(data, options = {}) {
 }
 function hash(data, options = {}) {
   const { result, error } = $hash(data, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryHashPassword(password, options = {}) {
@@ -459,7 +455,7 @@ function tryHashPassword(password, options = {}) {
 }
 function hashPassword(password, options = {}) {
   const { result, salt, error } = $hashPassword(password, options);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return { result, salt };
 }
 function verifyPassword(password, hashedPassword, salt, options = {}) {
@@ -470,7 +466,7 @@ function tryConvertStrToBytes(data, inputEncoding = "utf8") {
 }
 function convertStrToBytes(data, inputEncoding = "utf8") {
   const { result, error } = $convertStrToBytes(data, inputEncoding);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryConvertBytesToStr(data, outputEncoding = "utf8") {
@@ -478,7 +474,7 @@ function tryConvertBytesToStr(data, outputEncoding = "utf8") {
 }
 function convertBytesToStr(data, outputEncoding = "utf8") {
   const { result, error } = $convertBytesToStr(data, outputEncoding);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 function tryConvertEncoding(data, from, to) {
@@ -486,7 +482,7 @@ function tryConvertEncoding(data, from, to) {
 }
 function convertEncoding(data, from, to) {
   const { result, error } = $convertEncoding(data, from, to);
-  if (error) throw new Error(chunkX4CS7UXE_cjs.$fmtResultErr(error));
+  if (error) throw new Error(chunkHTRGOBZF_cjs.$fmtResultErr(error));
   return result;
 }
 
@@ -501,7 +497,6 @@ exports.encryptObj = encryptObj;
 exports.generateUuid = generateUuid;
 exports.hash = hash;
 exports.hashPassword = hashPassword;
-exports.isNodeSecretKey = isNodeSecretKey;
 exports.kit_exports = kit_exports;
 exports.tryConvertBytesToStr = tryConvertBytesToStr;
 exports.tryConvertEncoding = tryConvertEncoding;
@@ -515,5 +510,5 @@ exports.tryGenerateUuid = tryGenerateUuid;
 exports.tryHash = tryHash;
 exports.tryHashPassword = tryHashPassword;
 exports.verifyPassword = verifyPassword;
-//# sourceMappingURL=chunk-56PVVFVM.cjs.map
-//# sourceMappingURL=chunk-56PVVFVM.cjs.map
+//# sourceMappingURL=chunk-ZNM5M6RD.cjs.map
+//# sourceMappingURL=chunk-ZNM5M6RD.cjs.map