@sebastienrousseau/crypto-lib 0.0.9 → 0.0.24

package/dist/streaming/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEB_STREAM_HASH_ALGORITHMS = exports.createHashStream = exports.createDecryptStream = exports.createEncryptStream = exports.streamDecrypt = exports.streamEncrypt = exports.STREAM_HASH_ALGORITHMS = exports.createHasher = void 0;
+exports.SLOT_FIXED_OVERHEAD = exports.WRAPPED_CEK_LEN = exports.CEK_LEN = exports.MULTI_PQ_PREFIX_LEN = exports.MULTI_PQ_STREAM_VERSION = exports.MULTI_PQ_STREAM_MAGIC = exports.streamMultiPqDecrypt = exports.streamMultiPqEncrypt = exports.PQ_STREAM_HEADER_LEN = exports.streamPqDecrypt = exports.streamPqEncrypt = exports.WEB_STREAM_HASH_ALGORITHMS = exports.createMultiPqDecryptStream = exports.createMultiPqEncryptStream = exports.createPqDecryptStream = exports.createPqEncryptStream = exports.createHashStream = exports.createDecryptStream = exports.createEncryptStream = exports.streamDecrypt = exports.streamEncrypt = exports.STREAM_HASH_ALGORITHMS = exports.createHasher = void 0;
 var stream_hash_1 = require("./stream-hash");
 Object.defineProperty(exports, "createHasher", { enumerable: true, get: function () { return stream_hash_1.createHasher; } });
 Object.defineProperty(exports, "STREAM_HASH_ALGORITHMS", { enumerable: true, get: function () { return stream_hash_1.STREAM_HASH_ALGORITHMS; } });
@@ -11,5 +11,22 @@ var web_streams_1 = require("./web-streams");
 Object.defineProperty(exports, "createEncryptStream", { enumerable: true, get: function () { return web_streams_1.createEncryptStream; } });
 Object.defineProperty(exports, "createDecryptStream", { enumerable: true, get: function () { return web_streams_1.createDecryptStream; } });
 Object.defineProperty(exports, "createHashStream", { enumerable: true, get: function () { return web_streams_1.createHashStream; } });
+Object.defineProperty(exports, "createPqEncryptStream", { enumerable: true, get: function () { return web_streams_1.createPqEncryptStream; } });
+Object.defineProperty(exports, "createPqDecryptStream", { enumerable: true, get: function () { return web_streams_1.createPqDecryptStream; } });
+Object.defineProperty(exports, "createMultiPqEncryptStream", { enumerable: true, get: function () { return web_streams_1.createMultiPqEncryptStream; } });
+Object.defineProperty(exports, "createMultiPqDecryptStream", { enumerable: true, get: function () { return web_streams_1.createMultiPqDecryptStream; } });
 Object.defineProperty(exports, "WEB_STREAM_HASH_ALGORITHMS", { enumerable: true, get: function () { return web_streams_1.WEB_STREAM_HASH_ALGORITHMS; } });
+var stream_pq_aead_1 = require("./stream-pq-aead");
+Object.defineProperty(exports, "streamPqEncrypt", { enumerable: true, get: function () { return stream_pq_aead_1.streamPqEncrypt; } });
+Object.defineProperty(exports, "streamPqDecrypt", { enumerable: true, get: function () { return stream_pq_aead_1.streamPqDecrypt; } });
+Object.defineProperty(exports, "PQ_STREAM_HEADER_LEN", { enumerable: true, get: function () { return stream_pq_aead_1.PQ_STREAM_HEADER_LEN; } });
+var stream_multi_pq_aead_1 = require("./stream-multi-pq-aead");
+Object.defineProperty(exports, "streamMultiPqEncrypt", { enumerable: true, get: function () { return stream_multi_pq_aead_1.streamMultiPqEncrypt; } });
+Object.defineProperty(exports, "streamMultiPqDecrypt", { enumerable: true, get: function () { return stream_multi_pq_aead_1.streamMultiPqDecrypt; } });
+Object.defineProperty(exports, "MULTI_PQ_STREAM_MAGIC", { enumerable: true, get: function () { return stream_multi_pq_aead_1.MULTI_PQ_STREAM_MAGIC; } });
+Object.defineProperty(exports, "MULTI_PQ_STREAM_VERSION", { enumerable: true, get: function () { return stream_multi_pq_aead_1.MULTI_PQ_STREAM_VERSION; } });
+Object.defineProperty(exports, "MULTI_PQ_PREFIX_LEN", { enumerable: true, get: function () { return stream_multi_pq_aead_1.MULTI_PQ_PREFIX_LEN; } });
+Object.defineProperty(exports, "CEK_LEN", { enumerable: true, get: function () { return stream_multi_pq_aead_1.CEK_LEN; } });
+Object.defineProperty(exports, "WRAPPED_CEK_LEN", { enumerable: true, get: function () { return stream_multi_pq_aead_1.WRAPPED_CEK_LEN; } });
+Object.defineProperty(exports, "SLOT_FIXED_OVERHEAD", { enumerable: true, get: function () { return stream_multi_pq_aead_1.SLOT_FIXED_OVERHEAD; } });
 //# sourceMappingURL=index.js.map

package/dist/streaming/stream-multi-pq-aead.d.ts

