tiny-essentials 1.2.0 → 1.2.1

package/dist/v1/libs/TinyCertCrypto.mjs

@@ -1,5 +1,4 @@
-import fs from 'fs';
-import crypto from 'crypto';
+import * as fs from 'fs';
 import { Buffer } from 'buffer';
 /**
  * Determines if the environment is a browser.
@@ -29,7 +28,6 @@ class TinyCertCrypto {
      * It supports multi-line content.
      *
      * @type {RegExp}
-     * @private
      */
     #certRegex = /-----BEGIN CERTIFICATE-----([\s\S]+?)-----END CERTIFICATE-----/;
     /**
@@ -41,7 +39,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-----/;
     /**
@@ -93,10 +90,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 import(/* webpackMode: "eager" */ 'node-forge');
             this.forge = forge.default;
         }
@@ -116,7 +113,6 @@ class TinyCertCrypto {
      * Assumes the module has already been loaded.
      *
      * @returns {Object} The `node-forge` module.
-     * @private
      */
     #getNodeForge() {
         return this.forge;
@@ -137,14 +133,13 @@ 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)
+        if (keyMatch && typeof keyMatch[1] === 'string')
             return keyMatch[1].toLowerCase() + '_key'; // "public_key" or "private_key"
         return 'unknown';
     }
@@ -154,13 +149,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.
      *
@@ -172,46 +163,50 @@ class TinyCertCrypto {
         if (this.publicKey || this.privateKey || this.publicCert)
             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 (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.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, validityInYears, randomBytesLength);
+        const { cert, publicPem, privatePem } = this.#generateCertificate(subjectFields, encodedPublicKey, encodedPrivateKey, validityInYears, randomBytesLength);
         // Insert data
         this.publicKey = publicPem;
         this.privateKey = privatePem;
         this.publicCertPath = 'MEMORY';
         this.privateKeyPath = 'MEMORY';
         this.source = 'memory';
-        this.publicCertBuffer = publicKey;
-        this.privateKeyBuffer = privateKey;
+        this.publicCertBuffer = Buffer.from(encodedPublicKey);
+        this.privateKeyBuffer = 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).
@@ -222,7 +217,7 @@ class TinyCertCrypto {
         const publicPem = pki.publicKeyFromPem(publicKey);
         const privatePem = pki.privateKeyFromPem(privateKey);
         cert.publicKey = publicPem;
-        cert.serialNumber = Buffer.from(crypto.randomBytes(randomBytesLength)).toString('hex');
+        cert.serialNumber = 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);
@@ -259,8 +254,17 @@ class TinyCertCrypto {
             throw new Error('Public certificate is required to initialize');
         // 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);
             // Cert
@@ -275,13 +279,25 @@ 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 (!isBrowser) {
             const usedPublicBuffer = !!this.publicCertBuffer;
@@ -290,7 +306,9 @@ class TinyCertCrypto {
             const publicPem = usedPublicBuffer
                 ? typeof this.publicCertBuffer === 'string'
                     ? this.publicCertBuffer
-                    : this.publicCertBuffer.toString('utf-8')
+                    : Buffer.isBuffer(this.publicCertBuffer)
+                        ? this.publicCertBuffer.toString('utf-8')
+                        : null
                 : fs.readFileSync(this.publicCertPath, 'utf-8');
             loadPublicKey(publicPem);
             // Private Key
@@ -298,7 +316,9 @@ class TinyCertCrypto {
                 const privatePem = usedPrivateBuffer
                     ? typeof this.privateKeyBuffer === 'string'
                         ? this.privateKeyBuffer
-                        : this.privateKeyBuffer.toString('utf-8')
+                        : Buffer.isBuffer(this.privateKeyBuffer)
+                            ? this.privateKeyBuffer.toString('utf-8')
+                            : null
                     : fs.readFileSync(this.privateKeyPath, 'utf-8');
                 loadPrivateKey(privatePem);
             }
@@ -334,7 +354,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.
      */
@@ -343,8 +362,20 @@ class TinyCertCrypto {
             const { pki } = this.forge;
             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) {
@@ -362,7 +393,7 @@ class TinyCertCrypto {
             };
         }
         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'}`);
         }
     }
     /**

package/dist/v1/libs/TinyCrypto.cjs

@@ -5,6 +5,25 @@ var fs = require('fs');
 var buffer = require('buffer');
 var objFilter = require('../basics/objFilter.cjs');
 
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+
 /**
  * Determines if the environment is a browser.
  *
@@ -30,8 +49,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.
    *
@@ -41,15 +60,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';
   }
 
   /**
@@ -87,10 +108,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!');
@@ -104,30 +122,40 @@ class TinyCrypto {
     const plainText = this.#serialize(data);
 
     const cipher = crypto.createCipheriv(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.
@@ -148,12 +176,16 @@ class TinyCrypto {
     const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
     const decipher = crypto.createDecipheriv(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);
 
@@ -167,10 +199,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
@@ -188,12 +217,15 @@ class TinyCrypto {
     const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
     const decipher = crypto.createDecipheriv(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);
@@ -226,7 +258,7 @@ class TinyCrypto {
       a.download = filename;
       a.click();
       URL.revokeObjectURL(url);
-    } else fs.writeFileSync(filename, data);
+    } else fs__namespace.writeFileSync(filename, data);
   }
 
   /**
@@ -255,7 +287,7 @@ class TinyCrypto {
       a.download = filename;
       a.click();
       URL.revokeObjectURL(url);
-    } else fs.writeFileSync(filename, configData);
+    } else fs__namespace.writeFileSync(filename, configData);
   }
 
   /**
@@ -283,10 +315,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'));
@@ -296,7 +330,7 @@ class TinyCrypto {
         reader.readAsText(file);
       });
     } else {
-      const raw = fs.readFileSync(file, 'utf8');
+      const raw = fs__namespace.readFileSync(/** @type {string} */ (file), 'utf8');
       const config = JSON.parse(raw);
       return this.importConfig(config);
     }
@@ -328,9 +362,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);
@@ -339,7 +375,7 @@ class TinyCrypto {
         reader.readAsText(file);
       });
     } else {
-      const hexKey = fs.readFileSync(file, 'utf8');
+      const hexKey = fs__namespace.readFileSync(/** @type {string} */ (file), 'utf8');
       const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
       this.key = keyBuffer;
       return keyBuffer;
@@ -385,8 +421,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.
    *
@@ -433,7 +469,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.
@@ -474,8 +510,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',
@@ -500,7 +536,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.
@@ -527,14 +563,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),
@@ -555,7 +591,8 @@ class TinyCrypto {
    */
   #serialize(data) {
     const type = objFilter.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}`);
   }