tiny-essentials 1.1.0 → 1.2.0

package/dist/v1/libs/TinyCrypto.cjs

@@ -2,9 +2,18 @@
 
 var crypto = require('crypto');
 var fs = require('fs');
+var buffer = require('buffer');
 var objFilter = require('../basics/objFilter.cjs');
 
-// Detecta se estamos no browser
+/**
+ * Determines if the environment is a browser.
+ *
+ * This constant checks if the code is running in a browser environment by verifying if
+ * the `window` object and the `window.document` object are available. It will return `true`
+ * if the environment is a browser, and `false` otherwise (e.g., in a Node.js environment).
+ *
+ * @constant {boolean}
+ */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 
 /**
@@ -99,7 +108,7 @@ class TinyCrypto {
     });
 
     let encrypted = cipher.update(plainText, this.inputEncoding);
-    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    encrypted = buffer.Buffer.concat([encrypted, cipher.final()]);
     const authTag = cipher.getAuthTag();
 
     return {
@@ -134,9 +143,9 @@ class TinyCrypto {
    * console.log(decrypted); // Outputs: 'Hello, world!'
    */
   decrypt({ iv, encrypted, authTag }, expectedType = null) {
-    const ivBuffer = Buffer.from(iv, this.outputEncoding);
-    const encryptedBuffer = Buffer.from(encrypted, this.outputEncoding);
-    const authTagBuffer = Buffer.from(authTag, this.outputEncoding);
+    const ivBuffer = buffer.Buffer.from(iv, this.outputEncoding);
+    const encryptedBuffer = buffer.Buffer.from(encrypted, this.outputEncoding);
+    const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
     const decipher = crypto.createDecipheriv(this.algorithm, this.key, ivBuffer, {
       authTagLength: this.authTagLength,
@@ -174,9 +183,9 @@ class TinyCrypto {
    * console.log(dataType); // Outputs: 'string'
    */
   getTypeFromEncrypted({ iv, encrypted, authTag }) {
-    const ivBuffer = Buffer.from(iv, this.outputEncoding);
-    const encryptedBuffer = Buffer.from(encrypted, this.outputEncoding);
-    const authTagBuffer = Buffer.from(authTag, this.outputEncoding);
+    const ivBuffer = buffer.Buffer.from(iv, this.outputEncoding);
+    const encryptedBuffer = buffer.Buffer.from(encrypted, this.outputEncoding);
+    const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
     const decipher = crypto.createDecipheriv(this.algorithm, this.key, ivBuffer, {
       authTagLength: this.authTagLength,
@@ -188,7 +197,7 @@ class TinyCrypto {
     decrypted += decipher.final(this.inputEncoding);
 
     const { type } = this.#deserialize(decrypted);
-    return typeof type === 'string' ? type.toLowerCase() : 'unknown';
+    return typeof type === 'string' ? type : 'unknown';
   }
 
   /**
@@ -322,7 +331,7 @@ class TinyCrypto {
         const reader = new FileReader();
         reader.onload = () => {
           const hexKey = reader.result.trim();
-          const keyBuffer = Buffer.from(hexKey, 'hex');
+          const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
           this.key = keyBuffer;
           resolve(keyBuffer);
         };
@@ -331,7 +340,7 @@ class TinyCrypto {
       });
     } else {
       const hexKey = fs.readFileSync(file, 'utf8');
-      const keyBuffer = Buffer.from(hexKey, 'hex');
+      const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
       this.key = keyBuffer;
       return keyBuffer;
     }
@@ -409,7 +418,7 @@ class TinyCrypto {
     else if (typeof config.authTagLength !== 'undefined')
       throw new Error('Invalid or missing "authTagLength" property. Expected a number.');
 
-    if (typeof config.key === 'string') this.key = Buffer.from(config.key, 'hex');
+    if (typeof config.key === 'string') this.key = buffer.Buffer.from(config.key, 'hex');
     else if (typeof config.key !== 'undefined')
       throw new Error('Invalid or missing "key" property. Expected a hexadecimal string.');
   }
@@ -458,29 +467,29 @@ class TinyCrypto {
     function: () => {
       throw new Error('Function cannot be serialized');
     },
-    regexp: (data) => JSON.stringify({ __type: 'RegExp', value: data.toString() }),
-    htmlElement: (data) => JSON.stringify({ __type: 'HTMLElement', value: data.outerHTML }),
-    date: (data) => JSON.stringify({ __type: 'Date', value: data.toISOString() }),
-    bigint: (data) => JSON.stringify({ __type: 'BigInt', value: data.toString() }),
-    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' }),
+    regexp: (data) => JSON.stringify({ __type: 'regexp', value: data.toString() }),
+    htmlElement: (data) => JSON.stringify({ __type: 'htmlelement', value: data.outerHTML }),
+    date: (data) => JSON.stringify({ __type: 'date', value: data.toISOString() }),
+    bigint: (data) => JSON.stringify({ __type: 'bigint', value: data.toString() }),
+    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' }),
     map: (data) =>
       JSON.stringify({
-        __type: 'Map',
+        __type: 'map',
         value: Array.from(data.entries()),
       }),
     set: (data) =>
       JSON.stringify({
-        __type: 'Set',
+        __type: 'set',
         value: Array.from(data.values()),
       }),
-    symbol: (data) => JSON.stringify({ __type: 'Symbol', value: data.description }),
-    array: (data) => JSON.stringify({ __type: 'Array', value: data }),
-    object: (data) => JSON.stringify({ __type: 'JSON', value: data }),
-    buffer: (data) => JSON.stringify({ __type: 'Buffer', value: data.toString('base64') }),
+    symbol: (data) => JSON.stringify({ __type: 'symbol', value: data.description }),
+    array: (data) => JSON.stringify({ __type: 'array', value: data }),
+    object: (data) => JSON.stringify({ __type: 'object', value: data }),
+    buffer: (data) => JSON.stringify({ __type: 'buffer', value: data.toString('base64') }),
   };
 
   /**
@@ -492,47 +501,47 @@ class TinyCrypto {
    * and the value is a function that deserializes the value to its original format.
    *
    * @type {Object}
-   * @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.
-   * @property {Function} BigInt - Deserializes a BigInt from its string representation.
-   * @property {Function} Number - Deserializes a number from its string or numeric representation.
-   * @property {Function} Boolean - Deserializes a boolean value from its string representation.
-   * @property {Function} Null - Deserializes the `null` value.
-   * @property {Function} Undefined - Deserializes the `undefined` value.
-   * @property {Function} Map - Deserializes a Map from an array of key-value pairs.
-   * @property {Function} Set - Deserializes a Set from an array of values.
-   * @property {Function} Symbol - Deserializes a Symbol from its string description.
-   * @property {Function} Array - Deserializes an array from its serialized representation.
-   * @property {Function} JSON - Deserializes a plain JSON object from its serialized representation.
-   * @property {Function} String - Deserializes a string from its serialized representation.
-   * @property {Function} Buffer - Deserializes a Buffer from its base64-encoded string representation.
+   * @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.
+   * @property {Function} bigint - Deserializes a BigInt from its string representation.
+   * @property {Function} number - Deserializes a number from its string or numeric representation.
+   * @property {Function} boolean - Deserializes a boolean value from its string representation.
+   * @property {Function} null - Deserializes the `null` value.
+   * @property {Function} undefined - Deserializes the `undefined` value.
+   * @property {Function} map - Deserializes a Map from an array of key-value pairs.
+   * @property {Function} set - Deserializes a Set from an array of values.
+   * @property {Function} symbol - Deserializes a Symbol from its string description.
+   * @property {Function} array - Deserializes an array from its serialized representation.
+   * @property {Function} object - Deserializes a plain JSON object from its serialized representation.
+   * @property {Function} string - Deserializes a string from its serialized representation.
+   * @property {Function} buffer - Deserializes a Buffer from its base64-encoded string representation.
    */
   #valueTypes = {
-    RegExp: (value) => {
+    regexp: (value) => {
       const match = value.match(/^\/(.*)\/([gimsuy]*)$/);
       return match ? new RegExp(match[1], match[2]) : new RegExp(value);
     },
-    HTMLElement: (value) => {
+    htmlelement: (value) => {
       if (typeof document === 'undefined')
         throw new Error('HTMLElement deserialization is only supported in browsers');
       const div = document.createElement('div');
       div.innerHTML = value;
       return div.firstElementChild;
     },
-    Date: (value) => new Date(value),
-    BigInt: (value) => BigInt(value),
-    Number: (value) => Number(value),
-    Boolean: (value) => Boolean(value),
-    Null: (value) => null,
-    Undefined: (value) => undefined,
-    Map: (value) => new Map(value),
-    Set: (value) => new Set(value),
-    Symbol: (value) => Symbol(value),
-    Array: (value) => value,
-    JSON: (value) => value,
-    String: (value) => String(value),
-    Buffer: (value) => Buffer.from(value, 'base64'),
+    date: (value) => new Date(value),
+    bigint: (value) => BigInt(value),
+    number: (value) => Number(value),
+    boolean: (value) => Boolean(value),
+    null: (value) => null,
+    undefined: (value) => undefined,
+    map: (value) => new Map(value),
+    set: (value) => new Set(value),
+    symbol: (value) => Symbol(value),
+    array: (value) => value,
+    object: (value) => value,
+    string: (value) => String(value),
+    buffer: (value) => buffer.Buffer.from(value, 'base64'),
   };
 
   /**
@@ -564,7 +573,7 @@ class TinyCrypto {
       const parsed = JSON.parse(text);
       const type = parsed.__type;
 
-      if (typeof type !== 'string') return { value: text, type: 'String' };
+      if (typeof type !== 'string') return { value: text, type: 'string' };
       if (typeof this.#valueTypes[type] === 'function')
         return {
           value: this.#valueTypes[type](parsed.value),
@@ -586,10 +595,8 @@ class TinyCrypto {
    * @throws {Error} If the types do not match.
    */
   #validateDeserializedType(expected, actual) {
-    if (expected.toLowerCase() !== actual.toLowerCase())
-      throw new Error(
-        `Type mismatch: expected ${expected.toLowerCase()}, but got ${actual.toLowerCase()}`,
-      );
+    if (expected !== actual)
+      throw new Error(`Type mismatch: expected ${expected}, but got ${actual}`);
   }
 }
 

package/dist/v1/libs/TinyCrypto.d.mts

@@ -265,3 +265,4 @@ declare class TinyCrypto {
     }): void;
     #private;
 }
+import { Buffer } from 'buffer';

package/dist/v1/libs/TinyCrypto.mjs

@@ -1,7 +1,16 @@
 import crypto from 'crypto';
 import fs from 'fs';
+import { Buffer } from 'buffer';
 import { objType } from '../../v1/basics/objFilter.mjs';
-// Detecta se estamos no browser
+/**
+ * Determines if the environment is a browser.
+ *
+ * This constant checks if the code is running in a browser environment by verifying if
+ * the `window` object and the `window.document` object are available. It will return `true`
+ * if the environment is a browser, and `false` otherwise (e.g., in a Node.js environment).
+ *
+ * @constant {boolean}
+ */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 /**
  * TinyCrypto is a utility class that provides methods for secure key generation,
@@ -169,7 +178,7 @@ class TinyCrypto {
         let decrypted = decipher.update(encryptedBuffer, null, this.inputEncoding);
         decrypted += decipher.final(this.inputEncoding);
         const { type } = this.#deserialize(decrypted);
-        return typeof type === 'string' ? type.toLowerCase() : 'unknown';
+        return typeof type === 'string' ? type : 'unknown';
     }
     /**
      * Saves the cryptographic key to a file.
@@ -440,27 +449,27 @@ class TinyCrypto {
         function: () => {
             throw new Error('Function cannot be serialized');
         },
-        regexp: (data) => JSON.stringify({ __type: 'RegExp', value: data.toString() }),
-        htmlElement: (data) => JSON.stringify({ __type: 'HTMLElement', value: data.outerHTML }),
-        date: (data) => JSON.stringify({ __type: 'Date', value: data.toISOString() }),
-        bigint: (data) => JSON.stringify({ __type: 'BigInt', value: data.toString() }),
-        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' }),
+        regexp: (data) => JSON.stringify({ __type: 'regexp', value: data.toString() }),
+        htmlElement: (data) => JSON.stringify({ __type: 'htmlelement', value: data.outerHTML }),
+        date: (data) => JSON.stringify({ __type: 'date', value: data.toISOString() }),
+        bigint: (data) => JSON.stringify({ __type: 'bigint', value: data.toString() }),
+        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' }),
         map: (data) => JSON.stringify({
-            __type: 'Map',
+            __type: 'map',
             value: Array.from(data.entries()),
         }),
         set: (data) => JSON.stringify({
-            __type: 'Set',
+            __type: 'set',
             value: Array.from(data.values()),
         }),
-        symbol: (data) => JSON.stringify({ __type: 'Symbol', value: data.description }),
-        array: (data) => JSON.stringify({ __type: 'Array', value: data }),
-        object: (data) => JSON.stringify({ __type: 'JSON', value: data }),
-        buffer: (data) => JSON.stringify({ __type: 'Buffer', value: data.toString('base64') }),
+        symbol: (data) => JSON.stringify({ __type: 'symbol', value: data.description }),
+        array: (data) => JSON.stringify({ __type: 'array', value: data }),
+        object: (data) => JSON.stringify({ __type: 'object', value: data }),
+        buffer: (data) => JSON.stringify({ __type: 'buffer', value: data.toString('base64') }),
     };
     /**
      * A mapping of data types to their deserialization functions.
@@ -471,47 +480,47 @@ class TinyCrypto {
      * and the value is a function that deserializes the value to its original format.
      *
      * @type {Object}
-     * @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.
-     * @property {Function} BigInt - Deserializes a BigInt from its string representation.
-     * @property {Function} Number - Deserializes a number from its string or numeric representation.
-     * @property {Function} Boolean - Deserializes a boolean value from its string representation.
-     * @property {Function} Null - Deserializes the `null` value.
-     * @property {Function} Undefined - Deserializes the `undefined` value.
-     * @property {Function} Map - Deserializes a Map from an array of key-value pairs.
-     * @property {Function} Set - Deserializes a Set from an array of values.
-     * @property {Function} Symbol - Deserializes a Symbol from its string description.
-     * @property {Function} Array - Deserializes an array from its serialized representation.
-     * @property {Function} JSON - Deserializes a plain JSON object from its serialized representation.
-     * @property {Function} String - Deserializes a string from its serialized representation.
-     * @property {Function} Buffer - Deserializes a Buffer from its base64-encoded string representation.
+     * @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.
+     * @property {Function} bigint - Deserializes a BigInt from its string representation.
+     * @property {Function} number - Deserializes a number from its string or numeric representation.
+     * @property {Function} boolean - Deserializes a boolean value from its string representation.
+     * @property {Function} null - Deserializes the `null` value.
+     * @property {Function} undefined - Deserializes the `undefined` value.
+     * @property {Function} map - Deserializes a Map from an array of key-value pairs.
+     * @property {Function} set - Deserializes a Set from an array of values.
+     * @property {Function} symbol - Deserializes a Symbol from its string description.
+     * @property {Function} array - Deserializes an array from its serialized representation.
+     * @property {Function} object - Deserializes a plain JSON object from its serialized representation.
+     * @property {Function} string - Deserializes a string from its serialized representation.
+     * @property {Function} buffer - Deserializes a Buffer from its base64-encoded string representation.
      */
     #valueTypes = {
-        RegExp: (value) => {
+        regexp: (value) => {
             const match = value.match(/^\/(.*)\/([gimsuy]*)$/);
             return match ? new RegExp(match[1], match[2]) : new RegExp(value);
         },
-        HTMLElement: (value) => {
+        htmlelement: (value) => {
             if (typeof document === 'undefined')
                 throw new Error('HTMLElement deserialization is only supported in browsers');
             const div = document.createElement('div');
             div.innerHTML = value;
             return div.firstElementChild;
         },
-        Date: (value) => new Date(value),
-        BigInt: (value) => BigInt(value),
-        Number: (value) => Number(value),
-        Boolean: (value) => Boolean(value),
-        Null: (value) => null,
-        Undefined: (value) => undefined,
-        Map: (value) => new Map(value),
-        Set: (value) => new Set(value),
-        Symbol: (value) => Symbol(value),
-        Array: (value) => value,
-        JSON: (value) => value,
-        String: (value) => String(value),
-        Buffer: (value) => Buffer.from(value, 'base64'),
+        date: (value) => new Date(value),
+        bigint: (value) => BigInt(value),
+        number: (value) => Number(value),
+        boolean: (value) => Boolean(value),
+        null: (value) => null,
+        undefined: (value) => undefined,
+        map: (value) => new Map(value),
+        set: (value) => new Set(value),
+        symbol: (value) => Symbol(value),
+        array: (value) => value,
+        object: (value) => value,
+        string: (value) => String(value),
+        buffer: (value) => Buffer.from(value, 'base64'),
     };
     /**
      * Serializes a given data value into a JSON-compatible format based on its type.
@@ -542,7 +551,7 @@ class TinyCrypto {
             const parsed = JSON.parse(text);
             const type = parsed.__type;
             if (typeof type !== 'string')
-                return { value: text, type: 'String' };
+                return { value: text, type: 'string' };
             if (typeof this.#valueTypes[type] === 'function')
                 return {
                     value: this.#valueTypes[type](parsed.value),
@@ -565,8 +574,8 @@ class TinyCrypto {
      * @throws {Error} If the types do not match.
      */
     #validateDeserializedType(expected, actual) {
-        if (expected.toLowerCase() !== actual.toLowerCase())
-            throw new Error(`Type mismatch: expected ${expected.toLowerCase()}, but got ${actual.toLowerCase()}`);
+        if (expected !== actual)
+            throw new Error(`Type mismatch: expected ${expected}, but got ${actual}`);
     }
 }
 export default TinyCrypto;

package/docs/README.md

@@ -14,6 +14,8 @@ This folder contains external libraries and utility modules that are designed to
 
 - 🔐 **[TinyCrypto.md](./libs/TinyCrypto.md)** — A flexible and browser-compatible AES-256-GCM encryption utility with support for complex JavaScript types like `Date`, `RegExp`, `Buffer`, and even DOM elements (in the browser).
 
+- 📄 **[TinyCertCrypto.md](./libs/TinyCertCrypto.md)** — A lightweight tool for managing RSA key pairs and X.509 certificates with support for generation, PEM parsing, encryption/decryption of JSON, and certificate metadata extraction. Works in both Node.js and browser environments (with limitations in browser).
+
 ---
 
 ### 2. **`basics/`** 

package/docs/libs/TinyCertCrypto.md

@@ -0,0 +1,202 @@
+# ✨ Tiny Cert Crypto
+
+A lightweight 🔐 utility for managing, generating, and handling **X.509 certificates** and **RSA key pairs**.  
+Built with flexibility in mind — runs seamlessly in both **Node.js** and **browser** environments! 🌍
+
+---
+
+## 📦 Features
+
+- 🛠️ RSA key pair generation (**Node.js only**)
+- 🧾 Self-signed X.509 certificate creation
+- 🧬 Support for PEM-based 🔑 public/private keys and certificates
+- 🧊 JSON encryption & decryption using Base64 encoding
+- 🕵️ Metadata extraction from certificates (issuer, subject, validity, etc.)
+- 📁 Flexible key loading: from memory, local files (Node.js), or URLs (browser)
+
+---
+
+## 🚀 Getting Started
+
+### 📚 Constructor
+
+```js
+const instance = new TinyCertCrypto({
+  publicCertPath: 'cert.pem',          // Path to public cert (Node.js)
+  privateKeyPath: 'key.pem',           // Path to private key (Node.js)
+  publicCertBuffer: null,              // String or Buffer in memory (Node.js/browser)
+  privateKeyBuffer: null,              // String or Buffer in memory (Node.js/browser)
+  cryptoType: 'RSA-OAEP',              // Encryption algorithm (default: 'RSA-OAEP')
+});
+```
+
+> 🔍 In **browser environments**, at least `publicCertPath` or `publicCertBuffer` must be provided.
+
+---
+
+## 🧪 Core Methods
+
+### 🔧 `async init()`
+Initializes the certificate and key system from files, memory buffers, or URLs.
+
+- Loads the public certificate/key.
+- Optionally loads the private key.
+- Detects whether you’re running in Node.js or the browser and adjusts behavior accordingly.
+
+---
+
+### 📑 `extractCertMetadata()`
+Returns parsed metadata from the loaded certificate.
+
+```js
+{
+  subject: { names: {}, shortNames: {}, raw: "CN=example.com,O=MyOrg" },
+  issuer: { names: {}, shortNames: {}, raw: "CN=example.com,O=MyOrg" },
+  serialNumber: '...',
+  validFrom: Date,
+  validTo: Date
+}
+```
+
+---
+
+### 🛡️ `encryptJson(jsonObject)`
+Encrypts a JavaScript object using the loaded **public key**, returning a **Base64-encoded string**.
+
+```js
+const encrypted = instance.encryptJson({ hello: "world" });
+```
+
+---
+
+### 🔓 `decryptToJson(base64String)`
+Decrypts a Base64 string using the **private key**, returning the original JSON object.
+
+```js
+const json = instance.decryptToJson(encrypted);
+```
+
+---
+
+### 🔍 `hasKeys()`
+Returns `true` if both `publicKey` and `privateKey` are loaded.
+
+---
+
+### 📜 `hasCert()`
+Returns `true` if a certificate (`publicCert`) is loaded.
+
+---
+
+### ♻️ `reset()`
+Resets the internal state, clearing:
+- `publicKey`
+- `privateKey`
+- `publicCert`
+- `metadata`
+- `source`
+
+---
+
+### 📦 `fetchNodeForge()` & `getNodeForge()`
+Handles lazy-loading and reuse of the `node-forge` module.
+
+Use if you want to access Forge directly without importing it yourself:
+
+```js
+const forge = await instance.fetchNodeForge();
+```
+
+---
+
+## 🧠 Internals & Design
+
+- 🔍 Uses regular expressions to detect PEM types (`CERTIFICATE`, `PUBLIC KEY`, `PRIVATE KEY`)
+- 🧪 Automatically parses PEM buffers and files depending on the runtime
+- 🔐 Encrypts data with the selected algorithm (`RSA-OAEP`, etc.)
+- 🧬 X.509 certificate metadata extraction is done via `node-forge`
+
+---
+
+## 🧰 Requirements
+
+| Environment | Requirement        |
+|-------------|--------------------|
+| Node.js     | `node-forge` |
+| Browser     | Works with native `fetch()` and `TextDecoder` |
+
+---
+
+## 😺 Example Use Case
+
+```js
+const crypto = new TinyCertCrypto({ publicCertPath: 'cert.pem', privateKeyPath: 'key.pem' });
+await crypto.init();
+
+const data = { secret: 'I love ponies' };
+const encrypted = crypto.encryptJson(data);
+const decrypted = crypto.decryptToJson(encrypted);
+
+console.log(decrypted); // { secret: 'I love ponies' }
+```
+
+---
+
+### 🧾 `async generateX509Cert(subjectFields, options = {})`
+Generates a new **RSA key pair** and a **self-signed X.509 certificate** using the provided subject information.
+
+🔐 This is ideal for internal services, development environments, or cryptographic testing tools where a trusted CA is not required.
+
+---
+
+**🧬 Parameters:**
+
+- `subjectFields` (`Object`) – Describes the identity fields that will be embedded into the certificate's subject and issuer:
+  - Common fields include:
+    - `CN`: Common Name (e.g. domain or hostname)
+    - `O`: Organization Name
+    - `OU`: Organizational Unit
+    - `L`: Locality (City)
+    - `ST`: State or Province
+    - `C`: Country (2-letter code)
+    - `emailAddress`: Optional email field
+
+- `options` (`Object`) – Optional configuration:
+  - `keySize` (`number`) – RSA key size in bits (default: `2048`)
+  - `validityInYears` (`number`) – Certificate validity period (default: `1`)
+  - `randomBytesLength` (`number`) – Length of the serial number (default: `16`)
+  - `digestAlgorithm` (`string`) – Digest algorithm used to sign the certificate (default: `'sha256'`)
+  - `forgeInstance` (`object`) – Optionally inject a specific instance of `node-forge`
+  - `cryptoType` (`string`) – Encryption scheme used for later operations (e.g., `'RSA-OAEP'`, `'RSAES-PKCS1-V1_5'`)
+
+---
+
+**✅ Returns:**
+
+An object containing all the generated artifacts:
+
+```js
+{
+  publicKey: '-----BEGIN PUBLIC KEY-----...',
+  privateKey: '-----BEGIN PRIVATE KEY-----...',
+  cert: '-----BEGIN CERTIFICATE-----...'
+}
+```
+
+- `publicKey`: The newly generated **PEM-encoded RSA public key**
+- `privateKey`: The corresponding **PEM-encoded RSA private key**
+- `cert`: A **PEM-encoded X.509 certificate** that is **self-signed** with the private key and matches the provided subject
+
+---
+
+**📌 Notes:**
+
+- 🔄 The `subject` and `issuer` of the certificate are the same (self-signed).
+- ⏳ The certificate `validFrom` is set to the current date, and `validTo` is based on the `validityInYears` option.
+- 🔢 A secure random `serialNumber` is generated using `crypto.randomBytes`.
+
+---
+
+**⚠️ Availability:**
+
+> This method is only available in **Node.js environments** due to its dependency on the native `crypto` module and synchronous file access via `fs`.

package/docs/libs/TinyCrypto.md

@@ -79,7 +79,7 @@ const result = crypto.encrypt('Hello!');
 Decrypts a previously encrypted value and returns the original data. You can optionally pass an `expectedType` to validate it.
 
 ```js
-const plain = crypto.decrypt(result, 'String');
+const plain = crypto.decrypt(result, 'string');
 ```
 
 ---
@@ -136,7 +136,7 @@ Returns an object with the current settings:
   "outputEncoding": "hex",
   "inputEncoding": "utf8",
   "authTagLength": 16,
-  "key": "..." // hex string
+  "key": "..."
 }
 ```