@@ -0,0 +1,35 @@
+export declare const MULTI_PQ_STREAM_MAGIC: Uint8Array<ArrayBuffer>;
+export declare const MULTI_PQ_STREAM_VERSION = 1;
+export declare const MULTI_PQ_PREFIX_LEN = 35;
+export declare const CEK_LEN = 32;
+export declare const WRAPPED_CEK_LEN: number;
+export declare const SLOT_FIXED_OVERHEAD: number;
+export interface MultiPqRecipient {
+    recipientId: string;
+    recipientX25519Public: string | Uint8Array;
+    recipientMlKemPublic: string | Uint8Array;
+}
+export interface StreamMultiPqEncryptOptions {
+    recipients: MultiPqRecipient[];
+    plaintext: Uint8Array;
+    chunkSize?: number | undefined;
+}
+export interface StreamMultiPqEncryptResult {
+    ciphertext: Uint8Array;
+    algorithm: "multi-x25519-ml-kem-768-xchacha20-poly1305-stream";
+    recipientCount: number;
+}
+export interface StreamMultiPqDecryptOptions {
+    recipientId?: string | undefined;
+    recipientX25519Secret: string | Uint8Array;
+    recipientMlKemSecret: string | Uint8Array;
+    ciphertext: Uint8Array;
+    chunkSize?: number | undefined;
+}
+export interface StreamMultiPqDecryptResult {
+    plaintext: Uint8Array;
+    recipientId: string;
+}
+export declare function streamMultiPqEncrypt(options: StreamMultiPqEncryptOptions): StreamMultiPqEncryptResult;
+export declare function streamMultiPqDecrypt(options: StreamMultiPqDecryptOptions): StreamMultiPqDecryptResult;
+//# sourceMappingURL=stream-multi-pq-aead.d.ts.map

package/dist/streaming/stream-multi-pq-aead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-multi-pq-aead.d.ts","sourceRoot":"","sources":["../../src/streaming/stream-multi-pq-aead.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,qBAAqB,yBAA2C,CAAC;AAG9E,eAAO,MAAM,uBAAuB,IAAO,CAAC;AAG5C,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAGtC,eAAO,MAAM,OAAO,KAAK,CAAC;AAG1B,eAAO,MAAM,eAAe,QAAoB,CAAC;AAGjD,eAAO,MAAM,mBAAmB,QACiC,CAAC;AAOlE,MAAM,WAAW,gBAAgB;IAE/B,WAAW,EAAE,MAAM,CAAC;IAEpB,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3C;AAGD,MAAM,WAAW,2BAA2B;IAE1C,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAE/B,SAAS,EAAE,UAAU,CAAC;IAEtB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAGD,MAAM,WAAW,0BAA0B;IAEzC,UAAU,EAAE,UAAU,CAAC;IAEvB,SAAS,EAAE,mDAAmD,CAAC;IAE/D,cAAc,EAAE,MAAM,CAAC;CACxB;AAGD,MAAM,WAAW,2BAA2B;IAE1C,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjC,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1C,UAAU,EAAE,UAAU,CAAC;IAEvB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAGD,MAAM,WAAW,0BAA0B;IAEzC,SAAS,EAAE,UAAU,CAAC;IAEtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAgLD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CAsD5B;AAwND,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CAyC5B"}

