strata-storage 2.6.1 → 2.7.1

package/dist/features/compression/index.d.ts

@@ -1,2 +1,2 @@
-export * from '../compression';
+export * from "../compression.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/compression.d.ts

@@ -6,7 +6,11 @@
  * Compression configuration
  */
 export interface CompressionConfig {
-    algorithm?: 'lz' | 'gzip';
+    /**
+     * Compression algorithm. Only the bundled zero-dependency LZ codec is
+     * implemented (`'lz'`); the field is kept for forward compatibility.
+     */
+    algorithm?: 'lz';
     threshold?: number;
     level?: number;
 }
@@ -37,22 +41,37 @@ export declare class CompressionManager {
      * Check if data is compressed
      */
     isCompressedData(data: unknown): data is CompressedData;
+    private static readonly FORMAT;
+    private static readonly LZW_MAX_CODE;
     /**
-     * LZ-string compression implementation
+     * LZ compression over UTF-8 bytes.
+     *
+     * The alphabet is bytes (0–255), so the literal-vs-dictionary-code
+     * discriminator (`< 256`) on decompress is correct for ALL input — including
+     * CJK / emoji / symbols whose code points are ≥ 256. (Operating on raw UTF-16
+     * chars previously misclassified any such literal as a dictionary code and
+     * silently corrupted the stored value, or threw on read.)
      */
     private lzCompress;
     /**
-     * LZ-string decompression implementation
+     * LZ decompression — inverse of {@link lzCompress}, reconstructing UTF-8 bytes
+     * then decoding them back to the original string.
      */
     private lzDecompress;
+    private static readonly B64_CHARS;
+    /** Base64-encode raw bytes (btoa when available, else a pure-JS fallback). */
+    private bytesToBase64;
+    /** Decode a base64 string back to raw bytes (atob when available, else pure-JS). */
+    private base64ToBytes;
     /**
-     * Base64 encoding for compressed data
-     */
-    private encodeToBase64;
-    /**
-     * Base64 decoding for compressed data
+     * Legacy decoder for payloads written by <= 2.7.0 (algorithm 'lz'): the
+     * original UTF-16-char LZW over the raw string with a `decodeURIComponent`
+     * base64 layer. Kept read-only so existing compressed-at-rest values still
+     * decode after upgrading to the current byte-LZW codec. (That codec corrupted
+     * non-Latin1 input, so legacy payloads are Latin1 in practice.)
      */
-    private decodeFromBase64;
+    private legacyLzDecompress;
+    private legacyDecodeFromBase64;
     /**
      * Get compression ratio
      */

package/dist/features/compression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/features/compression.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAA8B;gBAEhC,MAAM,GAAE,iBAAsB;IAQ1C;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,OAAO,CAAC;IA8BhE;;OAEG;IACG,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAazE;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc;IAWvD;;OAEG;IACH,OAAO,CAAC,UAAU;IAmClB;;OAEG;IACH,OAAO,CAAC,YAAY;IA+BpB;;OAEG;IACH,OAAO,CAAC,cAAc;IA2BtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;OAEG;IACH,mBAAmB,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM;IAI3D;;OAEG;IACH,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM;CAO7D"}
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/features/compression.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAA8B;gBAEhC,MAAM,GAAE,iBAAsB;IAQ1C;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,OAAO,CAAC;IAkChE;;OAEG;IACG,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAmBzE;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc;IAcvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAW;IAMzC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAU;IAE9C;;;;;;;;OAQG;IACH,OAAO,CAAC,UAAU;IAmClB;;;OAGG;IACH,OAAO,CAAC,YAAY;IA4CpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CACoC;IAErE,8EAA8E;IAC9E,OAAO,CAAC,aAAa;IAyBrB,oFAAoF;IACpF,OAAO,CAAC,aAAa;IA2BrB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IA8B1B,OAAO,CAAC,sBAAsB;IAiB9B;;OAEG;IACH,mBAAmB,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM;IAI3D;;OAEG;IACH,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM;CAO7D"}

package/dist/features/compression.js

@@ -34,8 +34,12 @@ export class CompressionManager {
                 return data;
             }
             return {
+                // Tag the on-disk format so decompress() can pick the right decoder.
+                // Older releases wrote `algorithm: 'lz'` with a UTF-16-char codec that
+                // corrupted non-Latin1 data; the current byte-LZW format is tagged
+                // distinctly and old 'lz' payloads still read via the legacy path.
                 data: compressed,
-                algorithm: this.config.algorithm,
+                algorithm: CompressionManager.FORMAT,
                 originalSize,
                 compressedSize,
             };
@@ -52,7 +56,12 @@ export class CompressionManager {
             if (!this.isCompressedData(compressedData)) {
                 return compressedData;
             }
-            const decompressed = this.lzDecompress(compressedData.data);
+            // Route by stored format tag: the current byte-LZW format vs. the legacy
+            // UTF-16-char codec written by <= 2.7.0 (algorithm 'lz'), so existing
+            // compressed-at-rest values keep decoding after upgrade.
+            const decompressed = compressedData.algorithm === CompressionManager.FORMAT
+                ? this.lzDecompress(compressedData.data)
+                : this.legacyLzDecompress(compressedData.data);
             return JSON.parse(decompressed);
         }
         catch (error) {
@@ -70,120 +79,198 @@ export class CompressionManager {
             'originalSize' in data &&
             'compressedSize' in data);
     }
+    // Format tag stored in CompressedData.algorithm for the current byte-LZW
+    // codec. Payloads written by <= 2.7.0 are tagged 'lz' and decode via the
+    // legacy path; anything tagged FORMAT uses the current decoder.
+    static FORMAT = 'lz-u8';
+    // Freeze the LZW dictionary at 16 bits so every token serializes to exactly
+    // two bytes; both encoder and decoder stop growing the dictionary at the same
+    // point, staying in sync. 0xFFFF entries is ample for storage-sized values;
+    // beyond it, already-learned phrases still compress, just no new ones.
+    static LZW_MAX_CODE = 0xffff;
     /**
-     * LZ-string compression implementation
+     * LZ compression over UTF-8 bytes.
+     *
+     * The alphabet is bytes (0–255), so the literal-vs-dictionary-code
+     * discriminator (`< 256`) on decompress is correct for ALL input — including
+     * CJK / emoji / symbols whose code points are ≥ 256. (Operating on raw UTF-16
+     * chars previously misclassified any such literal as a dictionary code and
+     * silently corrupted the stored value, or threw on read.)
      */
     lzCompress(uncompressed) {
-        if (uncompressed == null)
+        const bytes = new TextEncoder().encode(uncompressed);
+        if (bytes.length === 0)
             return '';
-        const context = new Map();
-        const out = [];
-        let currentChar;
-        let phrase = uncompressed.charAt(0);
-        let code = 256;
-        for (let i = 1; i < uncompressed.length; i++) {
-            currentChar = uncompressed.charAt(i);
-            if (context.has(phrase + currentChar)) {
-                phrase += currentChar;
+        const dictionary = new Map();
+        let nextCode = 256;
+        const tokens = [];
+        let phrase = String.fromCharCode(bytes[0]); // byte-string (each char 0–255)
+        for (let i = 1; i < bytes.length; i++) {
+            const current = String.fromCharCode(bytes[i]);
+            const combined = phrase + current;
+            if (dictionary.has(combined)) {
+                phrase = combined;
             }
             else {
-                if (phrase.length > 1) {
-                    out.push(String.fromCharCode(context.get(phrase)));
-                }
-                else {
-                    out.push(phrase);
+                // `phrase` is always either a single byte (literal) or an existing
+                // dictionary entry, so the lookup below is always defined.
+                tokens.push(phrase.length === 1 ? phrase.charCodeAt(0) : dictionary.get(phrase));
+                if (nextCode <= CompressionManager.LZW_MAX_CODE) {
+                    dictionary.set(combined, nextCode++);
                 }
-                context.set(phrase + currentChar, code);
-                code++;
-                phrase = currentChar;
+                phrase = current;
             }
         }
-        if (phrase.length > 1) {
-            out.push(String.fromCharCode(context.get(phrase)));
+        tokens.push(phrase.length === 1 ? phrase.charCodeAt(0) : dictionary.get(phrase));
+        // Serialize each token as a 16-bit big-endian value, then base64.
+        const out = new Uint8Array(tokens.length * 2);
+        for (let i = 0; i < tokens.length; i++) {
+            out[i * 2] = (tokens[i] >> 8) & 0xff;
+            out[i * 2 + 1] = tokens[i] & 0xff;
         }
-        else {
-            out.push(phrase);
-        }
-        return this.encodeToBase64(out.join(''));
+        return this.bytesToBase64(out);
     }
     /**
-     * LZ-string decompression implementation
+     * LZ decompression — inverse of {@link lzCompress}, reconstructing UTF-8 bytes
+     * then decoding them back to the original string.
      */
     lzDecompress(compressed) {
-        if (compressed == null)
+        if (!compressed)
             return '';
-        if (compressed === '')
+        const inBytes = this.base64ToBytes(compressed);
+        const tokenCount = inBytes.length >> 1;
+        if (tokenCount === 0)
             return '';
-        const decoded = this.decodeFromBase64(compressed);
         const dictionary = new Map();
-        let currentChar = decoded.charAt(0);
-        let oldPhrase = currentChar;
-        const out = [currentChar];
-        let code = 256;
-        let phrase;
-        for (let i = 1; i < decoded.length; i++) {
-            const currentCode = decoded.charCodeAt(i);
-            if (currentCode < 256) {
-                phrase = decoded.charAt(i);
+        let nextCode = 256;
+        const readToken = (i) => (inBytes[i * 2] << 8) | inBytes[i * 2 + 1];
+        // The first token is always a literal byte (the dictionary starts empty).
+        let oldPhrase = String.fromCharCode(readToken(0));
+        const out = [oldPhrase];
+        for (let i = 1; i < tokenCount; i++) {
+            const code = readToken(i);
+            let phrase;
+            if (code < 256) {
+                phrase = String.fromCharCode(code);
+            }
+            else if (dictionary.has(code)) {
+                phrase = dictionary.get(code);
             }
             else {
-                phrase = dictionary.get(currentCode) || oldPhrase + currentChar;
+                // Classic LZW edge: the code equals the entry we are about to define.
+                phrase = oldPhrase + oldPhrase.charAt(0);
             }
             out.push(phrase);
-            currentChar = phrase.charAt(0);
-            dictionary.set(code, oldPhrase + currentChar);
-            code++;
+            if (nextCode <= CompressionManager.LZW_MAX_CODE) {
+                dictionary.set(nextCode++, oldPhrase + phrase.charAt(0));
+            }
             oldPhrase = phrase;
         }
-        return out.join('');
+        // `out` holds byte-strings; rebuild the byte sequence and UTF-8 decode it.
+        const joined = out.join('');
+        const bytes = new Uint8Array(joined.length);
+        for (let i = 0; i < joined.length; i++) {
+            bytes[i] = joined.charCodeAt(i) & 0xff;
+        }
+        return new TextDecoder().decode(bytes);
     }
-    /**
-     * Base64 encoding for compressed data
-     */
-    encodeToBase64(input) {
+    static B64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    /** Base64-encode raw bytes (btoa when available, else a pure-JS fallback). */
+    bytesToBase64(bytes) {
         if (typeof btoa !== 'undefined') {
-            // Browser environment
-            return btoa(unescape(encodeURIComponent(input)));
+            let binary = '';
+            const chunk = 0x8000;
+            for (let i = 0; i < bytes.length; i += chunk) {
+                binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+            }
+            return btoa(binary);
         }
-        // Pure JS implementation for Node.js or other environments
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        const chars = CompressionManager.B64_CHARS;
         let result = '';
-        let i = 0;
-        while (i < input.length) {
-            const a = input.charCodeAt(i++);
-            const b = i < input.length ? input.charCodeAt(i++) : 0;
-            const c = i < input.length ? input.charCodeAt(i++) : 0;
+        for (let i = 0; i < bytes.length; i += 3) {
+            const a = bytes[i];
+            const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+            const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
             const bitmap = (a << 16) | (b << 8) | c;
             result += chars.charAt((bitmap >> 18) & 63);
             result += chars.charAt((bitmap >> 12) & 63);
-            result += i - 2 < input.length ? chars.charAt((bitmap >> 6) & 63) : '=';
-            result += i - 1 < input.length ? chars.charAt(bitmap & 63) : '=';
+            result += i + 1 < bytes.length ? chars.charAt((bitmap >> 6) & 63) : '=';
+            result += i + 2 < bytes.length ? chars.charAt(bitmap & 63) : '=';
         }
         return result;
     }
+    /** Decode a base64 string back to raw bytes (atob when available, else pure-JS). */
+    base64ToBytes(input) {
+        if (typeof atob !== 'undefined') {
+            const binary = atob(input);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i) & 0xff;
+            }
+            return bytes;
+        }
+        const chars = CompressionManager.B64_CHARS;
+        const clean = input.replace(/[^A-Za-z0-9+/]/g, '');
+        const bytes = [];
+        for (let i = 0; i < clean.length; i += 4) {
+            const e1 = chars.indexOf(clean.charAt(i));
+            const e2 = chars.indexOf(clean.charAt(i + 1));
+            const e3 = chars.indexOf(clean.charAt(i + 2));
+            const e4 = chars.indexOf(clean.charAt(i + 3));
+            const bitmap = (e1 << 18) | (Math.max(e2, 0) << 12) | (Math.max(e3, 0) << 6) | Math.max(e4, 0);
+            bytes.push((bitmap >> 16) & 255);
+            if (e3 !== -1)
+                bytes.push((bitmap >> 8) & 255);
+            if (e4 !== -1)
+                bytes.push(bitmap & 255);
+        }
+        return new Uint8Array(bytes);
+    }
     /**
-     * Base64 decoding for compressed data
+     * Legacy decoder for payloads written by <= 2.7.0 (algorithm 'lz'): the
+     * original UTF-16-char LZW over the raw string with a `decodeURIComponent`
+     * base64 layer. Kept read-only so existing compressed-at-rest values still
+     * decode after upgrading to the current byte-LZW codec. (That codec corrupted
+     * non-Latin1 input, so legacy payloads are Latin1 in practice.)
      */
-    decodeFromBase64(input) {
-        if (typeof atob !== 'undefined') {
-            // Browser environment
-            return decodeURIComponent(escape(atob(input)));
+    legacyLzDecompress(compressed) {
+        if (!compressed)
+            return '';
+        const decoded = typeof atob !== 'undefined'
+            ? decodeURIComponent(escape(atob(compressed)))
+            : this.legacyDecodeFromBase64(compressed);
+        const dictionary = new Map();
+        let currentChar = decoded.charAt(0);
+        let oldPhrase = currentChar;
+        const out = [currentChar];
+        let code = 256;
+        for (let i = 1; i < decoded.length; i++) {
+            const currentCode = decoded.charCodeAt(i);
+            const phrase = currentCode < 256
+                ? decoded.charAt(i)
+                : dictionary.get(currentCode) || oldPhrase + currentChar;
+            out.push(phrase);
+            currentChar = phrase.charAt(0);
+            dictionary.set(code, oldPhrase + currentChar);
+            code++;
+            oldPhrase = phrase;
         }
-        // Pure JS implementation
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        return out.join('');
+    }
+    legacyDecodeFromBase64(input) {
+        const chars = `${CompressionManager.B64_CHARS}=`;
         let result = '';
-        let i = 0;
-        input = input.replace(/[^A-Za-z0-9+/]/g, '');
-        while (i < input.length) {
-            const encoded1 = chars.indexOf(input.charAt(i++));
-            const encoded2 = chars.indexOf(input.charAt(i++));
-            const encoded3 = chars.indexOf(input.charAt(i++));
-            const encoded4 = chars.indexOf(input.charAt(i++));
-            const bitmap = (encoded1 << 18) | (encoded2 << 12) | (encoded3 << 6) | encoded4;
+        const clean = input.replace(/[^A-Za-z0-9+/]/g, '');
+        for (let i = 0; i < clean.length; i += 4) {
+            const e1 = chars.indexOf(clean.charAt(i));
+            const e2 = chars.indexOf(clean.charAt(i + 1));
+            const e3 = chars.indexOf(clean.charAt(i + 2));
+            const e4 = chars.indexOf(clean.charAt(i + 3));
+            const bitmap = (e1 << 18) | (e2 << 12) | (e3 << 6) | e4;
             result += String.fromCharCode((bitmap >> 16) & 255);
-            if (encoded3 !== 64)
+            if (e3 !== 64 && e3 !== -1)
                 result += String.fromCharCode((bitmap >> 8) & 255);
-            if (encoded4 !== 64)
+            if (e4 !== 64 && e4 !== -1)
                 result += String.fromCharCode(bitmap & 255);
         }
         return result;

package/dist/features/encryption/index.d.ts

@@ -1,2 +1,2 @@
-export * from '../encryption';
+export * from "../encryption.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/encryption.d.ts

@@ -10,6 +10,7 @@ export interface EncryptionConfig {
     keyLength?: 128 | 192 | 256;
     iterations?: number;
     saltLength?: number;
+    keyDerivation?: 'PBKDF2';
 }
 /**
  * Encrypted data structure
@@ -20,16 +21,37 @@ export interface EncryptedData {
     iv: string;
     algorithm: string;
     iterations: number;
+    /**
+     * Base64 HMAC-SHA256 tag over (iv || ciphertext), present only for AES-CBC.
+     *
+     * AES-CBC provides confidentiality but NOT authentication, so without a MAC a
+     * CBC ciphertext is malleable and vulnerable to padding-oracle / bit-flip
+     * attacks. We therefore use Encrypt-then-MAC: a separate HMAC key is derived
+     * from the same password (domain-separated salt) and the tag is verified
+     * before decryption. AES-GCM is authenticated by construction and does not
+     * carry this field.
+     */
+    mac?: string;
 }
+/**
+ * Default PBKDF2 iteration count. Raised to 600,000 to match current OWASP
+ * guidance for PBKDF2-HMAC-SHA256. The per-record `iterations` value is stored
+ * in {@link EncryptedData} and used on decrypt, so raising this default never
+ * breaks data written with an older, lower count.
+ */
+export declare const DEFAULT_PBKDF2_ITERATIONS = 600000;
 /**
  * Encryption manager using Web Crypto API
  */
 export declare class EncryptionManager {
     private config;
     private keyCache;
+    private macKeyCache;
     constructor(config?: EncryptionConfig);
     /**
-     * Check if encryption is available
+     * Check if encryption is available. Uses the Web Crypto API via `globalThis`
+     * so it works in browsers, Web Workers, and modern Node.js / SSR runtimes
+     * (Node 20+ exposes `globalThis.crypto.subtle`) — not just the browser.
      */
     isAvailable(): boolean;
     /**
@@ -44,6 +66,32 @@ export declare class EncryptionManager {
      * Derive encryption key from password
      */
     private deriveKey;
+    /**
+     * Derive a separate HMAC-SHA256 key for Encrypt-then-MAC on AES-CBC.
+     *
+     * The HMAC key must be cryptographically independent of the AES key, so the
+     * PBKDF2 salt is domain-separated with a trailing marker byte. The MAC key is
+     * non-extractable and limited to sign/verify.
+     */
+    private deriveMacKey;
+    /**
+     * Import a password string as PBKDF2 key material.
+     */
+    private importPasswordKeyMaterial;
+    /**
+     * Build an opaque cache key by hashing the password together with the public
+     * derivation parameters. Returns a base64 SHA-256 digest so the raw password
+     * is never used as (or recoverable from) the Map key.
+     */
+    private hashCacheKey;
+    /**
+     * Copy a (possibly offset) typed array into a standalone ArrayBuffer.
+     */
+    private toArrayBuffer;
+    /**
+     * Concatenate two buffers into one ArrayBuffer.
+     */
+    private concatBuffers;
     /**
      * Convert ArrayBuffer to base64
      */
@@ -57,7 +105,12 @@ export declare class EncryptionManager {
      */
     clearCache(): void;
     /**
-     * Generate a secure random password
+     * Generate a secure random password.
+     *
+     * Uses rejection sampling so every character in the alphabet is equally
+     * likely. Naive `randomByte % alphabetLength` is biased whenever 256 is not a
+     * multiple of the alphabet length (here 89), making some characters more
+     * probable and slightly reducing entropy.
      */
     generatePassword(length?: number): string;
     /**

package/dist/features/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/features/encryption.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,QAAQ,CAAqC;gBAEzC,MAAM,GAAE,gBAAqB;IASzC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IA8CtE;;OAEG;IACG,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAiCtF;;OAEG;YACW,SAAS;IA8CvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,gBAAgB,CAAC,MAAM,GAAE,MAAW,GAAG,MAAM;IAc7C;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAU1C"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/features/encryption.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,QAAQ,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;;;OASG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,SAAS,CAAC;AAEhD;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,QAAQ,CAAqC;IACrD,OAAO,CAAC,WAAW,CAAqC;gBAE5C,MAAM,GAAE,gBAAqB;IAczC;;;;OAIG;IACH,WAAW,IAAI,OAAO;IAKtB;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAsDtE;;OAEG;IACG,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IA6DtF;;OAEG;YACW,SAAS;IAuCvB;;;;;;OAMG;YACW,YAAY;IAyC1B;;OAEG;YACW,yBAAyB;IASvC;;;;OAIG;YACW,YAAY;IAM1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;;;;;;OAOG;IACH,gBAAgB,CAAC,MAAM,GAAE,MAAW,GAAG,MAAM;IAsB7C;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAU1C"}