tiny-essentials 1.2.0 → 1.2.1

package/dist/TinyCertCrypto.min.js.LICENSE.txt

@@ -6,5 +6,3 @@
  */
 
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-
-/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/TinyCrypto.js

@@ -7692,16 +7692,17 @@ module.exports = pbkdf2
 /***/ ((__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);
@@ -7715,50 +7716,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.
 // [
@@ -7771,14 +7772,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,
@@ -47326,6 +47327,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,
 
@@ -47345,6 +47349,7 @@ const typeValidator = {
     'function',
     'array',
     'buffer',
+    'file',
     'date',
     'regexp',
     'map',
@@ -47531,8 +47536,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.
    *
@@ -47542,15 +47547,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';
   }
 
   /**
@@ -47564,7 +47571,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
   }
 
   /**
@@ -47578,7 +47585,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
   }
 
   /**
@@ -47588,10 +47595,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!');
@@ -47604,31 +47608,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.
@@ -47648,13 +47662,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);
 
@@ -47668,10 +47686,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
@@ -47688,13 +47703,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);
@@ -47784,10 +47802,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'));
@@ -47797,7 +47817,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);
     }
@@ -47829,9 +47849,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);
@@ -47840,7 +47862,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;
@@ -47886,8 +47908,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.
    *
@@ -47934,7 +47956,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.
@@ -47975,8 +47997,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',
@@ -48001,7 +48023,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.
@@ -48028,14 +48050,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),
@@ -48056,7 +48078,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}`);
   }