package/dist/streaming/stream-multi-pq-aead.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLOT_FIXED_OVERHEAD = exports.WRAPPED_CEK_LEN = exports.CEK_LEN = exports.MULTI_PQ_PREFIX_LEN = exports.MULTI_PQ_STREAM_VERSION = exports.MULTI_PQ_STREAM_MAGIC = void 0;
+exports.streamMultiPqEncrypt = streamMultiPqEncrypt;
+exports.streamMultiPqDecrypt = streamMultiPqDecrypt;
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const ml_kem_js_1 = require("@noble/post-quantum/ml-kem.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const utils_1 = require("../utils");
+const stream_pq_aead_1 = require("./stream-pq-aead");
+exports.MULTI_PQ_STREAM_MAGIC = new Uint8Array([0x4d, 0x53, 0x50, 0x51]);
+exports.MULTI_PQ_STREAM_VERSION = 0x01;
+exports.MULTI_PQ_PREFIX_LEN = 35;
+exports.CEK_LEN = 32;
+exports.WRAPPED_CEK_LEN = exports.CEK_LEN + stream_pq_aead_1.TAG_LEN;
+exports.SLOT_FIXED_OVERHEAD = 1 + stream_pq_aead_1.EPHEMERAL_LEN + stream_pq_aead_1.ML_KEM_CT_LEN + stream_pq_aead_1.NONCE_LEN + exports.WRAPPED_CEK_LEN;
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+const KEK_INFO = TEXT_ENCODER.encode("multi-pq-stream-kek-v1");
+function validateRecipient(r) {
+    if (!r.recipientId || typeof r.recipientId !== "string") {
+        throw new Error("Recipient ID must be a non-empty string");
+    }
+    const idBytes = TEXT_ENCODER.encode(r.recipientId);
+    if (idBytes.length === 0 || idBytes.length > 255) {
+        throw new Error("Recipient ID must be between 1 and 255 UTF-8 bytes");
+    }
+    const x25519Pub = (0, stream_pq_aead_1.toBytes)(r.recipientX25519Public, 32, "recipientX25519Public");
+    const mlKemPub = (0, stream_pq_aead_1.toBytes)(r.recipientMlKemPublic, 1184, "recipientMlKemPublic");
+    return { idBytes, x25519Pub, mlKemPub };
+}
+function createSlot(cek, slotIndex, r) {
+    const { idBytes, x25519Pub, mlKemPub } = validateRecipient(r);
+    const ephPriv = (0, utils_js_1.randomBytes)(32);
+    const ephPub = ed25519_js_1.x25519.getPublicKey(ephPriv);
+    const x25519Shared = ed25519_js_1.x25519.getSharedSecret(ephPriv, x25519Pub);
+    const { cipherText: mlKemCt, sharedSecret: mlKemShared } = ml_kem_js_1.ml_kem768.encapsulate(mlKemPub);
+    const combined = new Uint8Array(64);
+    combined.set(x25519Shared, 0);
+    combined.set(mlKemShared, 32);
+    const kek = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, combined, ephPub, KEK_INFO, 32);
+    const slotNonce = (0, utils_js_1.randomBytes)(stream_pq_aead_1.NONCE_LEN);
+    const aad = buildSlotAad(idBytes, slotIndex);
+    const wrappedCek = (0, chacha_js_1.xchacha20poly1305)(kek, slotNonce, aad).encrypt(cek);
+    (0, utils_1.wipeMemory)(ephPriv);
+    (0, utils_1.wipeMemory)(x25519Shared);
+    (0, utils_1.wipeMemory)(mlKemShared);
+    (0, utils_1.wipeMemory)(combined);
+    (0, utils_1.wipeMemory)(kek);
+    return serializeSlot(idBytes, ephPub, mlKemCt, slotNonce, wrappedCek);
+}
+function buildSlotAad(idBytes, slotIndex) {
+    const aad = new Uint8Array(idBytes.length + 4);
+    aad.set(idBytes, 0);
+    const view = new DataView(aad.buffer, aad.byteOffset, aad.byteLength);
+    view.setUint32(idBytes.length, slotIndex, false);
+    return aad;
+}
+function serializeSlot(idBytes, ephPub, mlKemCt, slotNonce, wrappedCek) {
+    const slotLen = exports.SLOT_FIXED_OVERHEAD + idBytes.length;
+    const out = new Uint8Array(slotLen);
+    out[0] = idBytes.length;
+    let pos = 1;
+    out.set(idBytes, pos);
+    pos += idBytes.length;
+    out.set(ephPub, pos);
+    pos += stream_pq_aead_1.EPHEMERAL_LEN;
+    out.set(mlKemCt, pos);
+    pos += stream_pq_aead_1.ML_KEM_CT_LEN;
+    out.set(slotNonce, pos);
+    pos += stream_pq_aead_1.NONCE_LEN;
+    out.set(wrappedCek, pos);
+    return out;
+}
+function computeMultiStreamOutputSize(headerLen, ptLen, chunkSize) {
+    const numFullChunks = Math.floor(ptLen / chunkSize);
+    const lastChunkLen = ptLen - numFullChunks * chunkSize;
+    const hasExtra = lastChunkLen > 0 || ptLen === 0;
+    const totalChunks = hasExtra ? numFullChunks + 1 : numFullChunks;
+    let totalSize = headerLen;
+    for (let i = 0; i < totalChunks; i++) {
+        const len = i < numFullChunks ? chunkSize : lastChunkLen > 0 ? lastChunkLen : 0;
+        totalSize += 1 + len + stream_pq_aead_1.TAG_LEN;
+    }
+    return totalSize;
+}
+function encryptStreamChunks(plaintext, cek, baseNonce, chunkSize, output, headerLen) {
+    const numFullChunks = Math.floor(plaintext.length / chunkSize);
+    const hasExtra = plaintext.length % chunkSize > 0 || plaintext.length === 0;
+    const totalChunks = hasExtra ? numFullChunks + 1 : numFullChunks;
+    let offset = headerLen;
+    for (let i = 0; i < totalChunks; i++) {
+        const isFinal = i === totalChunks - 1;
+        const chunkTag = isFinal ? stream_pq_aead_1.CHUNK_TAG_FINAL : stream_pq_aead_1.CHUNK_TAG_MESSAGE;
+        const start = i * chunkSize;
+        const end = isFinal ? plaintext.length : start + chunkSize;
+        const chunk = plaintext.subarray(start, end);
+        const nonce = (0, stream_pq_aead_1.derivePqChunkNonce)(baseNonce, i, chunkTag);
+        const cipher = (0, chacha_js_1.xchacha20poly1305)(cek, nonce);
+        const encrypted = cipher.encrypt(chunk);
+        output[offset] = chunkTag;
+        offset += 1;
+        output.set(encrypted, offset);
+        offset += encrypted.length;
+    }
+}
+function writeHeaderPrefix(out, chunkSize, baseNonce, count) {
+    out.set(exports.MULTI_PQ_STREAM_MAGIC, 0);
+    out[4] = exports.MULTI_PQ_STREAM_VERSION;
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    view.setUint32(5, chunkSize, false);
+    out.set(baseNonce, 9);
+    view.setUint16(33, count, false);
+}
+function streamMultiPqEncrypt(options) {
+    const recipients = options.recipients;
+    if (!Array.isArray(recipients) || recipients.length === 0) {
+        throw new Error("At least one recipient is required");
+    }
+    if (recipients.length > 1000) {
+        throw new Error("Recipient count exceeds maximum limit of 1000");
+    }
+    const chunkSize = options.chunkSize ?? stream_pq_aead_1.DEFAULT_CHUNK_SIZE;
+    if (chunkSize < 1024 || chunkSize > 16 * 1024 * 1024) {
+        throw new Error("Chunk size must be between 1024 and 16777216 bytes");
+    }
+    const cek = (0, utils_js_1.randomBytes)(exports.CEK_LEN);
+    const baseNonce = (0, utils_js_1.randomBytes)(stream_pq_aead_1.NONCE_LEN);
+    const serializedSlots = [];
+    let slotsTotalLen = 0;
+    for (let i = 0; i < recipients.length; i++) {
+        const slotBytes = createSlot(cek, i, recipients[i]);
+        serializedSlots.push(slotBytes);
+        slotsTotalLen += slotBytes.length;
+    }
+    const headerLen = exports.MULTI_PQ_PREFIX_LEN + slotsTotalLen;
+    const totalSize = computeMultiStreamOutputSize(headerLen, options.plaintext.length, chunkSize);
+    const output = new Uint8Array(totalSize);
+    writeHeaderPrefix(output, chunkSize, baseNonce, recipients.length);
+    let slotOffset = exports.MULTI_PQ_PREFIX_LEN;
+    for (const s of serializedSlots) {
+        output.set(s, slotOffset);
+        slotOffset += s.length;
+    }
+    encryptStreamChunks(options.plaintext, cek, baseNonce, chunkSize, output, headerLen);
+    (0, utils_1.wipeMemory)(cek);
+    return {
+        ciphertext: output,
+        algorithm: "multi-x25519-ml-kem-768-xchacha20-poly1305-stream",
+        recipientCount: recipients.length,
+    };
+}
+function parseHeaderPrefix(ciphertext) {
+    if (ciphertext.length < exports.MULTI_PQ_PREFIX_LEN) {
+        throw new Error("Ciphertext too short: missing header prefix");
+    }
+    for (let i = 0; i < 4; i++) {
+        if (ciphertext[i] !== exports.MULTI_PQ_STREAM_MAGIC[i]) {
+            throw new Error("Invalid multi-recipient post-quantum stream magic");
+        }
+    }
+    if (ciphertext[4] !== exports.MULTI_PQ_STREAM_VERSION) {
+        throw new Error(`Unsupported multi-recipient post-quantum stream version: ${ciphertext[4]}`);
+    }
+    const view = new DataView(ciphertext.buffer, ciphertext.byteOffset, ciphertext.byteLength);
+    const chunkSize = view.getUint32(5, false);
+    if (chunkSize < 1024 || chunkSize > 16 * 1024 * 1024) {
+        throw new Error(`Invalid stream header chunk size: ${chunkSize}`);
+    }
+    const baseNonce = ciphertext.subarray(9, 33);
+    const recipientCount = view.getUint16(33, false);
+    if (recipientCount < 1) {
+        throw new Error("Invalid stream header: zero recipients");
+    }
+    return { chunkSize, baseNonce, recipientCount };
+}
+function parseSlots(ciphertext, recipientCount) {
+    let offset = exports.MULTI_PQ_PREFIX_LEN;
+    const slots = [];
+    for (let i = 0; i < recipientCount; i++) {
+        if (offset >= ciphertext.length) {
+            throw new Error("Ciphertext truncated: incomplete slot table");
+        }
+        const idLen = ciphertext[offset];
+        const slotTotalLen = exports.SLOT_FIXED_OVERHEAD + idLen;
+        if (offset + slotTotalLen > ciphertext.length) {
+            throw new Error("Ciphertext truncated: incomplete recipient slot");
+        }
+        const idStart = offset + 1;
+        const recipientIdBytes = ciphertext.subarray(idStart, idStart + idLen);
+        const recipientId = TEXT_DECODER.decode(recipientIdBytes);
+        let pos = idStart + idLen;
+        const ephPub = ciphertext.subarray(pos, pos + stream_pq_aead_1.EPHEMERAL_LEN);
+        pos += stream_pq_aead_1.EPHEMERAL_LEN;
+        const mlKemCt = ciphertext.subarray(pos, pos + stream_pq_aead_1.ML_KEM_CT_LEN);
+        pos += stream_pq_aead_1.ML_KEM_CT_LEN;
+        const slotNonce = ciphertext.subarray(pos, pos + stream_pq_aead_1.NONCE_LEN);
+        pos += stream_pq_aead_1.NONCE_LEN;
+        const wrappedCek = ciphertext.subarray(pos, pos + exports.WRAPPED_CEK_LEN);
+        slots.push({
+            recipientId,
+            recipientIdBytes,
+            slotIndex: i,
+            ephPub,
+            mlKemCt,
+            slotNonce,
+            wrappedCek,
+        });
+        offset += slotTotalLen;
+    }
+    return { slots, headerEndOffset: offset };
+}
+function tryUnwrapSlot(slot, recipX25519Sec, recipMlKemSec) {
+    try {
+        const mlKemShared = ml_kem_js_1.ml_kem768.decapsulate(slot.mlKemCt, recipMlKemSec);
+        const x25519Shared = ed25519_js_1.x25519.getSharedSecret(recipX25519Sec, slot.ephPub);
+        const combined = new Uint8Array(64);
+        combined.set(x25519Shared, 0);
+        combined.set(mlKemShared, 32);
+        const kek = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, combined, slot.ephPub, KEK_INFO, 32);
+        const aad = buildSlotAad(slot.recipientIdBytes, slot.slotIndex);
+        const cek = (0, chacha_js_1.xchacha20poly1305)(kek, slot.slotNonce, aad).decrypt(slot.wrappedCek);
+        (0, utils_1.wipeMemory)(x25519Shared);
+        (0, utils_1.wipeMemory)(mlKemShared);
+        (0, utils_1.wipeMemory)(combined);
+        (0, utils_1.wipeMemory)(kek);
+        return cek;
+    }
+    catch {
+        return null;
+    }
+}
+function readMultiChunkHeader(ciphertext, offset, chunkSize) {
+    const chunkTag = ciphertext[offset];
+    if (chunkTag !== stream_pq_aead_1.CHUNK_TAG_MESSAGE && chunkTag !== stream_pq_aead_1.CHUNK_TAG_FINAL) {
+        throw new Error(`Invalid chunk tag: 0x${chunkTag.toString(16)}`);
+    }
+    const isFinal = chunkTag === stream_pq_aead_1.CHUNK_TAG_FINAL;
+    const start = offset + 1;
+    const encLen = isFinal ? ciphertext.length - start : chunkSize + stream_pq_aead_1.TAG_LEN;
+    if (start + encLen > ciphertext.length) {
+        throw new Error("Ciphertext truncated: incomplete chunk");
+    }
+    return { chunkTag, isFinal, encLen };
+}
+function decryptStreamChunks(ciphertext, headerEndOffset, cek, baseNonce, chunkSize) {
+    let offset = headerEndOffset;
+    const chunks = [];
+    let totalPtLen = 0;
+    let sawFinal = false;
+    while (offset < ciphertext.length) {
+        const { chunkTag, isFinal, encLen } = readMultiChunkHeader(ciphertext, offset, chunkSize);
+        offset += 1;
+        const chunkIdx = chunks.length;
+        const nonce = (0, stream_pq_aead_1.derivePqChunkNonce)(baseNonce, chunkIdx, chunkTag);
+        const cipher = (0, chacha_js_1.xchacha20poly1305)(cek, nonce);
+        const decrypted = cipher.decrypt(ciphertext.subarray(offset, offset + encLen));
+        chunks.push(decrypted);
+        totalPtLen += decrypted.length;
+        offset += encLen;
+        if (isFinal) {
+            sawFinal = true;
+            break;
+        }
+    }
+    if (!sawFinal) {
+        throw new Error("Ciphertext truncated: final chunk missing");
+    }
+    const result = new Uint8Array(totalPtLen);
+    let pos = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, pos);
+        pos += chunk.length;
+    }
+    return result;
+}
+function resolveRecipientCek(slots, recipId, recipX25519Sec, recipMlKemSec) {
+    if (recipId !== undefined) {
+        const slot = slots.find((s) => s.recipientId === recipId) ?? null;
+        if (!slot) {
+            throw new Error(`Recipient ID "${recipId}" not found in stream slots`);
+        }
+        const cek = tryUnwrapSlot(slot, recipX25519Sec, recipMlKemSec);
+        if (!cek) {
+            throw new Error(`Decryption failed for recipient slot "${recipId}"`);
+        }
+        return { cek, matchingSlot: slot };
+    }
+    for (const slot of slots) {
+        const cek = tryUnwrapSlot(slot, recipX25519Sec, recipMlKemSec);
+        if (cek) {
+            return { cek, matchingSlot: slot };
+        }
+    }
+    throw new Error("No matching recipient key slot could be decrypted");
+}
+function streamMultiPqDecrypt(options) {
+    const recipX25519Sec = (0, stream_pq_aead_1.toBytes)(options.recipientX25519Secret, 32, "recipientX25519Secret");
+    const recipMlKemSec = (0, stream_pq_aead_1.toBytes)(options.recipientMlKemSecret, 2400, "recipientMlKemSecret");
+    const ciphertext = options.ciphertext;
+    const { chunkSize: headerChunkSize, baseNonce, recipientCount, } = parseHeaderPrefix(ciphertext);
+    const effectiveChunkSize = options.chunkSize ?? headerChunkSize;
+    const { slots, headerEndOffset } = parseSlots(ciphertext, recipientCount);
+    const { cek, matchingSlot } = resolveRecipientCek(slots, options.recipientId, recipX25519Sec, recipMlKemSec);
+    const plaintext = decryptStreamChunks(ciphertext, headerEndOffset, cek, baseNonce, effectiveChunkSize);
+    (0, utils_1.wipeMemory)(cek);
+    return {
+        plaintext,
+        recipientId: matchingSlot.recipientId,
+    };
+}
+//# sourceMappingURL=stream-multi-pq-aead.js.map

