tiny-essentials 1.2.0 → 1.2.1

package/dist/TinyEssentials.js

@@ -9183,16 +9183,17 @@ pss.create = function(options) {
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
+var __webpack_unused_export__;
 
 
 // eslint-disable-next-line no-multi-assign
-exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = __webpack_require__(3209);
+exports.po = __webpack_unused_export__ = __webpack_unused_export__ = /* unused reexport */ __webpack_require__(3209);
 
 // eslint-disable-next-line no-multi-assign
-exports.createHash = exports.Hash = __webpack_require__(7108);
+__webpack_unused_export__ = /* unused reexport */ __webpack_require__(7108);
 
 // eslint-disable-next-line no-multi-assign
-exports.createHmac = exports.Hmac = __webpack_require__(3507);
+__webpack_unused_export__ = /* unused reexport */ __webpack_require__(3507);
 
 var algos = __webpack_require__(5715);
 var algoKeys = Object.keys(algos);
@@ -9206,50 +9207,50 @@ var hashes = [
 	'rmd160'
 ].concat(algoKeys);
 
-exports.getHashes = function () {
+__webpack_unused_export__ = function () {
 	return hashes;
 };
 
 var p = __webpack_require__(8396);
-exports.pbkdf2 = p.pbkdf2;
-exports.pbkdf2Sync = p.pbkdf2Sync;
+__webpack_unused_export__ = p.pbkdf2;
+__webpack_unused_export__ = p.pbkdf2Sync;
 
 var aes = __webpack_require__(125);
 
-exports.Cipher = aes.Cipher;
-exports.createCipher = aes.createCipher;
-exports.Cipheriv = aes.Cipheriv;
-exports.createCipheriv = aes.createCipheriv;
-exports.Decipher = aes.Decipher;
-exports.createDecipher = aes.createDecipher;
-exports.Decipheriv = aes.Decipheriv;
-exports.createDecipheriv = aes.createDecipheriv;
-exports.getCiphers = aes.getCiphers;
-exports.listCiphers = aes.listCiphers;
+__webpack_unused_export__ = aes.Cipher;
+__webpack_unused_export__ = aes.createCipher;
+__webpack_unused_export__ = aes.Cipheriv;
+exports.Tt = aes.createCipheriv;
+__webpack_unused_export__ = aes.Decipher;
+__webpack_unused_export__ = aes.createDecipher;
+__webpack_unused_export__ = aes.Decipheriv;
+exports._7 = aes.createDecipheriv;
+__webpack_unused_export__ = aes.getCiphers;
+__webpack_unused_export__ = aes.listCiphers;
 
 var dh = __webpack_require__(5380);
 
-exports.DiffieHellmanGroup = dh.DiffieHellmanGroup;
-exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
-exports.getDiffieHellman = dh.getDiffieHellman;
-exports.createDiffieHellman = dh.createDiffieHellman;
-exports.DiffieHellman = dh.DiffieHellman;
+__webpack_unused_export__ = dh.DiffieHellmanGroup;
+__webpack_unused_export__ = dh.createDiffieHellmanGroup;
+__webpack_unused_export__ = dh.getDiffieHellman;
+__webpack_unused_export__ = dh.createDiffieHellman;
+__webpack_unused_export__ = dh.DiffieHellman;
 
 var sign = __webpack_require__(20);
 
-exports.createSign = sign.createSign;
-exports.Sign = sign.Sign;
-exports.createVerify = sign.createVerify;
-exports.Verify = sign.Verify;
+__webpack_unused_export__ = sign.createSign;
+__webpack_unused_export__ = sign.Sign;
+__webpack_unused_export__ = sign.createVerify;
+__webpack_unused_export__ = sign.Verify;
 
-exports.createECDH = __webpack_require__(1324);
+/* unused reexport */ __webpack_require__(1324);
 
 var publicEncrypt = __webpack_require__(7168);
 
-exports.publicEncrypt = publicEncrypt.publicEncrypt;
-exports.privateEncrypt = publicEncrypt.privateEncrypt;
-exports.publicDecrypt = publicEncrypt.publicDecrypt;
-exports.privateDecrypt = publicEncrypt.privateDecrypt;
+__webpack_unused_export__ = publicEncrypt.publicEncrypt;
+__webpack_unused_export__ = publicEncrypt.privateEncrypt;
+__webpack_unused_export__ = publicEncrypt.publicDecrypt;
+__webpack_unused_export__ = publicEncrypt.privateDecrypt;
 
 // the least I can do is make error messages for the rest of the node.js/crypto api.
 // [
@@ -9262,14 +9263,14 @@ exports.privateDecrypt = publicEncrypt.privateDecrypt;
 
 var rf = __webpack_require__(6983);
 
-exports.randomFill = rf.randomFill;
-exports.randomFillSync = rf.randomFillSync;
+__webpack_unused_export__ = rf.randomFill;
+__webpack_unused_export__ = rf.randomFillSync;
 
-exports.createCredentials = function () {
+__webpack_unused_export__ = function () {
 	throw new Error('sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
 };
 
-exports.constants = {
+__webpack_unused_export__ = {
 	DH_CHECK_P_NOT_SAFE_PRIME: 2,
 	DH_CHECK_P_NOT_PRIME: 1,
 	DH_UNABLE_TO_CHECK_GENERATOR: 4,
@@ -75733,6 +75734,9 @@ __webpack_require__.d(__webpack_exports__, {
  * });
  */
 async function asyncReplace(str, regex, asyncFn) {
+  /**
+   * @type {any[]}
+   */
   const promises = [];
 
   // Collect promises
@@ -75764,7 +75768,7 @@ class TinyLevelUp {
 
   /**
    * Validates and adjusts the user's level based on their current experience.
-   * @param {Object} user - The user object containing experience and level properties.
+   * @param {{ exp: number, level: number, totalExp: any }} user - The user object containing experience and level properties.
    * @returns {Object} The updated user object.
    */
   expValidator(user) {
@@ -75794,7 +75798,7 @@ class TinyLevelUp {
 
   /**
    * Calculates the total experience based on the user's level.
-   * @param {Object} user - The user object containing experience and level properties.
+   * @param {{ exp: number, level: number }} user - The user object containing experience and level properties.
    * @returns {number} The total experience of the user.
    */
   getTotalExp(user) {
@@ -75815,7 +75819,7 @@ class TinyLevelUp {
 
   /**
    * Gets the experience points required to reach the next level.
-   * @param {Object} user - The user object containing the level.
+   * @param {{ level: number }} user - The user object containing the level.
    * @returns {number} The experience required for the next level.
    */
   progress(user) {
@@ -75824,7 +75828,7 @@ class TinyLevelUp {
 
   /**
    * Gets the experience points required to reach the next level.
-   * @param {Object} user - The user object containing the level.
+   * @param {{ level: number }} user - The user object containing the level.
    * @returns {number} The experience required for the next level.
    */
   getProgress(user) {
@@ -75833,7 +75837,7 @@ class TinyLevelUp {
 
   /**
    * Sets the experience value for the user, adjusting their level if necessary.
-   * @param {Object} user - The user object.
+   * @param {{ exp: number, level: number, totalExp: any }} user - The user object.
    * @param {number} value - The new experience value to set.
    * @returns {Object} The updated user object.
    */
@@ -75846,9 +75850,9 @@ class TinyLevelUp {
 
   /**
    * Adds experience to the user, adjusting their level if necessary.
-   * @param {Object} user - The user object.
+   * @param {{ exp: number, level: number, totalExp: any }} user - The user object.
    * @param {number} extraExp - Additional experience to be added.
-   * @param {string} type - Type of addition ('add' or 'extra').
+   * @param {'add' | 'extra'} type - Type of addition ('add' or 'extra').
    * @param {number} multi - Multiplier for experience generation.
    * @returns {Object} The updated user object.
    */
@@ -75863,9 +75867,9 @@ class TinyLevelUp {
 
   /**
    * Removes experience from the user, adjusting their level if necessary.
-   * @param {Object} user - The user object.
+   * @param {{ exp: number, level: number, totalExp: any }} user - The user object.
    * @param {number} extraExp - Experience to remove.
-   * @param {string} type - Type of removal ('add' or 'extra').
+   * @param {'add' | 'extra'} type - Type of removal ('add' or 'extra').
    * @param {number} multi - Multiplier for experience generation.
    * @returns {Object} The updated user object.
    */
@@ -75922,7 +75926,8 @@ function shuffleArray(items) {
 function getTimeDuration(timeData = new Date(), durationType = 'asSeconds', now = null) {
   if (timeData instanceof Date) {
     const currentTime = now instanceof Date ? now : new Date();
-    const diffMs = timeData - currentTime;
+    /** @type {number} */
+    const diffMs = timeData.getTime() - currentTime.getTime();
 
     switch (durationType) {
       case 'asMilliseconds':
@@ -75967,6 +75972,17 @@ function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
     seconds: index >= 0,
   };
 
+  /**
+   * @type {{
+   *   years: number|NaN,
+   *   months: number|NaN,
+   *   days: number|NaN,
+   *   hours: number|NaN,
+   *   minutes: number|NaN,
+   *   seconds: number|NaN,
+   *   total: number|NaN
+   * }}
+   */
   const parts = {
     years: include.years ? 0 : NaN,
     months: include.months ? 0 : NaN,
@@ -75987,8 +76003,11 @@ function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
     // Years
     if (include.years) {
       while (
-        new Date(workingDate.getFullYear() + 1, workingDate.getMonth(), workingDate.getDate()) <=
-        targetDate
+        new Date(
+          workingDate.getFullYear() + 1,
+          workingDate.getMonth(),
+          workingDate.getDate(),
+        ).getTime() <= targetDate.getTime()
       ) {
         workingDate.setFullYear(workingDate.getFullYear() + 1);
         parts.years++;
@@ -75998,8 +76017,11 @@ function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
     // Months
     if (include.months) {
       while (
-        new Date(workingDate.getFullYear(), workingDate.getMonth() + 1, workingDate.getDate()) <=
-        targetDate
+        new Date(
+          workingDate.getFullYear(),
+          workingDate.getMonth() + 1,
+          workingDate.getDate(),
+        ).getTime() <= targetDate.getTime()
       ) {
         workingDate.setMonth(workingDate.getMonth() + 1);
         parts.months++;
@@ -76009,15 +76031,18 @@ function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
     // Days
     if (include.days) {
       while (
-        new Date(workingDate.getFullYear(), workingDate.getMonth(), workingDate.getDate() + 1) <=
-        targetDate
+        new Date(
+          workingDate.getFullYear(),
+          workingDate.getMonth(),
+          workingDate.getDate() + 1,
+        ).getTime() <= targetDate.getTime()
       ) {
         workingDate.setDate(workingDate.getDate() + 1);
         parts.days++;
       }
     }
 
-    remaining = Math.floor((targetDate - workingDate) / 1000);
+    remaining = Math.floor((targetDate.getTime() - workingDate.getTime()) / 1000);
   }
 
   if (include.hours) {
@@ -76046,7 +76071,16 @@ function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
 
   parts.total = +(totalMap[level] || 0).toFixed(2).replace(/\.00$/, '');
 
-  const pad = (n) => (isNaN(n) ? 'NaN' : String(n).padStart(2, '0'));
+  /**
+   * Pads a number to ensure it is at least two digits long, using leading zeros if necessary.
+   *
+   * @param {number|string} n - The number or string to pad.
+   * @returns {string} The padded string.
+   */
+  const pad = (n) => {
+    const num = typeof n === 'string' ? parseInt(n) : n;
+    return Number.isNaN(num) ? 'NaN' : String(num).padStart(2, '0');
+  };
 
   const timeString = [
     include.hours ? pad(parts.hours) : null,
@@ -76057,14 +76091,14 @@ function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
     .join(':');
 
   return format
-    .replace(/\{years\}/g, parts.years)
-    .replace(/\{months\}/g, parts.months)
-    .replace(/\{days\}/g, parts.days)
+    .replace(/\{years\}/g, String(parts.years))
+    .replace(/\{months\}/g, String(parts.months))
+    .replace(/\{days\}/g, String(parts.days))
     .replace(/\{hours\}/g, pad(parts.hours))
     .replace(/\{minutes\}/g, pad(parts.minutes))
     .replace(/\{seconds\}/g, pad(parts.seconds))
     .replace(/\{time\}/g, timeString)
-    .replace(/\{total\}/g, parts.total)
+    .replace(/\{total\}/g, String(parts.total))
     .trim();
 }
 
@@ -76169,6 +76203,9 @@ const typeValidator = {
     /** Checks if the value is a Buffer. */
     buffer: (val) => typeof buffer.Buffer !== 'undefined' && buffer.Buffer.isBuffer(val),
 
+    /** Checks if the value is a File. */
+    file: (val) => typeof File !== 'undefined' && val instanceof File,
+
     /** Checks if the value is a Html Element. */
     htmlelement: (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
 
@@ -76188,6 +76225,7 @@ const typeValidator = {
     'function',
     'array',
     'buffer',
+    'file',
     'date',
     'regexp',
     'map',
@@ -76406,7 +76444,7 @@ function getSimplePerc(price, percentage) {
 function getAge(timeData = 0, now = null) {
   if (typeof timeData !== 'undefined' && timeData !== null && timeData !== 0) {
     const birthDate = new Date(timeData);
-    if (isNaN(birthDate)) return null;
+    if (Number.isNaN(birthDate.getTime())) return null;
 
     const currentDate = now instanceof Date ? now : new Date();
 
@@ -76493,8 +76531,8 @@ class TinyCrypto {
    *
    * @param {Object} [options={}] - Configuration options for encryption and decryption.
    * @param {string} [options.algorithm='aes-256-gcm'] - The encryption algorithm to use. Recommended: 'aes-256-gcm' for authenticated encryption.
-   * @param {string} [options.outputEncoding='hex'] - The encoding used when returning encrypted data (e.g., 'hex', 'base64').
-   * @param {string} [options.inputEncoding='utf8'] - The encoding used for plaintext inputs (e.g., 'utf8').
+   * @param {BufferEncoding} [options.outputEncoding='hex'] - The encoding used when returning encrypted data (e.g., 'hex', 'base64').
+   * @param {BufferEncoding} [options.inputEncoding='utf8'] - The encoding used for plaintext inputs (e.g., 'utf8').
    * @param {number} [options.authTagLength=16] - The length of the authentication tag used in GCM mode. Usually 16 for AES-256-GCM.
    * @param {Buffer} [options.key] - Optional 32-byte cryptographic key. If not provided, a random key is generated.
    *
@@ -76504,15 +76542,17 @@ class TinyCrypto {
    * const crypto = new CryptoManager({
    *   algorithm: 'aes-256-gcm',
    *   outputEncoding: 'base64',
-   *   key: crypto.randomBytes(32),
+   *   key: randomBytes(32),
    * });
    */
   constructor(options = {}) {
     this.algorithm = options.algorithm || 'aes-256-gcm';
-    this.outputEncoding = options.outputEncoding || 'hex';
-    this.inputEncoding = options.inputEncoding || 'utf8';
     this.authTagLength = options.authTagLength || 16;
     this.key = options.key || this.generateKey();
+    /** @type {BufferEncoding} */
+    this.outputEncoding = options.outputEncoding || 'hex';
+    /** @type {BufferEncoding} */
+    this.inputEncoding = options.inputEncoding || 'utf8';
   }
 
   /**
@@ -76526,7 +76566,7 @@ class TinyCrypto {
    * const customKey = cryptoManager.generateKey(16); // Generates a 16-byte key (e.g. for AES-128)
    */
   generateKey(value = 32) {
-    return crypto_browserify.randomBytes(value); // 256-bit
+    return (0,crypto_browserify/* randomBytes */.po)(value); // 256-bit
   }
 
   /**
@@ -76540,7 +76580,7 @@ class TinyCrypto {
    * const customIV = cryptoManager.generateIV(16); // Generates a 16-byte IV if needed for other algorithms
    */
   generateIV(value = 12) {
-    return crypto_browserify.randomBytes(value); // 96-bit padrão para GCM
+    return (0,crypto_browserify/* randomBytes */.po)(value); // 96-bit padrão para GCM
   }
 
   /**
@@ -76550,10 +76590,7 @@ class TinyCrypto {
    *
    * @param {*} data - The data to encrypt. Can be of any supported type (string, number, boolean, Date, JSON, etc.).
    * @param {Buffer} [iv=this.generateIV()] - Optional Initialization Vector (IV). If not provided, a secure random IV is generated.
-   * @returns {Object} An object containing:
-   * - `iv` {string} - The IV used, encoded with the output encoding.
-   * - `encrypted` {string} - The encrypted payload.
-   * - `authTag` {string} - The authentication tag used to verify the integrity of the ciphertext.
+   * @returns {EncryptedDataParams} An object containing the encrypted data.
    *
    * @example
    * const result = cryptoManager.encrypt('Hello, world!');
@@ -76566,31 +76603,41 @@ class TinyCrypto {
   encrypt(data, iv = this.generateIV()) {
     const plainText = this.#serialize(data);
 
-    const cipher = crypto_browserify.createCipheriv(this.algorithm, this.key, iv, {
+    const cipher = (0,crypto_browserify/* createCipheriv */.Tt)(this.algorithm, this.key, iv, {
+      // @ts-ignore
       authTagLength: this.authTagLength,
     });
 
+    // @ts-ignore
     let encrypted = cipher.update(plainText, this.inputEncoding);
+    // @ts-ignore
     encrypted = buffer.Buffer.concat([encrypted, cipher.final()]);
     const authTag = cipher.getAuthTag();
 
     return {
+      // @ts-ignore
       iv: iv.toString(this.outputEncoding),
+      // @ts-ignore
       encrypted: encrypted.toString(this.outputEncoding),
+      // @ts-ignore
       authTag: authTag.toString(this.outputEncoding),
     };
   }
 
+  /**
+   * @typedef {Object} EncryptedDataParams
+   * @property {string} iv - The Initialization Vector (IV) used in encryption, encoded with the output encoding.
+   * @property {string} encrypted - The encrypted data to decrypt, encoded with the output encoding.
+   * @property {string} authTag - The authentication tag used to verify the integrity of the encrypted data.
+   */
+
   /**
    * Decrypts a previously encrypted value.
    *
    * The method checks the integrity of the data using the authentication tag (`authTag`) and ensures the data is properly decrypted.
    * After decryption, it automatically deserializes the data back to its original type.
    *
-   * @param {Object} params - An object containing the encrypted data:
-   *   - `iv` {string} - The Initialization Vector (IV) used in encryption, encoded with the output encoding.
-   *   - `encrypted` {string} - The encrypted data to decrypt, encoded with the output encoding.
-   *   - `authTag` {string} - The authentication tag used to verify the integrity of the encrypted data.
+   * @param {EncryptedDataParams} params - An object containing the encrypted data.
    * @param {string|null} [expectedType=null] - Optionally specify the expected type of the decrypted data. If provided, the method will validate the type of the deserialized value.
    * @returns {*} The decrypted value, which will be the original type of the data before encryption.
    * @throws {Error} Throws if the authentication tag doesn't match or the data has been tampered with.
@@ -76610,13 +76657,17 @@ class TinyCrypto {
     const encryptedBuffer = buffer.Buffer.from(encrypted, this.outputEncoding);
     const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
-    const decipher = crypto_browserify.createDecipheriv(this.algorithm, this.key, ivBuffer, {
+    const decipher = (0,crypto_browserify/* createDecipheriv */._7)(this.algorithm, this.key, ivBuffer, {
+      // @ts-ignore
       authTagLength: this.authTagLength,
     });
 
     decipher.setAuthTag(authTagBuffer);
 
+    /** @type {string} */
+    // @ts-ignore
     let decrypted = decipher.update(encryptedBuffer, null, this.inputEncoding);
+    // @ts-ignore
     decrypted += decipher.final(this.inputEncoding);
     const { value, type } = this.#deserialize(decrypted);
 
@@ -76630,10 +76681,7 @@ class TinyCrypto {
    * This method decrypts the encrypted data and extracts its type information without fully deserializing the value.
    * It is useful when you need to verify the type of the encrypted data before fully decrypting it.
    *
-   * @param {Object} params - An object containing the encrypted data:
-   *   - `iv` {string} - The Initialization Vector (IV) used in encryption, encoded with the output encoding.
-   *   - `encrypted` {string} - The encrypted data to decrypt, encoded with the output encoding.
-   *   - `authTag` {string} - The authentication tag used to verify the integrity of the encrypted data.
+   * @param {EncryptedDataParams} params - An object containing the encrypted data.
    * @returns {string} The type of the original data (e.g., 'string', 'number', 'date', etc.).
    *
    * @example
@@ -76650,13 +76698,16 @@ class TinyCrypto {
     const encryptedBuffer = buffer.Buffer.from(encrypted, this.outputEncoding);
     const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
-    const decipher = crypto_browserify.createDecipheriv(this.algorithm, this.key, ivBuffer, {
+    const decipher = (0,crypto_browserify/* createDecipheriv */._7)(this.algorithm, this.key, ivBuffer, {
+      // @ts-ignore
       authTagLength: this.authTagLength,
     });
 
     decipher.setAuthTag(authTagBuffer);
 
+    // @ts-ignore
     let decrypted = decipher.update(encryptedBuffer, null, this.inputEncoding);
+    // @ts-ignore
     decrypted += decipher.final(this.inputEncoding);
 
     const { type } = this.#deserialize(decrypted);
@@ -76746,10 +76797,12 @@ class TinyCrypto {
   async loadConfigFromFile(file) {
     if (isBrowser) {
       return new Promise((resolve, reject) => {
+        if (!(file instanceof File))
+          return reject(new Error('In browser, the file must be a File object'));
         const reader = new FileReader();
         reader.onload = () => {
           try {
-            const config = JSON.parse(reader.result);
+            const config = typeof reader.result === 'string' ? JSON.parse(reader.result) : {};
             resolve(this.importConfig(config));
           } catch (err) {
             reject(new Error('Invalid config JSON file'));
@@ -76759,7 +76812,7 @@ class TinyCrypto {
         reader.readAsText(file);
       });
     } else {
-      const raw = fs_ignored_.readFileSync(file, 'utf8');
+      const raw = fs_ignored_.readFileSync(/** @type {string} */ (file), 'utf8');
       const config = JSON.parse(raw);
       return this.importConfig(config);
     }
@@ -76791,9 +76844,11 @@ class TinyCrypto {
   async loadKeyFromFile(file) {
     if (isBrowser) {
       return new Promise((resolve, reject) => {
+        if (!(file instanceof File))
+          return reject(new Error('In browser, the file must be a File object'));
         const reader = new FileReader();
         reader.onload = () => {
-          const hexKey = reader.result.trim();
+          const hexKey = typeof reader.result === 'string' ? reader.result.trim() : '';
           const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
           this.key = keyBuffer;
           resolve(keyBuffer);
@@ -76802,7 +76857,7 @@ class TinyCrypto {
         reader.readAsText(file);
       });
     } else {
-      const hexKey = fs_ignored_.readFileSync(file, 'utf8');
+      const hexKey = fs_ignored_.readFileSync(/** @type {string} */ (file), 'utf8');
       const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
       this.key = keyBuffer;
       return keyBuffer;
@@ -76848,8 +76903,8 @@ class TinyCrypto {
    *
    * @param {Object} config - The configuration object to import.
    * @param {string} config.algorithm - The encryption algorithm (e.g., 'aes-256-gcm').
-   * @param {string} config.outputEncoding - The output encoding format (e.g., 'hex').
-   * @param {string} config.inputEncoding - The input encoding format (e.g., 'utf8').
+   * @param {BufferEncoding} config.outputEncoding - The output encoding format (e.g., 'hex').
+   * @param {BufferEncoding} config.inputEncoding - The input encoding format (e.g., 'utf8').
    * @param {number} config.authTagLength - The authentication tag length (e.g., 16).
    * @param {string} config.key - The cryptographic key in hexadecimal string format.
    *
@@ -76896,7 +76951,7 @@ class TinyCrypto {
    * Each key corresponds to a specific data type (e.g., 'number', 'date', 'buffer', etc.),
    * and the value is a function that serializes the data to a specific format.
    *
-   * @type {Object}
+   * @type {Record<string, (data: any) => string>}
    * @property {Function} weakmap - Throws an error as WeakMap cannot be serialized.
    * @property {Function} weakset - Throws an error as WeakSet cannot be serialized.
    * @property {Function} promise - Throws an error as Promise cannot be serialized.
@@ -76937,8 +76992,8 @@ class TinyCrypto {
     number: (data) => JSON.stringify({ __type: 'number', value: data }),
     boolean: (data) => JSON.stringify({ __type: 'boolean', value: data }),
     string: (data) => JSON.stringify({ __type: 'string', value: data }),
-    null: (data) => JSON.stringify({ __type: 'null' }),
-    undefined: (data) => JSON.stringify({ __type: 'undefined' }),
+    null: () => JSON.stringify({ __type: 'null' }),
+    undefined: () => JSON.stringify({ __type: 'undefined' }),
     map: (data) =>
       JSON.stringify({
         __type: 'map',
@@ -76963,7 +77018,7 @@ class TinyCrypto {
    * Each key corresponds to a specific data type (e.g., 'Date', 'BigInt', 'Buffer', etc.),
    * and the value is a function that deserializes the value to its original format.
    *
-   * @type {Object}
+   * @type {Record<string, (data: any) => any>}
    * @property {Function} regexp - Deserializes a regular expression from its string representation (e.g., `/pattern/flags`).
    * @property {Function} htmlelement - Deserializes an HTML element from its serialized outerHTML string (only works in browser environments).
    * @property {Function} date - Deserializes a date from its ISO string representation.
@@ -76990,14 +77045,14 @@ class TinyCrypto {
         throw new Error('HTMLElement deserialization is only supported in browsers');
       const div = document.createElement('div');
       div.innerHTML = value;
-      return div.firstElementChild;
+      return div;
     },
     date: (value) => new Date(value),
     bigint: (value) => BigInt(value),
     number: (value) => Number(value),
     boolean: (value) => Boolean(value),
-    null: (value) => null,
-    undefined: (value) => undefined,
+    null: () => null,
+    undefined: () => undefined,
     map: (value) => new Map(value),
     set: (value) => new Set(value),
     symbol: (value) => Symbol(value),
@@ -77018,7 +77073,8 @@ class TinyCrypto {
    */
   #serialize(data) {
     const type = objType(data) || 'undefined';
-    if (this.#valueConvertTypes[type]) return this.#valueConvertTypes[type](data);
+    if (typeof type === 'string' && this.#valueConvertTypes[type])
+      return this.#valueConvertTypes[type](data);
     throw new Error(`Unsupported data type for encryption: ${type}`);
   }
 
@@ -77069,7 +77125,6 @@ class TinyCrypto {
 
 
 
-
 /**
  * Determines if the environment is a browser.
  *
@@ -77099,7 +77154,6 @@ class TinyCertCrypto {
    * It supports multi-line content.
    *
    * @type {RegExp}
-   * @private
    */
   #certRegex = /-----BEGIN CERTIFICATE-----([\s\S]+?)-----END CERTIFICATE-----/;
 
@@ -77112,7 +77166,6 @@ class TinyCertCrypto {
    * It captures the key type (PUBLIC|PRIVATE) and the base64 content.
    *
    * @type {RegExp}
-   * @private
    */
   #keyRegex =
     /-----BEGIN\s+(?:RSA\s+)?(PUBLIC|PRIVATE)\s+KEY-----([\s\S]+?)-----END\s+(?:RSA\s+)?\1\s+KEY-----/;
@@ -77180,10 +77233,10 @@ class TinyCertCrypto {
    * This method is private and should not be called directly from outside.
    *
    * @returns {Promise<Object>} The loaded `node-forge` module.
-   * @private
    */
   async #fetchNodeForge() {
     if (!this.forge) {
+      // @ts-ignore
       const forge = await Promise.resolve(/* import() eager */).then(__webpack_require__.t.bind(__webpack_require__, 9547, 19));
       this.forge = forge.default;
     }
@@ -77205,7 +77258,6 @@ class TinyCertCrypto {
    * Assumes the module has already been loaded.
    *
    * @returns {Object} The `node-forge` module.
-   * @private
    */
   #getNodeForge() {
     return this.forge;
@@ -77228,13 +77280,12 @@ class TinyCertCrypto {
    * or `'unknown'` if the format is not recognized.
    *
    * @param {string} pemString - The PEM string to inspect.
-   * @returns {'certificate' | 'public_key' | 'private_key' | 'unknown'} The detected PEM type.
-   * @private
+   * @returns {string} The detected PEM type.
    */
   #detectPemType(pemString) {
     if (this.#certRegex.test(pemString)) return 'certificate';
     const keyMatch = this.#keyRegex.exec(pemString);
-    if (keyMatch) return keyMatch[1].toLowerCase() + '_key'; // "public_key" or "private_key"
+    if (keyMatch && typeof keyMatch[1] === 'string') return keyMatch[1].toLowerCase() + '_key'; // "public_key" or "private_key"
     return 'unknown';
   }
 
@@ -77244,13 +77295,9 @@ class TinyCertCrypto {
    * This method can only be used in Node.js environments. It throws an error if a certificate
    * or key is already loaded into the instance.
    *
-   * @param {Object} subjectFields - An object representing the subject fields of the certificate (e.g., CN, O, C).
+   * @param {Object<string, string>} subjectFields - An object representing the subject fields of the certificate (e.g., CN, O, C).
    * @param {Object} [options={}] - Optional configuration for key and certificate generation.
    * @param {number} [options.modulusLength=2048] - Length of the RSA key in bits.
-   * @param {Object} [options.publicKeyEncoding={ type: 'spki', format: 'pem' }] - Options for public key encoding.
-   * @param {Object} [options.privateKeyEncoding={ type: 'pkcs8', format: 'pem' }] - Options for private key encoding.
-   * @param {string} [options.publicKeyType] - Overrides `publicKeyEncoding.type` if provided.
-   * @param {string} [options.privateKeyType] - Overrides `privateKeyEncoding.type` if provided.
    * @param {number} [options.validityInYears=1] - Number of years the certificate will be valid.
    * @param {number} [options.randomBytesLength=16] - Number of random bytes to use for serial number generation.
    *
@@ -77263,34 +77310,26 @@ class TinyCertCrypto {
       throw new Error('A certificate is already loaded into the instance.');
 
     // Prepare cert
+    /**  @type {any} */
     const { pki } = await this.#fetchNodeForge();
-    const {
-      modulusLength = 2048,
-      publicKeyEncoding = { type: 'spki', format: 'pem' },
-      privateKeyEncoding = { type: 'pkcs8', format: 'pem' },
-      validityInYears = 1,
-      randomBytesLength = 16,
-    } = options;
-
-    // Value types
-    const publicKeyType = options.publicKeyType || publicKeyEncoding.type;
-    const privateKeyType = options.privateKeyType || privateKeyEncoding.type;
 
-    // Validator
-    if (TinyCertCrypto_isBrowser) throw new Error('generateKeyPair can only be used in Node.js environments');
+    /**
+     * @property {number} [modulusLength=2048] - The length of the RSA modulus (in bits). Default is 2048.
+     * @property {number} [validityInYears=1] - The validity period of the key pair in years. Default is 1 year.
+     * @property {number} [randomBytesLength=16] - The length of random bytes used in key generation. Default is 16 bytes.
+     */
+    const { modulusLength = 2048, validityInYears = 1, randomBytesLength = 16 } = options;
 
     // Generate keys
-    const { publicKey, privateKey } = crypto_browserify.generateKeyPairSync('rsa', {
-      modulusLength,
-      publicKeyEncoding: { ...publicKeyEncoding, type: publicKeyType },
-      privateKeyEncoding: { ...privateKeyEncoding, type: privateKeyType },
-    });
+    const { publicKey, privateKey } = pki.rsa.generateKeyPair(modulusLength);
+    const encodedPublicKey = pki.publicKeyToPem(publicKey);
+    const encodedPrivateKey = pki.privateKeyToPem(privateKey);
 
     // Get pem files
     const { cert, publicPem, privatePem } = this.#generateCertificate(
       subjectFields,
-      publicKey,
-      privateKey,
+      encodedPublicKey,
+      encodedPrivateKey,
       validityInYears,
       randomBytesLength,
     );
@@ -77302,26 +77341,33 @@ class TinyCertCrypto {
     this.publicCertPath = 'MEMORY';
     this.privateKeyPath = 'MEMORY';
     this.source = 'memory';
-    this.publicCertBuffer = publicKey;
-    this.privateKeyBuffer = privateKey;
+    this.publicCertBuffer = buffer.Buffer.from(encodedPublicKey);
+    this.privateKeyBuffer = buffer.Buffer.from(encodedPrivateKey);
 
     this.#loadX509Certificate(cert);
-    return { publicKey, privateKey, cert };
+    return { publicKey: encodedPublicKey, privateKey: encodedPrivateKey, cert };
   }
 
+  /**
+   * @typedef {Object} CertificateDetails
+   * @property {string} cert - The certificate in PEM format.
+   * @property {string} publicPem - The public key in PEM format.
+   * @property {string} privatePem - The private key in PEM format.
+   */
+
   /**
    * Generates a self-signed X.509 certificate using the given public and private RSA keys.
    *
    * This method creates a certificate, assigns the subject and issuer fields,
    * sets the validity period, and signs it with the private key.
    *
-   * @param {Object} subject - An object representing the subject/issuer fields (e.g., { CN: 'example.com' }).
+   * @param {Object<string, string>} subject - An object representing the subject/issuer fields (e.g., { CN: 'example.com' }).
    * @param {string} publicKey - The public key in PEM format.
    * @param {string} privateKey - The private key in PEM format.
    * @param {number} validityInYears - Number of years the certificate will remain valid.
    * @param {number} randomBytesLength - Number of random bytes used to generate the serial number.
    *
-   * @returns {Object} An object containing:
+   * @returns {CertificateDetails} An object containing:
    *   - {string} cert: The generated certificate in PEM format.
    *   - {Object} publicPem: The parsed public key object (from node-forge).
    *   - {Object} privatePem: The parsed private key object (from node-forge).
@@ -77333,7 +77379,9 @@ class TinyCertCrypto {
     const privatePem = pki.privateKeyFromPem(privateKey);
 
     cert.publicKey = publicPem;
-    cert.serialNumber = buffer.Buffer.from(crypto_browserify.randomBytes(randomBytesLength)).toString('hex');
+    cert.serialNumber = buffer.Buffer.from(this.forge.random.getBytesSync(randomBytesLength)).toString(
+      'hex',
+    );
     cert.validity.notBefore = new Date();
     cert.validity.notAfter = new Date();
     cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + validityInYears);
@@ -77374,8 +77422,21 @@ class TinyCertCrypto {
 
     // Load public key
     this.metadata = {};
+    /**  @type {any} */
     const { pki } = await this.#fetchNodeForge();
+
+    /**
+     * Loads the public key from a PEM-encoded certificate or public key.
+     *
+     * @param {string|null} publicPem - The PEM-encoded public key or certificate.
+     * @throws {Error} If the PEM string is not recognized or if the key cannot be parsed.
+     */
     const loadPublicKey = (publicPem) => {
+      if (typeof publicPem !== 'string')
+        throw new Error(
+          'Expected publicPem to be a string containing a PEM-encoded key or certificate.',
+        );
+
       // File type
       const fileType = this.#detectPemType(publicPem);
 
@@ -77391,12 +77452,29 @@ class TinyCertCrypto {
       else throw new Error('Public key is required to initialize');
     };
 
+    /**
+     * Loads the private key from a PEM-encoded private key.
+     *
+     * @param {string|null} privatePem - The PEM-encoded private key.
+     * @throws {Error} If the PEM string is not recognized or if the key cannot be parsed.
+     */
     const loadPrivateKey = (privatePem) => {
+      if (typeof privatePem !== 'string')
+        throw new Error('Expected privatePem to be a string containing a PEM-encoded private key.');
       const fileType = this.#detectPemType(privatePem);
       if (fileType === 'private_key') this.privateKey = pki.privateKeyFromPem(privatePem);
       else throw new Error('Private key is required to initialize');
     };
 
+    if (typeof this.publicCertPath !== 'string')
+      throw new TypeError(
+        `Expected 'publicCertPath' to be a string, but got ${typeof this.publicCertPath}`,
+      );
+    if (typeof this.privateKeyPath !== 'string')
+      throw new TypeError(
+        `Expected 'privateKeyPath' to be a string, but got ${typeof this.privateKeyPath}`,
+      );
+
     // Nodejs
     if (!TinyCertCrypto_isBrowser) {
       const usedPublicBuffer = !!this.publicCertBuffer;
@@ -77406,7 +77484,9 @@ class TinyCertCrypto {
       const publicPem = usedPublicBuffer
         ? typeof this.publicCertBuffer === 'string'
           ? this.publicCertBuffer
-          : this.publicCertBuffer.toString('utf-8')
+          : buffer.Buffer.isBuffer(this.publicCertBuffer)
+            ? this.publicCertBuffer.toString('utf-8')
+            : null
         : fs_ignored_.readFileSync(this.publicCertPath, 'utf-8');
       loadPublicKey(publicPem);
 
@@ -77415,7 +77495,9 @@ class TinyCertCrypto {
         const privatePem = usedPrivateBuffer
           ? typeof this.privateKeyBuffer === 'string'
             ? this.privateKeyBuffer
-            : this.privateKeyBuffer.toString('utf-8')
+            : buffer.Buffer.isBuffer(this.privateKeyBuffer)
+              ? this.privateKeyBuffer.toString('utf-8')
+              : null
           : fs_ignored_.readFileSync(this.privateKeyPath, 'utf-8');
 
         loadPrivateKey(privatePem);
@@ -77457,7 +77539,6 @@ class TinyCertCrypto {
    * This method supports both PEM strings and already-parsed Forge certificate objects.
    * The parsed certificate is saved to `this.publicCert` and its metadata is extracted to `this.metadata`.
    *
-   * @private
    * @param {string|object} certPem - A PEM-encoded certificate string or a `forge.pki.Certificate` object.
    * @throws {Error} If the certificate cannot be parsed or processed.
    */
@@ -77467,8 +77548,21 @@ class TinyCertCrypto {
       const cert = typeof certPem === 'string' ? pki.certificateFromPem(certPem) : certPem;
       this.publicCert = cert;
 
+      /**
+       * @typedef {Object} Attribute
+       * @property {string} name - The name of the attribute.
+       * @property {string} shortName - The short name of the attribute.
+       * @property {string} value - The value of the attribute.
+       */
+
+      /**
+       * @param {Array<Attribute>} attributes - The list of attributes, each containing `name`, `shortName`, and `value`.
+       * @returns {{names: { [key: string]: string }, shortNames: { [key: string]: string }, raw: string}} The processed data containing the organized attributes.
+       */
       const insertData = (attributes) => {
+        /** @type {{[key: string]: string}} */
         const names = {};
+        /** @type {{[key: string]: string}} */
         const shortNames = {};
         const raw = attributes.map((attr) => `${attr.shortName}=${attr.value}`).join(',');
         for (const item of attributes) {
@@ -77486,7 +77580,9 @@ class TinyCertCrypto {
         validTo: cert.validity.notAfter,
       };
     } catch (err) {
-      throw new Error('Failed to parse X.509 certificate in browser: ' + err.message);
+      throw new Error(
+        `Failed to parse X.509 certificate in browser: ${err instanceof Error && typeof err.message === 'string' ? err.message : 'Unknown error'}`,
+      );
     }
   }