cipher-kit 1.0.0 → 2.0.0-beta.0

package/README.md

@@ -5,7 +5,8 @@
 
 <p align="center">
   Secure, Lightweight, and Cross-Platform <br/>
-  Encryption & Decryption for Web, Node.js, Deno, and Bun
+  Encryption, Decryption, and Hashing <br/> 
+  for Web, Node.js, Deno, Bun, and Cloudflare Workers
 </p>
 
 <a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/WolfieLeader/npm?color=DC343B" alt="License"></a>
@@ -36,6 +37,127 @@ npm install cipher-kit@latest
 
 > 💡 Works with `npm`, `pnpm`, `yarn`, `bun`, and `deno`. You can use it in dev dependencies since it's typically used only for local HTTPS.
 
+## Usage 🪛
+
+Pick the runtime you’re targeting, or import from the root:
+
+```typescript
+// For Node.js
+import { encrypt, decrypt } from 'cipher-kit/node';
+
+// For Web API, Deno, Bun, Cloudflare Workers
+import { encrypt, decrypt } from 'cipher-kit/web-api';
+
+// Or import everything from the root
+// Functions that, for example encrypt and decrypt will use Node.js implementation.
+// You can also access web and node object kits directly.
+import { encrypt, decrypt, nodeKit, webKit } from 'cipher-kit';
+```
+
+Functions that throw error will show that in their JSDoc comments.
+
+If you would like to avoid using `try/catch`, you can use the functions that prefixed with `try`, e.g., `tryEncrypt`, `tryDecrypt`, `tryEncryptObj`, `tryDecryptObj`. You need to check if the `error` is `undefined` or the `success` is `true` to ensure the operation was successful.
+
+### Node.js Example:
+
+```typescript
+import {
+  generateUuid,
+  hash,
+  createSecretKey,
+  encrypt,
+  decrypt,
+  encryptObj,
+  decryptObj,
+  tryEncrypt,
+  tryDecrypt,
+} from 'cipher-kit/node';
+
+const str = 'The brown fox 🦊 jumps over the lazy dog 🐶.';
+
+function nodeExample() {
+  console.log(`New UUID: ${generateUuid()}`);
+
+  console.log(`SHA-256 Hash (ABCDEFG): ${hash('ABCDEFG')}`);
+
+  const secretKey = createSecretKey('my secure passphrase');
+
+  const encrypted = encrypt(str, secretKey);
+  console.log(`Encrypted Data: ${encrypted}`);
+  console.log(`Decrypted Data: ${decrypt(encrypted, secretKey)}`);
+
+  const encryptedObj = encryptObj({ message: 'Hello, World! 🌍', count: 42 }, secretKey);
+  console.log(`Encrypted Object: ${encryptedObj}`);
+  console.log(`Decrypted Object: ${JSON.stringify(decryptObj(encryptedObj, secretKey))}`);
+
+  const { result: tryEncrypted, error: tryEncryptError } = tryEncrypt(str, secretKey);
+  if (tryEncryptError) {
+    console.error(`Encryption Try failed: ${tryEncryptError.message} - ${tryEncryptError.description}`);
+    return;
+  }
+  console.log(`Encrypted Try Data: ${tryEncrypted}`);
+
+  const decryptedTry = tryDecrypt(tryEncrypted, secretKey);
+  if (decryptedTry.success === false) {
+    console.error(`Decryption Try failed: ${decryptedTry.error.message} - ${decryptedTry.error.description}`);
+    return;
+  }
+  console.log(`Try Decrypted Data: ${decryptedTry.result}`);
+}
+
+nodeExample();
+```
+
+### Web API Example:
+
+```typescript
+import {
+  generateUuid,
+  hash,
+  createSecretKey,
+  encrypt,
+  decrypt,
+  encryptObj,
+  decryptObj,
+  tryEncrypt,
+  tryDecrypt,
+} from 'cipher-kit/web-api';
+
+const str = 'The brown fox 🦊 jumps over the lazy dog 🐶.';
+
+async function webApiExample() {
+  console.log(`New UUID: ${generateUuid()}`);
+
+  console.log(`SHA-256 Hash (ABCDEFG): ${await hash('ABCDEFG')}`);
+
+  const secretKey = await createSecretKey('my secure passphrase');
+
+  const encrypted = await encrypt(str, secretKey);
+  console.log(`Encrypted Data: ${encrypted}`);
+  console.log(`Decrypted Data: ${await decrypt(encrypted, secretKey)}`);
+
+  const encryptedObj = await encryptObj({ message: 'Hello, World! 🌍', count: 42 }, secretKey);
+  console.log(`Encrypted Object: ${encryptedObj}`);
+  console.log(`Decrypted Object: ${JSON.stringify(await decryptObj(encryptedObj, secretKey))}`);
+
+  const { result: tryEncrypted, error: tryEncryptError } = await tryEncrypt(str, secretKey);
+  if (tryEncryptError) {
+    console.error(`Encryption Try failed: ${tryEncryptError.message} - ${tryEncryptError.description}`);
+    return;
+  }
+  console.log(`Encrypted Try Data: ${tryEncrypted}`);
+
+  const decryptedTry = await tryDecrypt(tryEncrypted, secretKey);
+  if (decryptedTry.success === false) {
+    console.error(`Decryption Try failed: ${decryptedTry.error.message} - ${decryptedTry.error.description}`);
+    return;
+  }
+  console.log(`Try Decrypted Data: ${decryptedTry.result}`);
+}
+
+webApiExample();
+```
+
 ## Contributions 🤝
 
 Want to contribute or suggest a feature?

package/dist/chunk-4IOWANDJ.cjs