package/dist/streaming/stream-pq-aead.d.ts

@@ -0,0 +1,29 @@
+export declare const EPHEMERAL_LEN = 32;
+export declare const ML_KEM_CT_LEN = 1088;
+export declare const NONCE_LEN = 24;
+export declare const TAG_LEN = 16;
+export declare const PQ_STREAM_HEADER_LEN: number;
+export declare const DEFAULT_CHUNK_SIZE: number;
+export declare const CHUNK_TAG_MESSAGE = 0;
+export declare const CHUNK_TAG_FINAL = 1;
+export declare function toBytes(data: string | Uint8Array, expectedLen?: number, name?: string): Uint8Array;
+export declare function derivePqChunkNonce(baseNonce: Uint8Array, counter: number, tag: number): Uint8Array;
+export interface StreamPqEncryptOptions {
+    recipientX25519Public: string | Uint8Array;
+    recipientMlKemPublic: string | Uint8Array;
+    plaintext: Uint8Array;
+    chunkSize?: number | undefined;
+}
+export interface StreamPqEncryptResult {
+    ciphertext: Uint8Array;
+    algorithm: "x25519-ml-kem-768-xchacha20-poly1305-stream";
+}
+export interface StreamPqDecryptOptions {
+    recipientX25519Secret: string | Uint8Array;
+    recipientMlKemSecret: string | Uint8Array;
+    ciphertext: Uint8Array;
+    chunkSize?: number | undefined;
+}
+export declare function streamPqEncrypt(options: StreamPqEncryptOptions): StreamPqEncryptResult;
+export declare function streamPqDecrypt(options: StreamPqDecryptOptions): Uint8Array;
+//# sourceMappingURL=stream-pq-aead.d.ts.map

