@vvlad1973/crypto 2.1.1 → 2.3.0

package/dist/__tests__/crypto.test.js

@@ -35,7 +35,6 @@ describe('Crypto', () => {
         expect(crypto).toBeDefined();
     });
     it('should return UUIDv4', () => {
-        const crypto = new Crypto(options);
         const uuid = Crypto.getUUID();
         const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
         expect(uuid).toMatch(uuidv4Regex);
@@ -153,6 +152,50 @@ describe('isCrypto', () => {
         expect(isCrypto(plainObject)).toBe(false);
     });
 });
+describe('encryptStorable / decryptStorable', () => {
+    const password = 'testPassword';
+    const salt = 'testSalt';
+    const plainText = 'Hello, World!';
+    it('round-trips correctly', () => {
+        const crypto = new Crypto(password, salt);
+        expect(crypto.decryptStorable(crypto.encryptStorable(plainText))).toBe(plainText);
+    });
+    it('produces different ciphertext on each call (fresh IV)', () => {
+        const crypto = new Crypto(password, salt);
+        expect(crypto.encryptStorable(plainText)).not.toBe(crypto.encryptStorable(plainText));
+    });
+    it('output is longer than encrypt() by exactly 16 bytes (32 hex chars)', () => {
+        const crypto = new Crypto(password, salt, 'sha512', 1000, 32, 0);
+        const storable = crypto.encryptStorable(plainText);
+        const legacy = crypto.encrypt(plainText);
+        expect(storable.length).toBe(legacy.length + 32);
+    });
+    it('two different instances with same key can cross-decrypt', () => {
+        const a = new Crypto(password, salt);
+        const b = new Crypto(password, salt);
+        expect(b.decryptStorable(a.encryptStorable(plainText))).toBe(plainText);
+    });
+    it('throws RangeError when input is too short', () => {
+        const crypto = new Crypto(password, salt);
+        expect(() => crypto.decryptStorable('aabbcc')).toThrow(RangeError);
+    });
+    it('handles empty string', () => {
+        const crypto = new Crypto(password, salt);
+        expect(crypto.decryptStorable(crypto.encryptStorable(''))).toBe('');
+    });
+    it('handles Unicode text', () => {
+        const crypto = new Crypto(password, salt);
+        const unicode = '🔐 Шифрование 中文';
+        expect(crypto.decryptStorable(crypto.encryptStorable(unicode))).toBe(unicode);
+    });
+    it('construction-time IV does not affect result', () => {
+        const c0 = new Crypto(password, salt, 'sha512', 1000, 32, 0);
+        const c5 = new Crypto(password, salt, 'sha512', 1000, 32, 5);
+        // Both should decrypt successfully regardless of instance IV
+        expect(c5.decryptStorable(c0.encryptStorable(plainText))).toBe(plainText);
+        expect(c0.decryptStorable(c5.encryptStorable(plainText))).toBe(plainText);
+    });
+});
 describe('Compatibility with previous version', () => {
     const plainText = 'Проверка связи';
     let options;

package/dist/crypto.d.ts

@@ -40,16 +40,51 @@ export declare class Crypto {
     private convertNumberToIV;
     /**
      * Encrypt a text string.
+     * Uses the IV supplied at construction time (fixed or random-at-construct).
+     * The IV is **not** embedded in the output — both sides must use the same IV.
+     * For persistent storage use {@link encryptStorable} instead.
+     *
      * @param {string} text - The plain text to encrypt.
      * @returns {string} The encrypted text as a hex string.
      */
     encrypt(text: string): string;
     /**
-     * Decrypt an encrypted text string.
+     * Decrypt an encrypted text string produced by {@link encrypt}.
+     * Uses the IV supplied at construction time.
+     *
      * @param {string} text - The encrypted text as a hex string.
      * @returns {string} The decrypted plain text.
      */
     decrypt(text: string): string;
+    /**
+     * Encrypts text and prepends a fresh random IV to the output.
+     *
+     * Use this method when the ciphertext will be stored (database, file, etc.)
+     * and retrieved later in a different process instance.  A new random IV is
+     * generated for every call, so repeated encryptions of the same plaintext
+     * produce different ciphertexts — no IV reuse across records.
+     *
+     * Output format: `hex( IV[16 bytes] || ciphertext[N bytes] )`
+     *
+     * The construction-time IV is **not** used by this method.
+     *
+     * @param {string} text - The plain text to encrypt.
+     * @returns {string} Hex string containing the prepended IV and ciphertext.
+     * @see {@link decryptStorable}
+     */
+    encryptStorable(text: string): string;
+    /**
+     * Decrypts a value produced by {@link encryptStorable}.
+     *
+     * Extracts the first 16 bytes as the IV, then decrypts the remainder.
+     * The construction-time IV is **not** used by this method.
+     *
+     * @param {string} text - Hex string `IV[16 bytes] || ciphertext` from {@link encryptStorable}.
+     * @returns {string} The decrypted plain text.
+     * @throws {RangeError} When the input is shorter than 16 bytes (32 hex chars).
+     * @see {@link encryptStorable}
+     */
+    decryptStorable(text: string): string;
     /**
      * Returns a UUID ver.4 string.
      * @returns {string} UUID ver.4 string.

package/dist/crypto.js

@@ -53,6 +53,10 @@ export class Crypto {
     }
     /**
      * Encrypt a text string.
+     * Uses the IV supplied at construction time (fixed or random-at-construct).
+     * The IV is **not** embedded in the output — both sides must use the same IV.
+     * For persistent storage use {@link encryptStorable} instead.
+     *
      * @param {string} text - The plain text to encrypt.
      * @returns {string} The encrypted text as a hex string.
      */
@@ -65,7 +69,9 @@ export class Crypto {
         return encrypted.toString('hex');
     }
     /**
-     * Decrypt an encrypted text string.
+     * Decrypt an encrypted text string produced by {@link encrypt}.
+     * Uses the IV supplied at construction time.
+     *
      * @param {string} text - The encrypted text as a hex string.
      * @returns {string} The decrypted plain text.
      */
@@ -78,6 +84,50 @@ export class Crypto {
         ]);
         return decrypted.toString('utf8');
     }
+    /**
+     * Encrypts text and prepends a fresh random IV to the output.
+     *
+     * Use this method when the ciphertext will be stored (database, file, etc.)
+     * and retrieved later in a different process instance.  A new random IV is
+     * generated for every call, so repeated encryptions of the same plaintext
+     * produce different ciphertexts — no IV reuse across records.
+     *
+     * Output format: `hex( IV[16 bytes] || ciphertext[N bytes] )`
+     *
+     * The construction-time IV is **not** used by this method.
+     *
+     * @param {string} text - The plain text to encrypt.
+     * @returns {string} Hex string containing the prepended IV and ciphertext.
+     * @see {@link decryptStorable}
+     */
+    encryptStorable(text) {
+        const iv = randomBytes(16);
+        const cipher = createCipheriv('aes-256-ctr', this.key, iv);
+        const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+        return Buffer.concat([iv, encrypted]).toString('hex');
+    }
+    /**
+     * Decrypts a value produced by {@link encryptStorable}.
+     *
+     * Extracts the first 16 bytes as the IV, then decrypts the remainder.
+     * The construction-time IV is **not** used by this method.
+     *
+     * @param {string} text - Hex string `IV[16 bytes] || ciphertext` from {@link encryptStorable}.
+     * @returns {string} The decrypted plain text.
+     * @throws {RangeError} When the input is shorter than 16 bytes (32 hex chars).
+     * @see {@link encryptStorable}
+     */
+    decryptStorable(text) {
+        const buf = Buffer.from(text, 'hex');
+        if (buf.length < 16) {
+            throw new RangeError(`decryptStorable: input too short (${buf.length} bytes); ` +
+                'expected at least 16 bytes for the IV prefix.');
+        }
+        const iv = buf.subarray(0, 16);
+        const ciphertext = buf.subarray(16);
+        const decipher = createDecipheriv('aes-256-ctr', this.key, iv);
+        return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+    }
     /**
      * Returns a UUID ver.4 string.
      * @returns {string} UUID ver.4 string.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vvlad1973/crypto",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -17,7 +17,7 @@
   "license": "MIT with Commercial Use",
   "description": "A JavaScript class for encrypting and decrypting text using specified cryptographic parameters (algorithm, password, etc.)",
   "devDependencies": {
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.3.3",
     "@typescript-eslint/parser": "^7.18.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",

package/src/crypto.ts

@@ -102,6 +102,10 @@ export class Crypto {
 
   /**
    * Encrypt a text string.
+   * Uses the IV supplied at construction time (fixed or random-at-construct).
+   * The IV is **not** embedded in the output — both sides must use the same IV.
+   * For persistent storage use {@link encryptStorable} instead.
+   *
    * @param {string} text - The plain text to encrypt.
    * @returns {string} The encrypted text as a hex string.
    */
@@ -115,7 +119,9 @@ export class Crypto {
   }
 
   /**
-   * Decrypt an encrypted text string.
+   * Decrypt an encrypted text string produced by {@link encrypt}.
+   * Uses the IV supplied at construction time.
+   *
    * @param {string} text - The encrypted text as a hex string.
    * @returns {string} The decrypted plain text.
    */
@@ -129,6 +135,54 @@ export class Crypto {
     return decrypted.toString('utf8');
   }
 
+  /**
+   * Encrypts text and prepends a fresh random IV to the output.
+   *
+   * Use this method when the ciphertext will be stored (database, file, etc.)
+   * and retrieved later in a different process instance.  A new random IV is
+   * generated for every call, so repeated encryptions of the same plaintext
+   * produce different ciphertexts — no IV reuse across records.
+   *
+   * Output format: `hex( IV[16 bytes] || ciphertext[N bytes] )`
+   *
+   * The construction-time IV is **not** used by this method.
+   *
+   * @param {string} text - The plain text to encrypt.
+   * @returns {string} Hex string containing the prepended IV and ciphertext.
+   * @see {@link decryptStorable}
+   */
+  public encryptStorable(text: string): string {
+    const iv = randomBytes(16);
+    const cipher = createCipheriv('aes-256-ctr', this.key, iv);
+    const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+    return Buffer.concat([iv, encrypted]).toString('hex');
+  }
+
+  /**
+   * Decrypts a value produced by {@link encryptStorable}.
+   *
+   * Extracts the first 16 bytes as the IV, then decrypts the remainder.
+   * The construction-time IV is **not** used by this method.
+   *
+   * @param {string} text - Hex string `IV[16 bytes] || ciphertext` from {@link encryptStorable}.
+   * @returns {string} The decrypted plain text.
+   * @throws {RangeError} When the input is shorter than 16 bytes (32 hex chars).
+   * @see {@link encryptStorable}
+   */
+  public decryptStorable(text: string): string {
+    const buf = Buffer.from(text, 'hex');
+    if (buf.length < 16) {
+      throw new RangeError(
+        `decryptStorable: input too short (${buf.length} bytes); ` +
+        'expected at least 16 bytes for the IV prefix.',
+      );
+    }
+    const iv = buf.subarray(0, 16);
+    const ciphertext = buf.subarray(16);
+    const decipher = createDecipheriv('aes-256-ctr', this.key, iv);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+  }
+
   /**
    * Returns a UUID ver.4 string.
    * @returns {string} UUID ver.4 string.

package/.vscode/launch.json

@@ -1,20 +0,0 @@
-{
-    // Используйте IntelliSense, чтобы узнать о возможных атрибутах.
-    // Наведите указатель мыши, чтобы просмотреть описания существующих атрибутов.
-    // Для получения дополнительной информации посетите: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "env": {
-                "NODE_OPTIONS": "--experimental-vm-modules"
-            },
-            "name": "Запустить программу",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "program": "${workspaceFolder}\\index.js"
-        }
-    ]
-}

package/CLAUDE.md

@@ -1,90 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Common requirements
-
-- отвечай на русском языке. Используй английский только если на то есть особые указания
-- комментарии в коде, в JSDoc - используй английский язык
-- отчеты - используй русский язык
-- при создании документов и commit messages НИКОГДА НЕ ДОБАВЛЯЙ в нихх никакой информации о том, что этот текст сгенерирован тобой, либо при твоем участии/соавторстве
-- при формировании и редактировании файлов *.md соблюдай синтаксис MarkDown. Все Markdown-файлы (*.md) ДОЛЖНЫ проходить проверку линтером без ошибок и предупреждений
-- Не вноси изменений в CHANGELOG.md, этот файл формируется автоматически
-- **НИКОГДА НЕ ИСПОЛЬЗУЙ EMOJI** в файлах .md - это строгое требование проекта без исключений
-- при подготовке файлов документации соблюдай структуру каталога docs, правила, изложенные в C:\Repositories\botApp\bot-app-service\docs\CONTRIBUTING.md
-
-## Project Overview
-
-TypeScript library providing AES-256-CTR encryption/decryption functionality. Wrapper around Node.js native `crypto` module, replacing the previous `aes-js` dependency.
-
-## Development Commands
-
-### Build
-```bash
-npm run build
-```
-Compiles TypeScript to JavaScript using `tsc`. Output: `dist/` directory with `.js` and `.d.ts` files.
-
-### Testing
-```bash
-npm test
-```
-Runs build followed by Node.js native test runner with ts-node loader.
-
-To run a specific test file:
-```bash
-npm run build && node --loader ts-node/esm --test src/__tests__/crypto.test.ts
-```
-
-### Documentation Generation
-```bash
-npm run doc
-```
-Generates JSDoc documentation using better-docs template. Output: `docs/` directory.
-
-## Architecture
-
-### Core Module Structure
-- [src/crypto.ts](src/crypto.ts) - Main `Crypto` class implementation
-- [src/index.ts](src/index.ts) - Module exports
-- [src/__tests__/crypto.test.ts](src/__tests__/crypto.test.ts) - Test suite
-
-### Crypto Class Design
-
-The `Crypto` class uses Node.js native crypto APIs:
-- **Key derivation**: `pbkdf2Sync` with configurable algorithm (default SHA512), iterations (1000), and key length (32 bytes)
-- **Encryption**: AES-256-CTR mode via `createCipheriv`
-- **Initialization Vector (IV)**: Accepts either Buffer or number (converted to 16-byte Buffer)
-
-Constructor supports two signatures:
-1. Individual parameters: `new Crypto(password, salt, algorithm?, iterations?, keyLength?, iv?)`
-2. Options object: `new Crypto({ password, salt, algorithm?, iterations?, keyLength?, iv? })`
-
-### Key Implementation Details
-
-- IV conversion from number: Uses `Buffer.alloc(16)` with `writeUInt32BE` at offset 12
-- Encryption output: Hex-encoded string
-- Type guard: `isCrypto(object)` function checks for `encrypt` and `decrypt` methods
-- Static method: `Crypto.getUUID()` returns UUIDv4 string using `crypto.randomUUID()`
-
-### Module System
-- ES modules (`"type": "module"` in package.json)
-- TypeScript target: ES2022
-- File extensions: Import paths must use `.js` extension (not `.ts`) due to ES module resolution
-
-## TypeScript Configuration
-
-Strict mode enabled with full type checking. Output includes declaration files for TypeScript consumers.
-
-## Testing Approach
-
-Tests use Node.js native test runner (`node:test`) with:
-- Encryption/decryption round-trip verification
-- Both constructor signatures
-- Default parameter handling
-- Type guard validation
-- Backward compatibility with previous library version (validates specific encrypted output)
-
-## JSDoc Requirements
-
-Per user instructions: All modules must include complete JSDoc with module definitions. Comments and JSDoc must be in English.

package/src/__tests__/crypto.test.ts

@@ -1,238 +0,0 @@
-import { describe, it, beforeEach, expect } from 'vitest';
-import { randomBytes } from 'crypto';
-import Crypto, { CryptoOptions, isCrypto } from '../crypto.js';
-
-describe('Crypto', () => {
-  const plainText = 'Hello, World!';
-  let options: CryptoOptions;
-  let password: string;
-  let salt: string;
-  let algorithm: string;
-  let iterations: number;
-  let keyLength: number;
-  let iv: number;
-
-  beforeEach(() => {
-    options = {
-      password: 'testPassword',
-      salt: 'testSalt',
-      algorithm: 'SHA512',
-      iterations: 1000,
-      keyLength: 32,
-      iv: 5,
-    };
-    password = 'testPassword';
-    salt = 'testSalt';
-    algorithm = 'SHA512';
-    iterations = 1000;
-    keyLength = 32;
-    iv = 5;
-  });
-
-  it('should initialize with CryptoOptions object', () => {
-    const crypto = new Crypto(options);
-    expect(crypto).toBeDefined();
-  });
-
-  it('should initialize with separate parameters', () => {
-    const crypto = new Crypto(
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      iv
-    );
-    expect(crypto).toBeDefined();
-  });
-
-  it('should return UUIDv4', () => {
-    const crypto = new Crypto(options);
-    const uuid = Crypto.getUUID();
-    const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    expect(uuid).toMatch(uuidv4Regex);
-  });
-
-  it('should encrypt and decrypt text correctly using ICryptoOptions', () => {
-    const crypto = new Crypto(options);
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should encrypt and decrypt text correctly using separate parameters', () => {
-    const crypto = new Crypto(
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      iv
-    );
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should handle default values for optional parameters', () => {
-    const cryptoWithDefaults = new Crypto(password, salt);
-    const encryptedText = cryptoWithDefaults.encrypt(plainText);
-    const decryptedText = cryptoWithDefaults.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should initialize with Buffer IV using options object', () => {
-    const ivBuffer = randomBytes(16);
-    const crypto = new Crypto({
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      iv: ivBuffer,
-    });
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should initialize with Buffer IV using separate parameters', () => {
-    const ivBuffer = randomBytes(16);
-    const crypto = new Crypto(
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      ivBuffer
-    );
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should initialize without IV (random generation via options)', () => {
-    const crypto1 = new Crypto({ password, salt });
-    const crypto2 = new Crypto({ password, salt });
-    const encrypted1 = crypto1.encrypt(plainText);
-    const encrypted2 = crypto2.encrypt(plainText);
-    // Should produce different encrypted results due to different random IVs
-    expect(encrypted1).not.toBe(encrypted2);
-  });
-
-  it('should handle empty string encryption and decryption', () => {
-    const crypto = new Crypto(options);
-    const emptyText = '';
-    const encryptedText = crypto.encrypt(emptyText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(emptyText);
-  });
-
-  it('should handle Unicode characters', () => {
-    const crypto = new Crypto(options);
-    const unicodeText = '🔐 Encryption test 中文 العربية';
-    const encryptedText = crypto.encrypt(unicodeText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(unicodeText);
-  });
-
-  it('should handle different hash algorithms', () => {
-    const crypto256 = new Crypto(password, salt, 'sha256', iterations, keyLength, iv);
-    const encryptedText = crypto256.encrypt(plainText);
-    const decryptedText = crypto256.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should handle different key lengths', () => {
-    // AES-256-CTR requires 32 bytes key, testing with valid 32 bytes
-    const crypto32 = new Crypto(password, salt, algorithm, iterations, 32, iv);
-    const encryptedText = crypto32.encrypt(plainText);
-    const decryptedText = crypto32.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should handle different iteration counts', () => {
-    const crypto = new Crypto(password, salt, algorithm, 5000, keyLength, iv);
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-});
-
-describe('isCrypto', () => {
-  const validCryptoOptions: CryptoOptions = {
-    password: 'testPassword',
-    salt: 'testSalt',
-    algorithm: 'SHA512',
-    iterations: 1000,
-    keyLength: 32,
-    iv: 5,
-  };
-
-  it('should return true for a valid Crypto instance created with ICryptoOptions', () => {
-    const crypto = new Crypto(validCryptoOptions);
-    expect(isCrypto(crypto)).toBe(true);
-  });
-
-  it('should return true for a valid Crypto instance created with separate parameters', () => {
-    const crypto = new Crypto(
-      validCryptoOptions.password,
-      validCryptoOptions.salt,
-      validCryptoOptions.algorithm,
-      validCryptoOptions.iterations,
-      validCryptoOptions.keyLength,
-      validCryptoOptions.iv
-    );
-    expect(isCrypto(crypto)).toBe(true);
-  });
-
-  it('should return false for null', () => {
-    const nullObject = null;
-    expect(isCrypto(nullObject)).toBe(false);
-  });
-
-  it('should return false for undefined', () => {
-    const undefinedObject = undefined;
-    expect(isCrypto(undefinedObject)).toBe(false);
-  });
-
-  it('should return false for a plain object without encrypt and decrypt methods', () => {
-    const plainObject = {
-      someMethod: () => {},
-    };
-    expect(isCrypto(plainObject)).toBe(false);
-  });
-});
-
-describe('Compatibility with previous version', () => {
-
-  const plainText = 'Проверка связи';
-  let options: CryptoOptions;
-  let encText = 'a4661cb701751a895f65418ed488faad33da3090d05ad661f0a7a9';
-
-  beforeEach(() => {
-    options = {
-      algorithm: 'SHA512',
-      iv: 5,
-      keyLength: 32,
-      iterations: 1000,
-      password: 'password',
-      salt: 'saltsaltsalt',
-    };
-  });
-
-  it('should return correct string', () => {
-    const crypto = new Crypto(options);
-
-    const decryptedText = crypto.decrypt(encText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should return correct encrypt-decrypt', () => {
-    const crypto = new Crypto(options);
-
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "outDir": "./dist",
-    "declaration": true,
-    "skipLibCheck": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "coverage",
-    "docs"
-  ]
-}

package/vitest.config.ts

@@ -1,36 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  resolve: {
-    extensions: ['.ts', '.js']
-  },
-  test: {
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'html', 'lcov', 'json'],
-      reportsDirectory: './coverage',
-      clean: true,
-      exclude: [
-        'node_modules/**',
-        'dist/**',
-        'docs/**',
-        'coverage/**',
-        '**/__tests__/**',
-        '**/*.test.ts',
-        '**/*.spec.ts',
-        '**/*.config.ts',
-        '**/index.ts'
-      ],
-      include: ['src/crypto.ts'],
-      thresholds: {
-        lines: 90,
-        functions: 85,
-        branches: 90,
-        statements: 90
-      }
-    },
-    include: ['src/**/__tests__/**/*.test.ts'],
-    exclude: ['node_modules', 'dist', 'docs']
-  }
-});