@@ -0,0 +1,376 @@
+'use strict';
+
+var chunkD656BYPA_cjs = require('./chunk-D656BYPA.cjs');
+var buffer = require('buffer');
+var nodeCrypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var nodeCrypto__default = /*#__PURE__*/_interopDefault(nodeCrypto);
+
+// src/node/kit.ts
+var kit_exports = {};
+chunkD656BYPA_cjs.__export(kit_exports, {
+  convertBytesToStr: () => convertBytesToStr,
+  convertFormat: () => convertFormat,
+  convertStrToBytes: () => convertStrToBytes,
+  createSecretKey: () => createSecretKey,
+  decrypt: () => decrypt,
+  decryptObj: () => decryptObj,
+  encrypt: () => encrypt,
+  encryptObj: () => encryptObj,
+  generateUuid: () => generateUuid,
+  hash: () => hash,
+  hashPassword: () => hashPassword,
+  isNodeSecretKey: () => chunkD656BYPA_cjs.isNodeSecretKey,
+  tryConvertBytesToStr: () => tryConvertBytesToStr,
+  tryConvertFormat: () => tryConvertFormat,
+  tryConvertStrToBytes: () => tryConvertStrToBytes,
+  tryCreateSecretKey: () => tryCreateSecretKey,
+  tryDecrypt: () => tryDecrypt,
+  tryDecryptObj: () => tryDecryptObj,
+  tryEncrypt: () => tryEncrypt,
+  tryEncryptObj: () => tryEncryptObj,
+  tryGenerateUuid: () => tryGenerateUuid,
+  tryHash: () => tryHash,
+  tryHashPassword: () => tryHashPassword,
+  verifyPassword: () => verifyPassword
+});
+function $convertStrToBytes(data, format = "utf8") {
+  if (!chunkD656BYPA_cjs.$isStr(data)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - String to Bytes: Empty data",
+      desc: "Data must be a non-empty string"
+    });
+  }
+  if (!chunkD656BYPA_cjs.ENCODING_FORMATS.includes(format)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: `Crypto NodeJS API - String to Bytes: Unsupported encode format: ${format}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
+  try {
+    return chunkD656BYPA_cjs.$ok({ result: buffer.Buffer.from(data, format) });
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - String to Bytes: Failed to convert data", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $convertBytesToStr(data, format = "utf8") {
+  if (!(data instanceof buffer.Buffer)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Bytes to String: Invalid data type",
+      desc: "Data must be a Buffer"
+    });
+  }
+  if (!chunkD656BYPA_cjs.ENCODING_FORMATS.includes(format)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: `Crypto NodeJS API - Bytes to String: Unsupported format: ${format}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
+  try {
+    return chunkD656BYPA_cjs.$ok(buffer.Buffer.from(data).toString(format));
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Bytes to String: Failed to convert data", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $convertFormat(data, from, to) {
+  if (!chunkD656BYPA_cjs.$isStr(data)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Convert Format: Empty data",
+      desc: "Data must be a non-empty string"
+    });
+  }
+  if (!chunkD656BYPA_cjs.ENCODING_FORMATS.includes(from) || !chunkD656BYPA_cjs.ENCODING_FORMATS.includes(to)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: `Crypto NodeJS API - Convert Format: Unsupported format: from ${from} to ${to}`,
+      desc: "Use base64, base64url, hex, utf8, or latin1"
+    });
+  }
+  const bytes = $convertStrToBytes(data, from);
+  if (bytes.error) return chunkD656BYPA_cjs.$err({ msg: bytes.error.message, desc: bytes.error.description });
+  const str = $convertBytesToStr(bytes.result, to);
+  if (str.error) return chunkD656BYPA_cjs.$err({ msg: str.error.message, desc: str.error.description });
+  return chunkD656BYPA_cjs.$ok({ result: str.result });
+}
+function $generateUuid() {
+  try {
+    return chunkD656BYPA_cjs.$ok(nodeCrypto__default.default.randomUUID());
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - UUID Generation: Failed to generate UUID", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $createSecretKey(key) {
+  if (!chunkD656BYPA_cjs.$isStr(key)) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Key Generation: Empty key", desc: "Key must be a non-empty string" });
+  }
+  try {
+    const derivedKey = nodeCrypto__default.default.hkdfSync(
+      chunkD656BYPA_cjs.DIGEST_ALGORITHMS.sha256.node,
+      key.normalize("NFKC"),
+      "cipher-kit-salt",
+      "cipher-kit",
+      chunkD656BYPA_cjs.ENCRYPTION_ALGORITHMS.aes256gcm.keyBytes
+    );
+    const secretKey = nodeCrypto__default.default.createSecretKey(buffer.Buffer.from(derivedKey));
+    return chunkD656BYPA_cjs.$ok({ result: secretKey });
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Key Generation: Failed to create secret key", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $encrypt(data, secretKey) {
+  if (!chunkD656BYPA_cjs.$isStr(data)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Encryption: Empty data for encryption",
+      desc: "Data must be a non-empty string"
+    });
+  }
+  if (!chunkD656BYPA_cjs.isNodeSecretKey(secretKey)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Encryption: Invalid encryption key",
+      desc: "Expected a NodeKey (crypto.KeyObject)"
+    });
+  }
+  try {
+    const iv = nodeCrypto__default.default.randomBytes(chunkD656BYPA_cjs.ENCRYPTION_ALGORITHMS.aes256gcm.ivLength);
+    const cipher = nodeCrypto__default.default.createCipheriv(chunkD656BYPA_cjs.ENCRYPTION_ALGORITHMS.aes256gcm.node, secretKey, iv);
+    const encrypted = buffer.Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const ivStr = $convertBytesToStr(iv, "base64url");
+    const cipherStr = $convertBytesToStr(encrypted, "base64url");
+    const tagStr = $convertBytesToStr(tag, "base64url");
+    if (ivStr.error || cipherStr.error || tagStr.error) {
+      return chunkD656BYPA_cjs.$err({
+        msg: "Crypto NodeJS API - Encryption: Failed to convert IV or encrypted data or tag",
+        desc: `Conversion error: ${ivStr.error || cipherStr.error || tagStr.error}`
+      });
+    }
+    return chunkD656BYPA_cjs.$ok(`${ivStr.result}.${cipherStr.result}.${tagStr.result}.`);
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Encryption: Failed to encrypt data", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $decrypt(encrypted, secretKey) {
+  if (chunkD656BYPA_cjs.matchPattern(encrypted, "node") === false) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Decryption: Invalid encrypted data format",
+      desc: 'Encrypted data must be in the format "iv.cipher.tag."'
+    });
+  }
+  const [iv, cipher, tag] = encrypted.split(".", 4);
+  if (!chunkD656BYPA_cjs.$isStr(iv) || !chunkD656BYPA_cjs.$isStr(cipher) || !chunkD656BYPA_cjs.$isStr(tag)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Decryption: Invalid encrypted data",
+      desc: "Encrypted data must contain valid IV, encrypted data, and tag components"
+    });
+  }
+  if (!chunkD656BYPA_cjs.isNodeSecretKey(secretKey)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Decryption: Invalid decryption key",
+      desc: "Expected a NodeKey (crypto.KeyObject)"
+    });
+  }
+  const ivBytes = $convertStrToBytes(iv, "base64url");
+  const cipherBytes = $convertStrToBytes(cipher, "base64url");
+  const tagBytes = $convertStrToBytes(tag, "base64url");
+  if (ivBytes.error || cipherBytes.error || tagBytes.error) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Decryption: Failed to convert IV or encrypted data or tag",
+      desc: `Conversion error: ${ivBytes.error || cipherBytes.error || tagBytes.error}`
+    });
+  }
+  try {
+    const decipher = nodeCrypto__default.default.createDecipheriv(chunkD656BYPA_cjs.ENCRYPTION_ALGORITHMS.aes256gcm.node, secretKey, ivBytes.result);
+    decipher.setAuthTag(tagBytes.result);
+    const decrypted = buffer.Buffer.concat([decipher.update(cipherBytes.result), decipher.final()]);
+    return $convertBytesToStr(decrypted, "utf8");
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Decryption: Failed to decrypt data", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $encryptObj(data, secretKey) {
+  const { result, error } = chunkD656BYPA_cjs.$stringifyObj(data);
+  if (error) return chunkD656BYPA_cjs.$err(error);
+  return $encrypt(result, secretKey);
+}
+function $decryptObj(encrypted, secretKey) {
+  const { result, error } = $decrypt(encrypted, secretKey);
+  if (error) return chunkD656BYPA_cjs.$err(error);
+  return chunkD656BYPA_cjs.$parseToObj(result);
+}
+function $hash(data) {
+  if (!chunkD656BYPA_cjs.$isStr(data, 0)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Hashing: Empty data for hashing",
+      desc: "Data must be a non-empty string"
+    });
+  }
+  try {
+    const hashed = nodeCrypto__default.default.createHash(chunkD656BYPA_cjs.DIGEST_ALGORITHMS.sha256.node).update(data).digest();
+    return $convertBytesToStr(hashed, "base64url");
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Hashing: Failed to hash data with Crypto NodeJS", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $hashPassword(password) {
+  if (!chunkD656BYPA_cjs.$isStr(password)) {
+    return chunkD656BYPA_cjs.$err({
+      msg: "Crypto NodeJS API - Password Hashing: Empty password for hashing",
+      desc: "Password must be a non-empty string"
+    });
+  }
+  try {
+    const salt = nodeCrypto__default.default.randomBytes(chunkD656BYPA_cjs.PASSWORD_HASHING.pbkdf2.saltLength);
+    const hash2 = nodeCrypto__default.default.pbkdf2Sync(
+      password.normalize("NFKC"),
+      salt,
+      chunkD656BYPA_cjs.PASSWORD_HASHING.pbkdf2.iterations,
+      chunkD656BYPA_cjs.PASSWORD_HASHING.pbkdf2.keyLength,
+      chunkD656BYPA_cjs.DIGEST_ALGORITHMS.sha512.node
+    );
+    return chunkD656BYPA_cjs.$ok({ salt: salt.toString("base64url"), hash: hash2.toString("base64url") });
+  } catch (error) {
+    return chunkD656BYPA_cjs.$err({ msg: "Crypto NodeJS API - Password Hashing: Failed to hash password", desc: chunkD656BYPA_cjs.$fmtError(error) });
+  }
+}
+function $verifyPassword(password, hashedPassword, salt) {
+  if (!chunkD656BYPA_cjs.$isStr(password) || !chunkD656BYPA_cjs.$isStr(hashedPassword) || !chunkD656BYPA_cjs.$isStr(salt)) return false;
+  const saltBytes = $convertStrToBytes(salt, "base64url");
+  if (saltBytes.error) return false;
+  const hashedPasswordBytes = $convertStrToBytes(hashedPassword, "base64url");
+  if (hashedPasswordBytes.error) return false;
+  try {
+    return nodeCrypto__default.default.timingSafeEqual(
+      nodeCrypto__default.default.pbkdf2Sync(
+        password.normalize("NFKC"),
+        saltBytes.result,
+        chunkD656BYPA_cjs.PASSWORD_HASHING.pbkdf2.iterations,
+        chunkD656BYPA_cjs.PASSWORD_HASHING.pbkdf2.keyLength,
+        chunkD656BYPA_cjs.DIGEST_ALGORITHMS.sha512.node
+      ),
+      hashedPasswordBytes.result
+    );
+  } catch {
+    return false;
+  }
+}
+
+// src/node/kit.ts
+function tryGenerateUuid() {
+  return $generateUuid();
+}
+function generateUuid() {
+  const { result, error } = $generateUuid();
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryCreateSecretKey(key) {
+  return $createSecretKey(key);
+}
+function createSecretKey(key) {
+  const { result, error } = $createSecretKey(key);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryEncrypt(data, secretKey) {
+  return $encrypt(data, secretKey);
+}
+function encrypt(data, secretKey) {
+  const { result, error } = $encrypt(data, secretKey);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryDecrypt(encrypted, secretKey) {
+  return $decrypt(encrypted, secretKey);
+}
+function decrypt(encrypted, secretKey) {
+  const { result, error } = $decrypt(encrypted, secretKey);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryEncryptObj(data, secretKey) {
+  return $encryptObj(data, secretKey);
+}
+function encryptObj(data, secretKey) {
+  const { result, error } = $encryptObj(data, secretKey);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryDecryptObj(encrypted, secretKey) {
+  return $decryptObj(encrypted, secretKey);
+}
+function decryptObj(encrypted, secretKey) {
+  const { result, error } = $decryptObj(encrypted, secretKey);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return { result };
+}
+function tryHash(data) {
+  return $hash(data);
+}
+function hash(data) {
+  const { result, error } = $hash(data);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryHashPassword(password) {
+  return $hashPassword(password);
+}
+function hashPassword(password) {
+  const { hash: hash2, salt, error } = $hashPassword(password);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return { hash: hash2, salt };
+}
+function verifyPassword(password, hashedPassword, salt) {
+  return $verifyPassword(password, hashedPassword, salt);
+}
+function tryConvertStrToBytes(data, format = "utf8") {
+  return $convertStrToBytes(data, format);
+}
+function convertStrToBytes(data, format = "utf8") {
+  const { result, error } = $convertStrToBytes(data, format);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryConvertBytesToStr(data, format = "utf8") {
+  return $convertBytesToStr(data, format);
+}
+function convertBytesToStr(data, format = "utf8") {
+  const { result, error } = $convertBytesToStr(data, format);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+function tryConvertFormat(data, from, to) {
+  return $convertFormat(data, from, to);
+}
+function convertFormat(data, from, to) {
+  const { result, error } = $convertFormat(data, from, to);
+  if (error) throw new Error(chunkD656BYPA_cjs.$fmtResultErr(error));
+  return result;
+}
+
+exports.convertBytesToStr = convertBytesToStr;
+exports.convertFormat = convertFormat;
+exports.convertStrToBytes = convertStrToBytes;
+exports.createSecretKey = createSecretKey;
+exports.decrypt = decrypt;
+exports.decryptObj = decryptObj;
+exports.encrypt = encrypt;
+exports.encryptObj = encryptObj;
+exports.generateUuid = generateUuid;
+exports.hash = hash;
+exports.hashPassword = hashPassword;
+exports.kit_exports = kit_exports;
+exports.tryConvertBytesToStr = tryConvertBytesToStr;
+exports.tryConvertFormat = tryConvertFormat;
+exports.tryConvertStrToBytes = tryConvertStrToBytes;
+exports.tryCreateSecretKey = tryCreateSecretKey;
+exports.tryDecrypt = tryDecrypt;
+exports.tryDecryptObj = tryDecryptObj;
+exports.tryEncrypt = tryEncrypt;
+exports.tryEncryptObj = tryEncryptObj;
+exports.tryGenerateUuid = tryGenerateUuid;
+exports.tryHash = tryHash;
+exports.tryHashPassword = tryHashPassword;
+exports.verifyPassword = verifyPassword;
+//# sourceMappingURL=chunk-4IOWANDJ.cjs.map
+//# sourceMappingURL=chunk-4IOWANDJ.cjs.map

package/dist/chunk-4IOWANDJ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node/kit.ts","../src/node/node-encode.ts","../src/node/node-encrypt.ts"],"names":["__export","isNodeSecretKey","$isStr","$err","ENCODING_FORMATS","$ok","Buffer","$fmtError","nodeCrypto","DIGEST_ALGORITHMS","ENCRYPTION_ALGORITHMS","matchPattern","$stringifyObj","$parseToObj","PASSWORD_HASHING","hash","$fmtResultErr"],"mappings":"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","file":"chunk-4IOWANDJ.cjs","sourcesContent":["import type { Buffer } from 'node:buffer';\r\nimport { $fmtResultErr, type Result } from '~/helpers/error';\r\nimport type { EncodingFormat, NodeSecretKey } from '~/helpers/types';\r\nimport { $convertBytesToStr, $convertFormat, $convertStrToBytes } from './node-encode';\r\nimport {\r\n  $createSecretKey,\r\n  $decrypt,\r\n  $decryptObj,\r\n  $encrypt,\r\n  $encryptObj,\r\n  $generateUuid,\r\n  $hash,\r\n  $hashPassword,\r\n  $verifyPassword,\r\n} from './node-encrypt';\r\n\r\nexport { isNodeSecretKey } from '~/helpers/validate';\r\n\r\n/**\r\n * Generates a UUID (v4).\r\n *\r\n * @returns A Result containing a string representing the generated UUID or an error.\r\n */\r\nexport function tryGenerateUuid(): Result<string> {\r\n  return $generateUuid();\r\n}\r\n\r\n/**\r\n * Generates a UUID (v4).\r\n *\r\n * @returns A string representing the generated UUID.\r\n * @throws {Error} If UUID generation fails.\r\n */\r\nexport function generateUuid(): string {\r\n  const { result, error } = $generateUuid();\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Derives a secret key from the provided string for encryption/decryption.\r\n * Internally, the key is hashed using SHA-256 to ensure it meets the required length.\r\n *\r\n * @param key - The input string to derive the secret key from.\r\n * @returns A Result containing a NodeKey object representing the derived secret key or an error.\r\n */\r\nexport function tryCreateSecretKey(key: string): Result<{ result: NodeSecretKey }> {\r\n  return $createSecretKey(key);\r\n}\r\n\r\n/**\r\n * Derives a secret key from the provided string for encryption/decryption.\r\n * Internally, the key is hashed using SHA-256 to ensure it meets the required length.\r\n *\r\n * @param key - The input string to derive the secret key from.\r\n * @returns A NodeKey object representing the derived secret key.\r\n * @throws {Error} If the input key is invalid or key generation fails.\r\n */\r\nexport function createSecretKey(key: string): NodeSecretKey {\r\n  const { result, error } = $createSecretKey(key);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Encrypts the input string using the provided secret key.\r\n * The output is a string in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n *\r\n * @param data - The input string to encrypt.\r\n * @param secretKey - The NodeKey object used for encryption.\r\n * @returns A Result containing a string representing the encrypted data in the specified format or an error.\r\n */\r\nexport function tryEncrypt(data: string, secretKey: NodeSecretKey): Result<string> {\r\n  return $encrypt(data, secretKey);\r\n}\r\n\r\n/**\r\n * Encrypts the input string using the provided secret key.\r\n * The output is a string in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n *\r\n * @param data - The input string to encrypt.\r\n * @param secretKey - The NodeKey object used for encryption.\r\n * @returns A string representing the encrypted data in the specified format.\r\n * @throws {Error} If the input data or key is invalid, or if encryption fails.\r\n */\r\nexport function encrypt(data: string, secretKey: NodeSecretKey): string {\r\n  const { result, error } = $encrypt(data, secretKey);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Decrypts the input string using the provided secret key.\r\n * The input must be in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n *\r\n * @param encrypted - The input string to decrypt.\r\n * @param secretKey - The NodeKey object used for decryption.\r\n * @returns A Result containing a string representing the decrypted data or an error.\r\n */\r\nexport function tryDecrypt(encrypted: string, secretKey: NodeSecretKey): Result<string> {\r\n  return $decrypt(encrypted, secretKey);\r\n}\r\n\r\n/**\r\n * Decrypts the input string using the provided secret key.\r\n * The input must be in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n *\r\n * @param encrypted - The input string to decrypt.\r\n * @param secretKey - The NodeKey object used for decryption.\r\n * @returns A string representing the decrypted data.\r\n * @throws {Error} If the input data or key is invalid, or if decryption fails.\r\n */\r\nexport function decrypt(encrypted: string, secretKey: NodeSecretKey): string {\r\n  const { result, error } = $decrypt(encrypted, secretKey);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Encrypts the input object using the provided secret key.\r\n * The object is first serialized to a JSON string before encryption.\r\n * The output is a string in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n *\r\n * @param data - The input object to encrypt.\r\n * @param secretKey - The NodeKey object used for encryption.\r\n * @returns A Result containing a string representing the encrypted object in the specified format or an error.\r\n */\r\nexport function tryEncryptObj<T extends object = Record<string, unknown>>(\r\n  data: T,\r\n  secretKey: NodeSecretKey,\r\n): Result<string> {\r\n  return $encryptObj(data, secretKey);\r\n}\r\n\r\n/**\r\n * Encrypts the input object using the provided secret key.\r\n * The object is first serialized to a JSON string before encryption.\r\n * The output is a string in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n *\r\n * @param data - The input object to encrypt.\r\n * @param secretKey - The NodeKey object used for encryption.\r\n * @returns A string representing the encrypted object in the specified format.\r\n * @throws {Error} If the input data or key is invalid, or if encryption fails.\r\n */\r\nexport function encryptObj<T extends object = Record<string, unknown>>(data: T, secretKey: NodeSecretKey): string {\r\n  const { result, error } = $encryptObj(data, secretKey);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Decrypts the input string to an object using the provided secret key.\r\n * The input must be in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n * The decrypted string is parsed as JSON to reconstruct the original object.\r\n *\r\n * @param encrypted - The input string to decrypt.\r\n * @param secretKey - The NodeKey object used for decryption.\r\n * @returns A Result containing an object representing the decrypted data or an error.\r\n */\r\nexport function tryDecryptObj<T extends object = Record<string, unknown>>(\r\n  encrypted: string,\r\n  secretKey: NodeSecretKey,\r\n): Result<{ result: T }> {\r\n  return $decryptObj<T>(encrypted, secretKey);\r\n}\r\n\r\n/**\r\n * Decrypts the input string to an object using the provided secret key.\r\n * The input must be in the format \"iv.cipher.tag.\" where each component is base64url encoded.\r\n * The decrypted string is parsed as JSON to reconstruct the original object.\r\n *\r\n * @param encrypted - The input string to decrypt.\r\n * @param secretKey - The NodeKey object used for decryption.\r\n * @returns An object representing the decrypted data.\r\n * @throws {Error} If the input data or key is invalid, or if decryption fails.\r\n */\r\nexport function decryptObj<T extends object = Record<string, unknown>>(\r\n  encrypted: string,\r\n  secretKey: NodeSecretKey,\r\n): { result: T } {\r\n  const { result, error } = $decryptObj<T>(encrypted, secretKey);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return { result };\r\n}\r\n\r\n/**\r\n * Hashes the input string using SHA-256 and returns the hash in base64url format.\r\n *\r\n * @param data - The input string to hash.\r\n * @returns A Result containing a string representing the SHA-256 hash in base64url format or an error.\r\n */\r\nexport function tryHash(data: string): Result<string> {\r\n  return $hash(data);\r\n}\r\n\r\n/**\r\n * Hashes the input string using SHA-256 and returns the hash in base64url format.\r\n *\r\n * @param data - The input string to hash.\r\n * @returns A string representing the SHA-256 hash in base64url format.\r\n * @throws {Error} If the input data is invalid or hashing fails.\r\n */\r\nexport function hash(data: string): string {\r\n  const { result, error } = $hash(data);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Hashes a password using PBKDF2 with SHA-512.\r\n *\r\n * @param password - The password to hash.\r\n * @returns A Result containing an object with the hash and salt, or an error.\r\n */\r\nexport function tryHashPassword(password: string): Result<{ hash: string; salt: string }> {\r\n  return $hashPassword(password);\r\n}\r\n\r\n/**\r\n * Hashes a password using PBKDF2 with SHA-512.\r\n *\r\n * @param password - The password to hash.\r\n * @returns An object with the hash and salt.\r\n * @throws {Error} If the input password is invalid or hashing fails.\r\n */\r\nexport function hashPassword(password: string): { hash: string; salt: string } {\r\n  const { hash, salt, error } = $hashPassword(password);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return { hash, salt };\r\n}\r\n\r\n/**\r\n * Verifies a password against a hashed password and salt.\r\n *\r\n * @param password - The password to verify.\r\n * @param hashedPassword - The hashed password to compare against (in base64url format).\r\n * @param salt - The salt used during hashing (in base64url format).\r\n * @returns A boolean indicating whether the password matches the hashed password.\r\n */\r\nexport function verifyPassword(password: string, hashedPassword: string, salt: string): boolean {\r\n  return $verifyPassword(password, hashedPassword, salt);\r\n}\r\n\r\n/**\r\n * Converts a string to a Buffer (byte array) using the specified encoding format.\r\n * Supported formats: 'base64', 'base64url', 'hex', 'utf8', 'latin1'.\r\n *\r\n * @param data - The input string to convert.\r\n * @param format - The encoding format to use (default is 'utf8').\r\n * @returns A Result containing a Node.js Buffer with the encoded data or an error.\r\n */\r\nexport function tryConvertStrToBytes(data: string, format: EncodingFormat = 'utf8'): Result<{ result: Buffer }> {\r\n  return $convertStrToBytes(data, format);\r\n}\r\n\r\n/**\r\n * Converts a string to a Buffer (byte array) using the specified encoding format.\r\n * Supported formats: 'base64', 'base64url', 'hex', 'utf8', 'latin1'.\r\n *\r\n * @param data - The input string to convert.\r\n * @param format - The encoding format to use (default is 'utf8').\r\n * @returns A Node.js Buffer containing the encoded data.\r\n * @throws {Error} If the input data is invalid or conversion fails.\r\n */\r\nexport function convertStrToBytes(data: string, format: EncodingFormat = 'utf8'): Buffer {\r\n  const { result, error } = $convertStrToBytes(data, format);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Converts a Buffer (byte array) to a string using the specified encoding format.\r\n * Supported formats: 'base64', 'base64url', 'hex', 'utf8', 'latin1'.\r\n *\r\n * @param data - The input Buffer to convert.\r\n * @param format - The encoding format to use (default is 'utf8').\r\n * @returns A Result containing the string representation of the Buffer or an error.\r\n */\r\nexport function tryConvertBytesToStr(data: Buffer, format: EncodingFormat = 'utf8'): Result<string> {\r\n  return $convertBytesToStr(data, format);\r\n}\r\n\r\n/**\r\n * Converts a Buffer (byte array) to a string using the specified encoding format.\r\n * Supported formats: 'base64', 'base64url', 'hex', 'utf8', 'latin1'.\r\n *\r\n * @param data - The input Buffer to convert.\r\n * @param format - The encoding format to use (default is 'utf8').\r\n * @returns A string representation of the Buffer in the specified format.\r\n * @throws {Error} If the input data is invalid or conversion fails.\r\n */\r\nexport function convertBytesToStr(data: Buffer, format: EncodingFormat = 'utf8'): string {\r\n  const { result, error } = $convertBytesToStr(data, format);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n\r\n/**\r\n * Convert data from one encoding format to another.\r\n *\r\n * @param data - The input data to convert.\r\n * @param from - The encoding format to convert from.\r\n * @param to - The encoding format to convert to.\r\n * @returns A Result containing the converted string or an error.\r\n */\r\nexport function tryConvertFormat(data: string, from: EncodingFormat, to: EncodingFormat): Result<{ result: string }> {\r\n  return $convertFormat(data, from, to);\r\n}\r\n\r\n/**\r\n * Convert data from one encoding format to another.\r\n *\r\n * @param data - The input data to convert.\r\n * @param from - The encoding format to convert from.\r\n * @param to - The encoding format to convert to.\r\n * @returns A converted string.\r\n * @throws {Error} If the input data is invalid or conversion fails.\r\n */\r\nexport function convertFormat(data: string, from: EncodingFormat, to: EncodingFormat): string {\r\n  const { result, error } = $convertFormat(data, from, to);\r\n  if (error) throw new Error($fmtResultErr(error));\r\n  return result;\r\n}\r\n","import { Buffer } from 'node:buffer';\r\nimport { ENCODING_FORMATS } from '~/helpers/consts';\r\nimport { $err, $fmtError, $ok, type Result } from '~/helpers/error';\r\nimport type { EncodingFormat } from '~/helpers/types';\r\nimport { $isStr } from '~/helpers/validate';\r\n\r\nexport function $convertStrToBytes(data: string, format: EncodingFormat = 'utf8'): Result<{ result: Buffer }> {\r\n  if (!$isStr(data)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - String to Bytes: Empty data',\r\n      desc: 'Data must be a non-empty string',\r\n    });\r\n  }\r\n  if (!ENCODING_FORMATS.includes(format)) {\r\n    return $err({\r\n      msg: `Crypto NodeJS API - String to Bytes: Unsupported encode format: ${format}`,\r\n      desc: 'Use base64, base64url, hex, utf8, or latin1',\r\n    });\r\n  }\r\n  try {\r\n    return $ok({ result: Buffer.from(data, format) });\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - String to Bytes: Failed to convert data', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $convertBytesToStr(data: Buffer, format: EncodingFormat = 'utf8'): Result<string> {\r\n  if (!(data instanceof Buffer)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Bytes to String: Invalid data type',\r\n      desc: 'Data must be a Buffer',\r\n    });\r\n  }\r\n  if (!ENCODING_FORMATS.includes(format)) {\r\n    return $err({\r\n      msg: `Crypto NodeJS API - Bytes to String: Unsupported format: ${format}`,\r\n      desc: 'Use base64, base64url, hex, utf8, or latin1',\r\n    });\r\n  }\r\n  try {\r\n    return $ok(Buffer.from(data).toString(format));\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - Bytes to String: Failed to convert data', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $convertFormat(data: string, from: EncodingFormat, to: EncodingFormat): Result<{ result: string }> {\r\n  if (!$isStr(data)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Convert Format: Empty data',\r\n      desc: 'Data must be a non-empty string',\r\n    });\r\n  }\r\n\r\n  if (!ENCODING_FORMATS.includes(from) || !ENCODING_FORMATS.includes(to)) {\r\n    return $err({\r\n      msg: `Crypto NodeJS API - Convert Format: Unsupported format: from ${from} to ${to}`,\r\n      desc: 'Use base64, base64url, hex, utf8, or latin1',\r\n    });\r\n  }\r\n\r\n  const bytes = $convertStrToBytes(data, from);\r\n  if (bytes.error) return $err({ msg: bytes.error.message, desc: bytes.error.description });\r\n\r\n  const str = $convertBytesToStr(bytes.result, to);\r\n  if (str.error) return $err({ msg: str.error.message, desc: str.error.description });\r\n\r\n  return $ok({ result: str.result });\r\n}\r\n","import { Buffer } from 'node:buffer';\r\nimport nodeCrypto from 'node:crypto';\r\nimport { DIGEST_ALGORITHMS, ENCRYPTION_ALGORITHMS, PASSWORD_HASHING } from '~/helpers/consts';\r\nimport { $err, $fmtError, $ok, type Result } from '~/helpers/error';\r\nimport { $parseToObj, $stringifyObj } from '~/helpers/object';\r\nimport type { NodeSecretKey } from '~/helpers/types';\r\nimport { $isStr, isNodeSecretKey, matchPattern } from '~/helpers/validate';\r\nimport { $convertBytesToStr, $convertStrToBytes } from './node-encode';\r\n\r\nexport function $generateUuid(): Result<string> {\r\n  try {\r\n    return $ok(nodeCrypto.randomUUID());\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - UUID Generation: Failed to generate UUID', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $createSecretKey(key: string): Result<{ result: NodeSecretKey }> {\r\n  if (!$isStr(key)) {\r\n    return $err({ msg: 'Crypto NodeJS API - Key Generation: Empty key', desc: 'Key must be a non-empty string' });\r\n  }\r\n\r\n  try {\r\n    const derivedKey = nodeCrypto.hkdfSync(\r\n      DIGEST_ALGORITHMS.sha256.node,\r\n      key.normalize('NFKC'),\r\n      'cipher-kit-salt',\r\n      'cipher-kit',\r\n      ENCRYPTION_ALGORITHMS.aes256gcm.keyBytes,\r\n    );\r\n    const secretKey = nodeCrypto.createSecretKey(Buffer.from(derivedKey));\r\n    return $ok({ result: secretKey as NodeSecretKey });\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - Key Generation: Failed to create secret key', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $encrypt(data: string, secretKey: NodeSecretKey): Result<string> {\r\n  if (!$isStr(data)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Encryption: Empty data for encryption',\r\n      desc: 'Data must be a non-empty string',\r\n    });\r\n  }\r\n\r\n  if (!isNodeSecretKey(secretKey)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Encryption: Invalid encryption key',\r\n      desc: 'Expected a NodeKey (crypto.KeyObject)',\r\n    });\r\n  }\r\n\r\n  try {\r\n    const iv = nodeCrypto.randomBytes(ENCRYPTION_ALGORITHMS.aes256gcm.ivLength);\r\n    const cipher = nodeCrypto.createCipheriv(ENCRYPTION_ALGORITHMS.aes256gcm.node, secretKey, iv);\r\n    const encrypted = Buffer.concat([cipher.update(data, 'utf8'), cipher.final()]);\r\n    const tag = cipher.getAuthTag();\r\n\r\n    const ivStr = $convertBytesToStr(iv, 'base64url');\r\n    const cipherStr = $convertBytesToStr(encrypted, 'base64url');\r\n    const tagStr = $convertBytesToStr(tag, 'base64url');\r\n\r\n    if (ivStr.error || cipherStr.error || tagStr.error) {\r\n      return $err({\r\n        msg: 'Crypto NodeJS API - Encryption: Failed to convert IV or encrypted data or tag',\r\n        desc: `Conversion error: ${ivStr.error || cipherStr.error || tagStr.error}`,\r\n      });\r\n    }\r\n\r\n    return $ok(`${ivStr.result}.${cipherStr.result}.${tagStr.result}.`);\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - Encryption: Failed to encrypt data', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $decrypt(encrypted: string, secretKey: NodeSecretKey): Result<string> {\r\n  if (matchPattern(encrypted, 'node') === false) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Decryption: Invalid encrypted data format',\r\n      desc: 'Encrypted data must be in the format \"iv.cipher.tag.\"',\r\n    });\r\n  }\r\n\r\n  const [iv, cipher, tag] = encrypted.split('.', 4);\r\n  if (!$isStr(iv) || !$isStr(cipher) || !$isStr(tag)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Decryption: Invalid encrypted data',\r\n      desc: 'Encrypted data must contain valid IV, encrypted data, and tag components',\r\n    });\r\n  }\r\n\r\n  if (!isNodeSecretKey(secretKey)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Decryption: Invalid decryption key',\r\n      desc: 'Expected a NodeKey (crypto.KeyObject)',\r\n    });\r\n  }\r\n\r\n  const ivBytes = $convertStrToBytes(iv, 'base64url');\r\n  const cipherBytes = $convertStrToBytes(cipher, 'base64url');\r\n  const tagBytes = $convertStrToBytes(tag, 'base64url');\r\n\r\n  if (ivBytes.error || cipherBytes.error || tagBytes.error) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Decryption: Failed to convert IV or encrypted data or tag',\r\n      desc: `Conversion error: ${ivBytes.error || cipherBytes.error || tagBytes.error}`,\r\n    });\r\n  }\r\n\r\n  try {\r\n    const decipher = nodeCrypto.createDecipheriv(ENCRYPTION_ALGORITHMS.aes256gcm.node, secretKey, ivBytes.result);\r\n    decipher.setAuthTag(tagBytes.result);\r\n    const decrypted = Buffer.concat([decipher.update(cipherBytes.result), decipher.final()]);\r\n\r\n    return $convertBytesToStr(decrypted, 'utf8');\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - Decryption: Failed to decrypt data', desc: $fmtError(error) });\r\n  }\r\n}\r\nexport function $encryptObj<T extends object = Record<string, unknown>>(\r\n  data: T,\r\n  secretKey: NodeSecretKey,\r\n): Result<string> {\r\n  const { result, error } = $stringifyObj(data);\r\n  if (error) return $err(error);\r\n  return $encrypt(result, secretKey);\r\n}\r\n\r\nexport function $decryptObj<T extends object = Record<string, unknown>>(\r\n  encrypted: string,\r\n  secretKey: NodeSecretKey,\r\n): Result<{ result: T }> {\r\n  const { result, error } = $decrypt(encrypted, secretKey);\r\n  if (error) return $err(error);\r\n  return $parseToObj<T>(result);\r\n}\r\n\r\nexport function $hash(data: string): Result<string> {\r\n  if (!$isStr(data, 0)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Hashing: Empty data for hashing',\r\n      desc: 'Data must be a non-empty string',\r\n    });\r\n  }\r\n\r\n  try {\r\n    const hashed = nodeCrypto.createHash(DIGEST_ALGORITHMS.sha256.node).update(data).digest();\r\n    return $convertBytesToStr(hashed, 'base64url');\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - Hashing: Failed to hash data with Crypto NodeJS', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $hashPassword(password: string): Result<{ hash: string; salt: string }> {\r\n  if (!$isStr(password)) {\r\n    return $err({\r\n      msg: 'Crypto NodeJS API - Password Hashing: Empty password for hashing',\r\n      desc: 'Password must be a non-empty string',\r\n    });\r\n  }\r\n\r\n  try {\r\n    const salt = nodeCrypto.randomBytes(PASSWORD_HASHING.pbkdf2.saltLength);\r\n    const hash = nodeCrypto.pbkdf2Sync(\r\n      password.normalize('NFKC'),\r\n      salt,\r\n      PASSWORD_HASHING.pbkdf2.iterations,\r\n      PASSWORD_HASHING.pbkdf2.keyLength,\r\n      DIGEST_ALGORITHMS.sha512.node,\r\n    );\r\n\r\n    return $ok({ salt: salt.toString('base64url'), hash: hash.toString('base64url') });\r\n  } catch (error) {\r\n    return $err({ msg: 'Crypto NodeJS API - Password Hashing: Failed to hash password', desc: $fmtError(error) });\r\n  }\r\n}\r\n\r\nexport function $verifyPassword(password: string, hashedPassword: string, salt: string): boolean {\r\n  if (!$isStr(password) || !$isStr(hashedPassword) || !$isStr(salt)) return false;\r\n\r\n  const saltBytes = $convertStrToBytes(salt, 'base64url');\r\n  if (saltBytes.error) return false;\r\n\r\n  const hashedPasswordBytes = $convertStrToBytes(hashedPassword, 'base64url');\r\n  if (hashedPasswordBytes.error) return false;\r\n\r\n  try {\r\n    return nodeCrypto.timingSafeEqual(\r\n      nodeCrypto.pbkdf2Sync(\r\n        password.normalize('NFKC'),\r\n        saltBytes.result,\r\n        PASSWORD_HASHING.pbkdf2.iterations,\r\n        PASSWORD_HASHING.pbkdf2.keyLength,\r\n        DIGEST_ALGORITHMS.sha512.node,\r\n      ),\r\n      hashedPasswordBytes.result,\r\n    );\r\n  } catch {\r\n    return false;\r\n  }\r\n}\r\n"]}