package/dist/streaming/stream-pq-aead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-pq-aead.d.ts","sourceRoot":"","sources":["../../src/streaming/stream-pq-aead.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,eAAO,MAAM,OAAO,KAAK,CAAC;AAE1B,eAAO,MAAM,oBAAoB,QAA4C,CAAC;AAE9E,eAAO,MAAM,kBAAkB,QAAY,CAAC;AAE5C,eAAO,MAAM,iBAAiB,IAAO,CAAC;AAEtC,eAAO,MAAM,eAAe,IAAO,CAAC;AAKpC,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,GAAG,UAAU,EACzB,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,SAAS,GACZ,UAAU,CAYZ;AAGD,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACV,UAAU,CAiBZ;AAGD,MAAM,WAAW,sBAAsB;IACrC,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAC3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;IAC1C,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAGD,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,6CAA6C,CAAC;CAC1D;AAGD,MAAM,WAAW,sBAAsB;IACrC,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAC3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;IAC1C,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAqGD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAiCvB;AA6ED,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,UAAU,CAoC3E"}

package/dist/streaming/stream-pq-aead.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHUNK_TAG_FINAL = exports.CHUNK_TAG_MESSAGE = exports.DEFAULT_CHUNK_SIZE = exports.PQ_STREAM_HEADER_LEN = exports.TAG_LEN = exports.NONCE_LEN = exports.ML_KEM_CT_LEN = exports.EPHEMERAL_LEN = void 0;
+exports.toBytes = toBytes;
+exports.derivePqChunkNonce = derivePqChunkNonce;
+exports.streamPqEncrypt = streamPqEncrypt;
+exports.streamPqDecrypt = streamPqDecrypt;
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const ml_kem_js_1 = require("@noble/post-quantum/ml-kem.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+exports.EPHEMERAL_LEN = 32;
+exports.ML_KEM_CT_LEN = 1088;
+exports.NONCE_LEN = 24;
+exports.TAG_LEN = 16;
+exports.PQ_STREAM_HEADER_LEN = exports.EPHEMERAL_LEN + exports.ML_KEM_CT_LEN + exports.NONCE_LEN;
+exports.DEFAULT_CHUNK_SIZE = 64 * 1024;
+exports.CHUNK_TAG_MESSAGE = 0x00;
+exports.CHUNK_TAG_FINAL = 0x01;
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function toBytes(data, expectedLen, name = "Data") {
+    let buf;
+    if (typeof data === "string") {
+        if (!HEX_RE.test(data))
+            throw new Error(`Invalid hex string for ${name}`);
+        buf = Buffer.from(data, "hex");
+    }
+    else {
+        buf = new Uint8Array(data);
+    }
+    if (expectedLen !== undefined && buf.length !== expectedLen) {
+        throw new Error(`${name} must be ${expectedLen} bytes, got ${buf.length}`);
+    }
+    return buf;
+}
+function derivePqChunkNonce(baseNonce, counter, tag) {
+    const nonce = new Uint8Array(baseNonce);
+    const view = new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength);
+    const low = counter & 0xffffffff;
+    const high = (counter / 0x100000000) | 0;
+    view.setUint32(nonce.length - 8, view.getUint32(nonce.length - 8) ^ low, true);
+    view.setUint32(nonce.length - 4, view.getUint32(nonce.length - 4) ^ high, true);
+    nonce[0] = nonce[0] ^ tag;
+    return nonce;
+}
+function deriveSharedKey(x25519Shared, mlKemShared, ephPub) {
+    const combined = new Uint8Array(x25519Shared.length + mlKemShared.length);
+    combined.set(x25519Shared);
+    combined.set(mlKemShared, x25519Shared.length);
+    return (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, combined, ephPub, new TextEncoder().encode("pq-stream-aead-v1"), 32);
+}
+function encapsulateKeyMaterial(recipX25519Pub, recipMlKemPub) {
+    const ephPriv = (0, utils_js_1.randomBytes)(32);
+    const ephPub = ed25519_js_1.x25519.getPublicKey(ephPriv);
+    const x25519Shared = ed25519_js_1.x25519.getSharedSecret(ephPriv, recipX25519Pub);
+    const { cipherText: mlKemCt, sharedSecret: mlKemShared } = ml_kem_js_1.ml_kem768.encapsulate(recipMlKemPub);
+    const key = deriveSharedKey(x25519Shared, mlKemShared, ephPub);
+    return { ephPub, mlKemCt, key };
+}
+function decapsulateKeyMaterial(recipX25519Sec, recipMlKemSec, ephPub, mlKemCt) {
+    const mlKemShared = ml_kem_js_1.ml_kem768.decapsulate(mlKemCt, recipMlKemSec);
+    const x25519Shared = ed25519_js_1.x25519.getSharedSecret(recipX25519Sec, ephPub);
+    return deriveSharedKey(x25519Shared, mlKemShared, ephPub);
+}
+function computeStreamOutputSize(ptLen, chunkSize) {
+    const numFullChunks = Math.floor(ptLen / chunkSize);
+    const lastChunkLen = ptLen - numFullChunks * chunkSize;
+    const hasExtraChunk = lastChunkLen > 0 || ptLen === 0;
+    const totalChunks = hasExtraChunk ? numFullChunks + 1 : numFullChunks;
+    let totalSize = exports.PQ_STREAM_HEADER_LEN;
+    for (let i = 0; i < totalChunks; i++) {
+        const len = i < numFullChunks ? chunkSize : lastChunkLen > 0 ? lastChunkLen : 0;
+        totalSize += 1 + len + exports.TAG_LEN;
+    }
+    return totalSize;
+}
+function encryptChunks(plaintext, key, baseNonce, chunkSize, output) {
+    const numFullChunks = Math.floor(plaintext.length / chunkSize);
+    const hasExtra = plaintext.length % chunkSize > 0 || plaintext.length === 0;
+    const totalChunks = hasExtra ? numFullChunks + 1 : numFullChunks;
+    let offset = exports.PQ_STREAM_HEADER_LEN;
+    for (let i = 0; i < totalChunks; i++) {
+        const isFinal = i === totalChunks - 1;
+        const chunkTag = isFinal ? exports.CHUNK_TAG_FINAL : exports.CHUNK_TAG_MESSAGE;
+        const start = i * chunkSize;
+        const end = isFinal ? plaintext.length : start + chunkSize;
+        const chunk = plaintext.subarray(start, end);
+        const nonce = derivePqChunkNonce(baseNonce, i, chunkTag);
+        const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce);
+        const encrypted = cipher.encrypt(chunk);
+        output[offset] = chunkTag;
+        offset += 1;
+        output.set(encrypted, offset);
+        offset += encrypted.length;
+    }
+}
+function streamPqEncrypt(options) {
+    const recipX25519Pub = toBytes(options.recipientX25519Public, 32, "recipientX25519Public");
+    const recipMlKemPub = toBytes(options.recipientMlKemPublic, 1184, "recipientMlKemPublic");
+    const chunkSize = options.chunkSize ?? exports.DEFAULT_CHUNK_SIZE;
+    const plaintext = options.plaintext;
+    const { ephPub, mlKemCt, key } = encapsulateKeyMaterial(recipX25519Pub, recipMlKemPub);
+    const baseNonce = (0, utils_js_1.randomBytes)(exports.NONCE_LEN);
+    const totalSize = computeStreamOutputSize(plaintext.length, chunkSize);
+    const output = new Uint8Array(totalSize);
+    output.set(ephPub, 0);
+    output.set(mlKemCt, exports.EPHEMERAL_LEN);
+    output.set(baseNonce, exports.EPHEMERAL_LEN + exports.ML_KEM_CT_LEN);
+    encryptChunks(plaintext, key, baseNonce, chunkSize, output);
+    return {
+        ciphertext: output,
+        algorithm: "x25519-ml-kem-768-xchacha20-poly1305-stream",
+    };
+}
+function readPqChunkHeader(ciphertext, offset, chunkSize) {
+    const chunkTag = ciphertext[offset];
+    if (chunkTag !== exports.CHUNK_TAG_MESSAGE && chunkTag !== exports.CHUNK_TAG_FINAL) {
+        throw new Error(`Invalid chunk tag: 0x${chunkTag.toString(16)}`);
+    }
+    const isFinal = chunkTag === exports.CHUNK_TAG_FINAL;
+    const start = offset + 1;
+    const encLen = isFinal ? ciphertext.length - start : chunkSize + exports.TAG_LEN;
+    if (start + encLen > ciphertext.length) {
+        throw new Error("Ciphertext truncated — incomplete chunk");
+    }
+    return { chunkTag, isFinal, encLen };
+}
+function decryptChunks(ciphertext, key, baseNonce, chunkSize) {
+    let offset = exports.PQ_STREAM_HEADER_LEN;
+    const chunks = [];
+    let totalPtLen = 0;
+    let sawFinal = false;
+    while (offset < ciphertext.length) {
+        const { chunkTag, isFinal, encLen } = readPqChunkHeader(ciphertext, offset, chunkSize);
+        offset += 1;
+        const chunkIdx = chunks.length;
+        const nonce = derivePqChunkNonce(baseNonce, chunkIdx, chunkTag);
+        const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce);
+        const decrypted = cipher.decrypt(ciphertext.subarray(offset, offset + encLen));
+        chunks.push(decrypted);
+        totalPtLen += decrypted.length;
+        offset += encLen;
+        if (isFinal) {
+            sawFinal = true;
+            break;
+        }
+    }
+    if (!sawFinal) {
+        throw new Error("Ciphertext truncated — final chunk missing");
+    }
+    const result = new Uint8Array(totalPtLen);
+    let pos = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, pos);
+        pos += chunk.length;
+    }
+    return result;
+}
+function streamPqDecrypt(options) {
+    const recipX25519Sec = toBytes(options.recipientX25519Secret, 32, "recipientX25519Secret");
+    const recipMlKemSec = toBytes(options.recipientMlKemSecret, 2400, "recipientMlKemSecret");
+    const chunkSize = options.chunkSize ?? exports.DEFAULT_CHUNK_SIZE;
+    const ciphertext = options.ciphertext;
+    if (ciphertext.length < exports.PQ_STREAM_HEADER_LEN + 1 + exports.TAG_LEN) {
+        throw new Error("Ciphertext too short — missing header or chunk data");
+    }
+    const ephPub = ciphertext.subarray(0, exports.EPHEMERAL_LEN);
+    const mlKemCt = ciphertext.subarray(exports.EPHEMERAL_LEN, exports.EPHEMERAL_LEN + exports.ML_KEM_CT_LEN);
+    const baseNonce = ciphertext.subarray(exports.EPHEMERAL_LEN + exports.ML_KEM_CT_LEN, exports.PQ_STREAM_HEADER_LEN);
+    const key = decapsulateKeyMaterial(recipX25519Sec, recipMlKemSec, ephPub, mlKemCt);
+    return decryptChunks(ciphertext, key, baseNonce, chunkSize);
+}
+//# sourceMappingURL=stream-pq-aead.js.map

