@pathscale/secure-local-storage-chacha20-poly1305 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-05-07
+
+### Added
+- Initial renamed fork package: `@pathscale/secure-local-storage-chacha20-poly1305`.
+- ChaCha20-Poly1305 authenticated encryption for stored values.
+- PBKDF2-SHA256 key derivation through `@noble/hashes`.
+- Versioned encrypted value envelope containing algorithm, nonce, ciphertext, and version.
+
+### Changed
+- Replaced the original encryption dependency with `@noble/ciphers`.
+- Updated installation, import examples, package metadata, and npm badges for the renamed package.
+
+### Removed
+- Removed legacy encryption code and package dependencies.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 jahidulsaeid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,403 @@
+# Secure Local Storage ChaCha20-Poly1305
+
+[![npm](https://img.shields.io/npm/v/@pathscale/secure-local-storage-chacha20-poly1305.svg)](https://www.npmjs.com/package/@pathscale/secure-local-storage-chacha20-poly1305) [![downloads](https://img.shields.io/npm/dm/@pathscale/secure-local-storage-chacha20-poly1305.svg)](http://npm-stat.com/charts.html?package=@pathscale/secure-local-storage-chacha20-poly1305) [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A secure, encrypted local storage library with browser fingerprinting for enhanced security. This fork provides a drop-in replacement for localStorage with ChaCha20-Poly1305 authenticated encryption, type preservation, and browser-specific security keys.
+
+## 🚀 Features
+
+- **🔐 Automatic Encryption**: All data is encrypted using ChaCha20-Poly1305 with browser-specific keys
+- **🔍 Browser Fingerprinting**: Generates unique keys based on browser characteristics
+- **📝 Type Preservation**: Maintains original data types (string, number, boolean, object)
+- **🎯 Framework Agnostic**: Works with React, Vue, Angular, Vite, Next.js, and vanilla JavaScript
+- **💾 Memory Caching**: Singleton pattern with in-memory cache for performance
+- **🛡️ Secure by Default**: Each browser generates its own encryption key
+- **⚙️ Configurable**: Extensive configuration options and environment variable support
+- **📦 TypeScript Ready**: Full TypeScript support with comprehensive type definitions
+- **🚀 Production Ready**: Thoroughly tested and optimized for performance
+
+## 🤔 Why Secure Local Storage?
+
+### The Problem with Regular localStorage
+
+Regular localStorage stores data as plain text, making it vulnerable to:
+
+- **Data theft**: Anyone with device access can read your stored data
+- **Cross-browser attacks**: Encrypted data from one browser can be copied to another
+- **No type safety**: Everything is stored as strings, losing original data types
+
+### The Solution
+
+Secure Local Storage generates a unique encryption key for each browser using:
+- Browser fingerprinting (10+ unique identifiers)
+- User-specific hash keys
+- Environment-specific configuration
+
+This ensures that data encrypted in one browser cannot be decrypted in another, even if the encrypted data is copied.
+
+## 📦 Installation
+
+```bash
+npm install @pathscale/secure-local-storage-chacha20-poly1305
+```
+
+or
+
+```bash
+yarn add @pathscale/secure-local-storage-chacha20-poly1305
+```
+
+## 🏃‍♂️ Quick Start
+
+### Basic Usage
+
+```typescript
+import secureLocalStorage from '@pathscale/secure-local-storage-chacha20-poly1305';
+
+// Store different data types
+secureLocalStorage.setItem('user', {
+  name: 'John Doe',
+  age: 30,
+  active: true
+});
+
+secureLocalStorage.setItem('count', 42);
+secureLocalStorage.setItem('enabled', true);
+secureLocalStorage.setItem('message', 'Hello, World!');
+
+// Retrieve data (maintains original types)
+const user = secureLocalStorage.getItem('user'); // Returns object
+const count = secureLocalStorage.getItem('count'); // Returns number
+const enabled = secureLocalStorage.getItem('enabled'); // Returns boolean
+const message = secureLocalStorage.getItem('message'); // Returns string
+
+// Remove items
+secureLocalStorage.removeItem('user');
+
+// Clear all secure storage
+secureLocalStorage.clear();
+
+// Get all keys
+const keys = secureLocalStorage.keys(); // Returns string[]
+
+// Get storage length
+const length = secureLocalStorage.length(); // Returns number
+```
+
+### Advanced Usage
+
+```typescript
+import { SecureLocalStorage } from '@pathscale/secure-local-storage-chacha20-poly1305';
+
+// Create a custom instance with configuration
+const customStorage = SecureLocalStorage.getInstance({
+  hashKey: 'my-custom-key',
+  prefix: 'myapp_',
+  disabledKeys: ['Canvas', 'Fonts'], // Disable specific fingerprint properties
+  debug: true
+});
+
+// Use the custom instance
+customStorage.setItem('data', { custom: true });
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+Secure Local Storage supports multiple frameworks through environment variables:
+
+#### React
+```bash
+REACT_APP_SECURE_LOCAL_STORAGE_HASH_KEY=your-secret-key
+REACT_APP_SECURE_LOCAL_STORAGE_PREFIX=myapp_
+REACT_APP_SECURE_LOCAL_STORAGE_DISABLED_KEYS=Canvas|Fonts
+```
+
+#### Vite
+```bash
+VITE_SECURE_LOCAL_STORAGE_HASH_KEY=your-secret-key
+VITE_SECURE_LOCAL_STORAGE_PREFIX=myapp_
+VITE_SECURE_LOCAL_STORAGE_DISABLED_KEYS=Canvas|Fonts
+```
+
+#### Next.js
+```bash
+NEXT_PUBLIC_SECURE_LOCAL_STORAGE_HASH_KEY=your-secret-key
+NEXT_PUBLIC_SECURE_LOCAL_STORAGE_PREFIX=myapp_
+NEXT_PUBLIC_SECURE_LOCAL_STORAGE_DISABLED_KEYS=Canvas|Fonts
+```
+
+#### Generic/Node.js
+```bash
+SECURE_LOCAL_STORAGE_HASH_KEY=your-secret-key
+SECURE_LOCAL_STORAGE_PREFIX=myapp_
+SECURE_LOCAL_STORAGE_DISABLED_KEYS=Canvas|Fonts
+```
+
+### Vite Configuration
+
+For Vite projects, you need to define `process.env` in your `vite.config.ts`:
+
+```typescript
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  define: {
+    "process.env": {
+      SECURE_LOCAL_STORAGE_HASH_KEY: JSON.stringify(process.env.VITE_SECURE_LOCAL_STORAGE_HASH_KEY),
+      // Add other environment variables as needed
+    },
+  },
+})
+```
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `hashKey` | `string` | `'secure-local-storage-default-key'` | Custom encryption key |
+| `prefix` | `string` | `'sls_'` | Storage key prefix |
+| `disabledKeys` | `FingerprintProperty[]` | `[]` | Disabled fingerprint properties |
+| `debug` | `boolean` | `false` | Enable debug logging |
+
+### Fingerprint Properties
+
+You can disable specific browser fingerprint properties:
+
+| Property | Description |
+|----------|-------------|
+| `UserAgent` | Browser user agent string |
+| `ScreenPrint` | Screen dimensions and color depth |
+| `Plugins` | Installed browser plugins |
+| `Fonts` | Available system fonts |
+| `LocalStorage` | localStorage availability |
+| `SessionStorage` | sessionStorage availability |
+| `TimeZone` | System timezone |
+| `Language` | Browser language |
+| `SystemLanguage` | System language |
+| `Cookie` | Cookie support |
+| `Canvas` | Canvas fingerprint |
+| `Hostname` | Current hostname |
+
+> **Note**: Disabling properties reduces the uniqueness of the browser fingerprint, potentially making encryption less secure.
+
+## 🔧 API Reference
+
+### Methods
+
+#### `setItem(key: string, value: StorageValue): void`
+Stores a value in secure local storage.
+
+```typescript
+secureLocalStorage.setItem('user', { name: 'John', age: 30 });
+```
+
+#### `getItem(key: string): StorageValue`
+Retrieves a value from secure local storage. Returns `null` if the key doesn't exist.
+
+```typescript
+const user = secureLocalStorage.getItem('user');
+```
+
+#### `removeItem(key: string): void`
+Removes a specific item from secure local storage.
+
+```typescript
+secureLocalStorage.removeItem('user');
+```
+
+#### `clear(): void`
+Removes all items from secure local storage.
+
+```typescript
+secureLocalStorage.clear();
+```
+
+#### `keys(): string[]`
+Returns an array of all keys in secure local storage.
+
+```typescript
+const allKeys = secureLocalStorage.keys();
+```
+
+#### `length(): number`
+Returns the number of items in secure local storage.
+
+```typescript
+const itemCount = secureLocalStorage.length();
+```
+
+### Types
+
+```typescript
+type StorageValue = string | number | boolean | object | null;
+
+interface SecureStorageConfig {
+  hashKey?: string;
+  prefix?: string;
+  disabledKeys?: FingerprintProperty[];
+  debug?: boolean;
+}
+
+type FingerprintProperty = 
+  | 'UserAgent' | 'ScreenPrint' | 'Plugins' | 'Fonts'
+  | 'LocalStorage' | 'SessionStorage' | 'TimeZone' | 'Language'
+  | 'SystemLanguage' | 'Cookie' | 'Canvas' | 'Hostname';
+```
+
+## 🔒 Security Features
+
+### Encryption Details
+- **Algorithm**: ChaCha20-Poly1305 authenticated encryption with PBKDF2-SHA256 key derivation
+- **Key Generation**: Combines user hash key with browser fingerprint
+- **Salt**: Uses a fixed salt for consistent key generation
+- **Iterations**: 1000 PBKDF2 iterations for key strengthening
+
+### Browser Fingerprinting
+The library generates a unique fingerprint using:
+- User agent string
+- Screen dimensions and color depth
+- Installed plugins
+- Available fonts (canvas-based detection)
+- Storage capabilities
+- Timezone and language settings
+- Canvas fingerprint
+- Current hostname
+
+### Data Protection
+- Each encrypted item includes metadata (type, timestamp, version)
+- Type information is preserved and restored
+- Memory cache prevents repeated decryption operations
+- Automatic validation of encrypted data integrity
+
+## 📚 Examples
+
+### React Example
+
+```tsx
+import React, { useState, useEffect } from 'react';
+import secureLocalStorage from '@pathscale/secure-local-storage-chacha20-poly1305';
+
+const UserProfile: React.FC = () => {
+  const [user, setUser] = useState(null);
+
+  useEffect(() => {
+    // Load user from secure storage
+    const savedUser = secureLocalStorage.getItem('user');
+    if (savedUser) {
+      setUser(savedUser);
+    }
+  }, []);
+
+  const saveUser = (userData: any) => {
+    secureLocalStorage.setItem('user', userData);
+    setUser(userData);
+  };
+
+  const logout = () => {
+    secureLocalStorage.removeItem('user');
+    setUser(null);
+  };
+
+  return (
+    <div>
+      {user ? (
+        <div>
+          <h1>Welcome, {user.name}!</h1>
+          <button onClick={logout}>Logout</button>
+        </div>
+      ) : (
+        <button onClick={() => saveUser({ name: 'John', id: 1 })}>
+          Login
+        </button>
+      )}
+    </div>
+  );
+};
+```
+
+### Vue Example
+
+```vue
+<template>
+  <div>
+    <h1 v-if="user">Welcome, {{ user.name }}!</h1>
+    <button @click="toggleUser">
+      {{ user ? 'Logout' : 'Login' }}
+    </button>
+  </div>
+</template>
+
+<script>
+import secureLocalStorage from '@pathscale/secure-local-storage-chacha20-poly1305';
+
+export default {
+  data() {
+    return {
+      user: null
+    };
+  },
+  
+  mounted() {
+    this.user = secureLocalStorage.getItem('user');
+  },
+  
+  methods: {
+    toggleUser() {
+      if (this.user) {
+        secureLocalStorage.removeItem('user');
+        this.user = null;
+      } else {
+        const userData = { name: 'John', id: 1 };
+        secureLocalStorage.setItem('user', userData);
+        this.user = userData;
+      }
+    }
+  }
+};
+</script>
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+Please read our [Contributing Guide](CONTRIBUTING.md) for detailed information on:
+
+- Setting up the development environment
+- Running tests locally  
+- Code style guidelines
+- Submitting pull requests
+- Development workflow
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `npm install`
+3. Build the project: `npm run build`
+4. Run linting: `npm run lint`
+5. Test locally in a browser with the built files
+
+For detailed development instructions, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙋‍♂️ Support
+
+If you have any questions or issues, please:
+
+1. Check the [documentation](#-api-reference)
+2. Search existing issues in the fork repository
+3. Create a new issue if needed
+
+## 🔗 Related Projects
+
+- [noble-ciphers](https://github.com/paulmillr/noble-ciphers) - Audited JavaScript ciphers including ChaCha20-Poly1305
+- [fingerprintjs](https://github.com/fingerprintjs/fingerprintjs) - Browser fingerprinting
+
+---
+
+Forked from `@jahidulsaeid/secure-local-storage` and ported to ChaCha20-Poly1305.

package/dist/SecureLocalStorage.d.ts

@@ -0,0 +1,54 @@
+import { SecureStorageConfig, StorageValue } from './types';
+/**
+ * Secure Local Storage - A secure, encrypted local storage with browser fingerprinting
+ */
+export declare class SecureLocalStorage {
+    private static instance;
+    private fingerprinting;
+    private encryption;
+    private environment;
+    private config;
+    private storageEngine;
+    private prefix;
+    private memoryCache;
+    private isInitialized;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(config?: Partial<SecureStorageConfig>): SecureLocalStorage;
+    /**
+     * Set an item in secure storage
+     */
+    setItem(key: string, value: StorageValue): void;
+    /**
+     * Get an item from secure storage
+     */
+    getItem(key: string): StorageValue;
+    /**
+     * Remove an item from secure storage
+     */
+    removeItem(key: string): void;
+    /**
+     * Clear all items from secure storage
+     */
+    clear(): void;
+    /**
+     * Get all keys in secure storage
+     */
+    keys(): string[];
+    /**
+     * Get the number of items in secure storage
+     */
+    length(): number;
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<SecureStorageConfig>): void;
+    private getStorageEngine;
+    private getStorageKey;
+    private generateDefaultHashKey;
+    private generateSecretKey;
+    private initializeFromStorage;
+}
+//# sourceMappingURL=SecureLocalStorage.d.ts.map

package/dist/SecureLocalStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureLocalStorage.d.ts","sourceRoot":"","sources":["../src/SecureLocalStorage.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAiB,MAAM,SAAS,CAAC;AAE3E;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmC;IAC1D,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,aAAa,CAAkB;IAEvC,OAAO;IA4BP;;OAEG;WACW,WAAW,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,kBAAkB;IAOpF;;OAEG;IACI,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IAqBtD;;OAEG;IACI,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAoCzC;;OAEG;IACI,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAmBpC;;OAEG;IACI,KAAK,IAAI,IAAI;IA+BpB;;OAEG;IACI,IAAI,IAAI,MAAM,EAAE;IAkBvB;;OAEG;IACI,MAAM,IAAI,MAAM;IAIvB;;OAEG;IACI,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,IAAI;IAoBlE,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,qBAAqB;CAsB9B"}

package/dist/encryption.d.ts

@@ -0,0 +1,36 @@
+import { StorageValue } from './types';
+/**
+ * Encryption utility for secure data storage
+ */
+export declare class EncryptionManager {
+    private secretKey;
+    private readonly version;
+    private readonly textEncoder;
+    private readonly textDecoder;
+    constructor(secretKey: string);
+    /**
+     * Update the secret key
+     */
+    updateSecretKey(newSecretKey: string): void;
+    /**
+     * Encrypt data with type preservation
+     */
+    encrypt(data: StorageValue): string;
+    /**
+     * Decrypt data with type restoration
+     */
+    decrypt(encryptedData: string): StorageValue;
+    /**
+     * Validate if data was encrypted with this library
+     */
+    isValidEncryptedData(encryptedData: string): boolean;
+    private deriveKey;
+    private serializeData;
+    private deserializeData;
+    private getDataType;
+    private isChachaEnvelope;
+    private encodeBase64;
+    private decodeBase64;
+    private getGlobalBuffer;
+}
+//# sourceMappingURL=encryption.d.ts.map

package/dist/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAwB,MAAM,SAAS,CAAC;AAuB7D;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAW;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;gBAErC,SAAS,EAAE,MAAM;IAI7B;;OAEG;IACI,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAKlD;;OAEG;IACI,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAsB1C;;OAEG;IACI,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,YAAY;IAoBnD;;OAEG;IACI,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;IAe3D,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,eAAe;CAGxB"}

package/dist/environment.d.ts

@@ -0,0 +1,17 @@
+import { SecureStorageConfig } from './types';
+/**
+ * Environment configuration manager for different frameworks
+ */
+export declare class EnvironmentManager {
+    private config;
+    constructor();
+    /**
+     * Get configuration from environment variables
+     */
+    getConfig(): SecureStorageConfig;
+    private loadEnvironmentVariables;
+    private getHashKey;
+    private getPrefix;
+    private getDisabledKeys;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,mBAAmB,EAAuB,MAAM,SAAS,CAAC;AAEtF;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAoB;;IAMlC;;OAEG;IACI,SAAS,IAAI,mBAAmB;IAgBvC,OAAO,CAAC,wBAAwB;IAsBhC,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,eAAe;CAcxB"}

package/dist/fingerprinting.d.ts

@@ -0,0 +1,30 @@
+import { BrowserFingerprint, FingerprintProperty } from './types';
+/**
+ * Browser fingerprinting utility for generating unique browser identifiers
+ */
+export declare class BrowserFingerprinting {
+    private disabledKeys;
+    constructor(disabledKeys?: FingerprintProperty[]);
+    /**
+     * Generate a comprehensive browser fingerprint
+     */
+    generateFingerprint(): BrowserFingerprint;
+    /**
+     * Convert fingerprint to a hash string
+     */
+    fingerprintToString(fingerprint: BrowserFingerprint): string;
+    private isEnabled;
+    private getUserAgent;
+    private getScreenPrint;
+    private getPlugins;
+    private getFonts;
+    private hasLocalStorage;
+    private hasSessionStorage;
+    private getTimeZone;
+    private getLanguage;
+    private getSystemLanguage;
+    private hasCookieSupport;
+    private getCanvasFingerprint;
+    private getHostname;
+}
+//# sourceMappingURL=fingerprinting.d.ts.map

package/dist/fingerprinting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprinting.d.ts","sourceRoot":"","sources":["../src/fingerprinting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAElE;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,YAAY,CAA2B;gBAEnC,YAAY,GAAE,mBAAmB,EAAO;IAIpD;;OAEG;IACI,mBAAmB,IAAI,kBAAkB;IAiBhD;;OAEG;IACI,mBAAmB,CAAC,WAAW,EAAE,kBAAkB,GAAG,MAAM;IAMnE,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,QAAQ;IA+BhB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,WAAW;CAIpB"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { SecureLocalStorage } from './SecureLocalStorage';
+export { BrowserFingerprinting } from './fingerprinting';
+export { EncryptionManager } from './encryption';
+export { EnvironmentManager } from './environment';
+export * from './types';
+import { SecureLocalStorage } from './SecureLocalStorage';
+/**
+ * Default secure local storage instance
+ */
+declare const secureLocalStorage: SecureLocalStorage;
+export default secureLocalStorage;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;GAEG;AACH,QAAA,MAAM,kBAAkB,oBAAmC,CAAC;AAE5D,eAAe,kBAAkB,CAAC"}