package/dist/streaming/web-streams.d.ts

@@ -1,3 +1,4 @@
+import { type MultiPqRecipient } from "./stream-multi-pq-aead";
 export type CryptoTransformStream<I, O> = import("stream/web").TransformStream<I, O>;
 export type WebStreamHashAlgorithm = "sha256" | "sha512" | "sha3-256" | "sha3-512" | "blake3";
 export declare const WEB_STREAM_HASH_ALGORITHMS: readonly WebStreamHashAlgorithm[];
@@ -14,4 +15,28 @@ export interface DecryptStreamOptions {
 export declare function createEncryptStream(options: EncryptStreamOptions): CryptoTransformStream<Uint8Array, Uint8Array>;
 export declare function createDecryptStream(options: DecryptStreamOptions): CryptoTransformStream<Uint8Array, Uint8Array>;
 export declare function createHashStream(algorithm: WebStreamHashAlgorithm): CryptoTransformStream<Uint8Array, HashStreamResult>;
+export interface PqEncryptStreamOptions {
+    recipientX25519Public: string | Uint8Array;
+    recipientMlKemPublic: string | Uint8Array;
+    chunkSize?: number | undefined;
+}
+export interface PqDecryptStreamOptions {
+    recipientX25519Secret: string | Uint8Array;
+    recipientMlKemSecret: string | Uint8Array;
+    chunkSize?: number | undefined;
+}
+export interface MultiPqEncryptStreamOptions {
+    recipients: MultiPqRecipient[];
+    chunkSize?: number | undefined;
+}
+export interface MultiPqDecryptStreamOptions {
+    recipientId?: string | undefined;
+    recipientX25519Secret: string | Uint8Array;
+    recipientMlKemSecret: string | Uint8Array;
+    chunkSize?: number | undefined;
+}
+export declare function createPqEncryptStream(options: PqEncryptStreamOptions): CryptoTransformStream<Uint8Array, Uint8Array>;
+export declare function createPqDecryptStream(options: PqDecryptStreamOptions): CryptoTransformStream<Uint8Array, Uint8Array>;
+export declare function createMultiPqEncryptStream(options: MultiPqEncryptStreamOptions): CryptoTransformStream<Uint8Array, Uint8Array>;
+export declare function createMultiPqDecryptStream(options: MultiPqDecryptStreamOptions): CryptoTransformStream<Uint8Array, Uint8Array>;
 //# sourceMappingURL=web-streams.d.ts.map

package/dist/streaming/web-streams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-streams.d.ts","sourceRoot":"","sources":["../../src/streaming/web-streams.ts"],"names":[],"mappings":"AA6BA,MAAM,MAAM,qBAAqB,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,YAAY,EAAE,eAAe,CAC5E,CAAC,EACD,CAAC,CACF,CAAC;AAMF,MAAM,MAAM,sBAAsB,GAChC,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAY3D,eAAO,MAAM,0BAA0B,EAAE,SAAS,sBAAsB,EAM9D,CAAC;AAUX,MAAM,WAAW,gBAAgB;IAE/B,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,EAAE,sBAAsB,CAAC;CACnC;AAUD,MAAM,WAAW,oBAAoB;IAEnC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC1B;AAUD,MAAM,WAAW,oBAAoB;IAEnC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC1B;AAkDD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,GAC5B,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CA8B/C;AAoBD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,GAC5B,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CA8B/C;AAuBD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,sBAAsB,GAChC,qBAAqB,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAgBrD"}
+{"version":3,"file":"web-streams.d.ts","sourceRoot":"","sources":["../../src/streaming/web-streams.ts"],"names":[],"mappings":"AAuBA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAQhC,MAAM,MAAM,qBAAqB,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,YAAY,EAAE,eAAe,CAC5E,CAAC,EACD,CAAC,CACF,CAAC;AAMF,MAAM,MAAM,sBAAsB,GAChC,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAY3D,eAAO,MAAM,0BAA0B,EAAE,SAAS,sBAAsB,EAM9D,CAAC;AAUX,MAAM,WAAW,gBAAgB;IAE/B,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,EAAE,sBAAsB,CAAC;CACnC;AAUD,MAAM,WAAW,oBAAoB;IAEnC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC1B;AAUD,MAAM,WAAW,oBAAoB;IAEnC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC1B;AAkDD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,GAC5B,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CA8B/C;AAoBD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,GAC5B,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CA8B/C;AAuBD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,sBAAsB,GAChC,qBAAqB,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAgBrD;AAGD,MAAM,WAAW,sBAAsB;IAErC,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1C,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAGD,MAAM,WAAW,sBAAsB;IAErC,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1C,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAGD,MAAM,WAAW,2BAA2B;IAE1C,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAE/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAGD,MAAM,WAAW,2BAA2B;IAE1C,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjC,qBAAqB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3C,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1C,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAUD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CAyB/C;AAUD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CAyB/C;AAUD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CAwB/C;AAUD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CA0B/C"}