@sebastienrousseau/crypto-lib 0.0.2 → 0.0.8

package/dist/protocols/iso20022.d.ts

@@ -0,0 +1,51 @@
+import { type MlDsaLevel } from "../modern/pq-sign";
+export type Iso20022MessageType = "pacs.008" | "pain.001" | "camt.053" | "generic";
+export type Iso20022DigestAlgorithm = "sha256" | "sha384" | "sha512";
+export interface Iso20022DualSignatureEnvelope {
+    messageId: string;
+    messageType: Iso20022MessageType;
+    payloadDigest: string;
+    digestAlgorithm: Iso20022DigestAlgorithm;
+    timestamp: string;
+    classical: {
+        algorithm: "ed25519";
+        signature: string;
+        publicKey: string;
+    };
+    postQuantum: {
+        algorithm: "ml-dsa-44" | "ml-dsa-65" | "ml-dsa-87";
+        signature: string;
+        publicKey: string;
+    };
+}
+export interface Iso20022SignOptions {
+    messageId: string;
+    messageType?: Iso20022MessageType;
+    payload: string | Record<string, unknown>;
+    classicalKey: {
+        privateKeyHex: string;
+        publicKeyHex: string;
+    };
+    postQuantumKey: {
+        secretKeyHex: string;
+        publicKeyHex: string;
+        level?: MlDsaLevel;
+    };
+    digestAlgorithm?: Iso20022DigestAlgorithm;
+}
+export interface Iso20022VerifyResult {
+    valid: boolean;
+    digestMatches: boolean;
+    classicalValid: boolean;
+    postQuantumValid: boolean;
+    messageId: string;
+}
+export interface Iso20022TrustedKeys {
+    classicalPublicKeyHex: string;
+    postQuantumPublicKeyHex: string;
+}
+export declare function canonicalizePayload(payload: string | Record<string, unknown>): string;
+export declare function computeIso20022Digest(payload: string | Record<string, unknown>, algorithm?: Iso20022DigestAlgorithm): string;
+export declare function signIso20022Payment(options: Iso20022SignOptions): Iso20022DualSignatureEnvelope;
+export declare function verifyIso20022Payment(envelope: Iso20022DualSignatureEnvelope, payload: string | Record<string, unknown>, trustedKeys: Iso20022TrustedKeys): Iso20022VerifyResult;
+//# sourceMappingURL=iso20022.d.ts.map

package/dist/protocols/iso20022.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso20022.d.ts","sourceRoot":"","sources":["../../src/protocols/iso20022.ts"],"names":[],"mappings":"AAuBA,OAAO,EAA0B,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI5E,MAAM,MAAM,mBAAmB,GAC7B,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;AAGnD,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAGrE,MAAM,WAAW,6BAA6B;IAE5C,SAAS,EAAE,MAAM,CAAC;IAElB,WAAW,EAAE,mBAAmB,CAAC;IAEjC,aAAa,EAAE,MAAM,CAAC;IAEtB,eAAe,EAAE,uBAAuB,CAAC;IAEzC,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE;QACT,SAAS,EAAE,SAAS,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IAEF,WAAW,EAAE;QACX,SAAS,EAAE,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;QACnD,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAGD,MAAM,WAAW,mBAAmB;IAElC,SAAS,EAAE,MAAM,CAAC;IAElB,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAElC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE1C,YAAY,EAAE;QACZ,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF,cAAc,EAAE;QACd,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,UAAU,CAAC;KACpB,CAAC;IAEF,eAAe,CAAC,EAAE,uBAAuB,CAAC;CAC3C;AAGD,MAAM,WAAW,oBAAoB;IAEnC,KAAK,EAAE,OAAO,CAAC;IAEf,aAAa,EAAE,OAAO,CAAC;IAEvB,cAAc,EAAE,OAAO,CAAC;IAExB,gBAAgB,EAAE,OAAO,CAAC;IAE1B,SAAS,EAAE,MAAM,CAAC;CACnB;AASD,MAAM,WAAW,mBAAmB;IAElC,qBAAqB,EAAE,MAAM,CAAC;IAE9B,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAyDD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACxC,MAAM,CAKR;AAiBD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzC,SAAS,GAAE,uBAAkC,GAC5C,MAAM,CAGR;AAqBD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,mBAAmB,GAC3B,6BAA6B,CA+C/B;AAqDD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,6BAA6B,EACvC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzC,WAAW,EAAE,mBAAmB,GAC/B,oBAAoB,CAsCtB"}

package/dist/protocols/iso20022.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizePayload = canonicalizePayload;
+exports.computeIso20022Digest = computeIso20022Digest;
+exports.signIso20022Payment = signIso20022Payment;
+exports.verifyIso20022Payment = verifyIso20022Payment;
+const node_crypto_1 = require("node:crypto");
+const signing_1 = require("../modern/signing");
+const pq_sign_1 = require("../modern/pq-sign");
+const serialize_1 = require("../keys/serialize");
+const STATEMENT_DOMAIN = "crypto-service/iso20022-dual-signature/v2";
+const ML_DSA_LEVELS = {
+    "ml-dsa-44": 44,
+    "ml-dsa-65": 65,
+    "ml-dsa-87": 87,
+};
+function encodeStatement(fields) {
+    const parts = [
+        STATEMENT_DOMAIN,
+        fields.messageType,
+        fields.messageId,
+        fields.digestAlgorithm,
+        fields.payloadDigest,
+        fields.timestamp,
+        fields.classicalAlgorithm,
+        fields.classicalPublicKeyHex.toLowerCase(),
+        fields.postQuantumAlgorithm,
+        fields.postQuantumPublicKeyHex.toLowerCase(),
+    ];
+    const chunks = [];
+    for (const part of parts) {
+        const bytes = Buffer.from(part, "utf8");
+        const len = Buffer.alloc(4);
+        len.writeUInt32BE(bytes.length, 0);
+        chunks.push(len, bytes);
+    }
+    return Buffer.concat(chunks);
+}
+function canonicalizePayload(payload) {
+    if (typeof payload === "string") {
+        return payload.replace(/\r\n/g, "\n").trim();
+    }
+    return JSON.stringify(sortObjectKeys(payload));
+}
+function sortObjectKeys(obj) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortObjectKeys);
+    }
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+        sorted[key] = sortObjectKeys(obj[key]);
+    }
+    return sorted;
+}
+function computeIso20022Digest(payload, algorithm = "sha256") {
+    const canonical = canonicalizePayload(payload);
+    return (0, node_crypto_1.createHash)(algorithm).update(canonical, "utf8").digest("hex");
+}
+function signIso20022Payment(options) {
+    const digestAlgorithm = options.digestAlgorithm ?? "sha256";
+    const messageType = options.messageType ?? "generic";
+    const level = options.postQuantumKey.level ?? 65;
+    const payloadDigest = computeIso20022Digest(options.payload, digestAlgorithm);
+    const timestamp = new Date().toISOString();
+    const postQuantumAlgorithm = `ml-dsa-${level}`;
+    const statementBytes = encodeStatement({
+        messageType,
+        messageId: options.messageId,
+        digestAlgorithm,
+        payloadDigest,
+        timestamp,
+        classicalAlgorithm: "ed25519",
+        classicalPublicKeyHex: options.classicalKey.publicKeyHex,
+        postQuantumAlgorithm,
+        postQuantumPublicKeyHex: options.postQuantumKey.publicKeyHex,
+    });
+    const classicalSig = (0, signing_1.ed25519Sign)(options.classicalKey.privateKeyHex, (0, serialize_1.bytesToHex)(statementBytes));
+    const pqSig = (0, pq_sign_1.mlDsaSign)(level, options.postQuantumKey.secretKeyHex, statementBytes);
+    return {
+        messageId: options.messageId,
+        messageType,
+        payloadDigest,
+        digestAlgorithm,
+        timestamp,
+        classical: {
+            algorithm: "ed25519",
+            signature: classicalSig.signature,
+            publicKey: options.classicalKey.publicKeyHex,
+        },
+        postQuantum: {
+            algorithm: pqSig.algorithm,
+            signature: pqSig.signature,
+            publicKey: options.postQuantumKey.publicKeyHex,
+        },
+    };
+}
+function verifyClassical(publicKeyHex, statement, signatureHex) {
+    try {
+        return (0, signing_1.ed25519Verify)(publicKeyHex, (0, serialize_1.bytesToHex)(statement), signatureHex)
+            .valid;
+    }
+    catch {
+        return false;
+    }
+}
+function verifyPostQuantum(algorithm, publicKeyHex, statement, signatureHex) {
+    const level = ML_DSA_LEVELS[algorithm];
+    if (level === undefined) {
+        return false;
+    }
+    try {
+        return (0, pq_sign_1.mlDsaVerify)(level, publicKeyHex, statement, signatureHex).valid;
+    }
+    catch {
+        return false;
+    }
+}
+function verifyIso20022Payment(envelope, payload, trustedKeys) {
+    const computedDigest = computeIso20022Digest(payload, envelope.digestAlgorithm);
+    const digestMatches = computedDigest === envelope.payloadDigest;
+    const statement = encodeStatement({
+        messageType: envelope.messageType,
+        messageId: envelope.messageId,
+        digestAlgorithm: envelope.digestAlgorithm,
+        payloadDigest: envelope.payloadDigest,
+        timestamp: envelope.timestamp,
+        classicalAlgorithm: envelope.classical.algorithm,
+        classicalPublicKeyHex: trustedKeys.classicalPublicKeyHex,
+        postQuantumAlgorithm: envelope.postQuantum.algorithm,
+        postQuantumPublicKeyHex: trustedKeys.postQuantumPublicKeyHex,
+    });
+    const classicalValid = verifyClassical(trustedKeys.classicalPublicKeyHex, statement, envelope.classical.signature);
+    const postQuantumValid = verifyPostQuantum(envelope.postQuantum.algorithm, trustedKeys.postQuantumPublicKeyHex, statement, envelope.postQuantum.signature);
+    return {
+        valid: digestMatches && classicalValid && postQuantumValid,
+        digestMatches,
+        classicalValid,
+        postQuantumValid,
+        messageId: envelope.messageId,
+    };
+}
+//# sourceMappingURL=iso20022.js.map

package/dist/protocols/opaque/ake.d.ts

@@ -0,0 +1,51 @@
+import type { CleartextCredentials } from "./envelope";
+import type { AuthResponse, CredentialRequest, CredentialResponse, KE1, KE2, KE3 } from "./messages";
+import type { Suite } from "./suite";
+export interface ClientAkeState {
+    clientSecret: Uint8Array;
+    ke1: KE1;
+}
+export interface ServerLoginState {
+    expectedClientMac: Uint8Array;
+    sessionKey: Uint8Array;
+}
+export interface DerivedKeys {
+    handshakeSecret: Uint8Array;
+    km2: Uint8Array;
+    km3: Uint8Array;
+    sessionKey: Uint8Array;
+}
+export declare function expandLabel(s: Suite, secret: Uint8Array, label: string, context: Uint8Array, length: number): Uint8Array;
+export interface PreambleInput {
+    context: Uint8Array;
+    clientIdentity: Uint8Array;
+    ke1: KE1;
+    serverIdentity: Uint8Array;
+    credentialResponse: CredentialResponse;
+    serverNonce: Uint8Array;
+    serverPublicKeyshare: Uint8Array;
+}
+export declare function preamble(p: PreambleInput): Uint8Array;
+export declare function deriveKeys(s: Suite, ikm: Uint8Array, transcript: Uint8Array): DerivedKeys;
+export declare function authClientStart(s: Suite, credentialRequest: CredentialRequest, clientNonce: Uint8Array, clientKeyshareSeed: Uint8Array): ClientAkeState;
+export interface AuthServerRespondInput {
+    context: Uint8Array;
+    cleartextCredentials: CleartextCredentials;
+    serverPrivateKey: Uint8Array;
+    clientPublicKey: Uint8Array;
+    ke1: KE1;
+    credentialResponse: CredentialResponse;
+    serverNonce: Uint8Array;
+    serverKeyshareSeed: Uint8Array;
+}
+export declare function authServerRespond(s: Suite, input: AuthServerRespondInput): {
+    authResponse: AuthResponse;
+    state: ServerLoginState;
+    keys: DerivedKeys;
+};
+export declare function authClientFinalize(s: Suite, context: Uint8Array, cc: CleartextCredentials, clientPrivateKey: Uint8Array, state: ClientAkeState, ke2: KE2): {
+    ke3: KE3;
+    sessionKey: Uint8Array;
+};
+export declare function authServerFinalize(state: ServerLoginState, ke3: KE3): Uint8Array;
+//# sourceMappingURL=ake.d.ts.map

package/dist/protocols/opaque/ake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ake.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/ake.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,GAAG,EACH,GAAG,EACH,GAAG,EACJ,MAAM,YAAY,CAAC;AAYpB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,MAAM,WAAW,cAAc;IAE7B,YAAY,EAAE,UAAU,CAAC;IAEzB,GAAG,EAAE,GAAG,CAAC;CACV;AAGD,MAAM,WAAW,gBAAgB;IAE/B,iBAAiB,EAAE,UAAU,CAAC;IAE9B,UAAU,EAAE,UAAU,CAAC;CACxB;AAGD,MAAM,WAAW,WAAW;IAC1B,eAAe,EAAE,UAAU,CAAC;IAC5B,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,UAAU,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;CACxB;AAGD,wBAAgB,WAAW,CACzB,CAAC,EAAE,KAAK,EACR,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACb,UAAU,CAUZ;AAGD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,UAAU,CAAC;IACpB,cAAc,EAAE,UAAU,CAAC;IAC3B,GAAG,EAAE,GAAG,CAAC;IACT,cAAc,EAAE,UAAU,CAAC;IAC3B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,UAAU,CAAC;IACxB,oBAAoB,EAAE,UAAU,CAAC;CAClC;AAGD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,aAAa,GAAG,UAAU,CAcrD;AAGD,wBAAgB,UAAU,CACxB,CAAC,EAAE,KAAK,EACR,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,UAAU,GACrB,WAAW,CAWb;AAUD,wBAAgB,eAAe,CAC7B,CAAC,EAAE,KAAK,EACR,iBAAiB,EAAE,iBAAiB,EACpC,WAAW,EAAE,UAAU,EACvB,kBAAkB,EAAE,UAAU,GAC7B,cAAc,CAUhB;AAGD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,UAAU,CAAC;IACpB,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C,gBAAgB,EAAE,UAAU,CAAC;IAC7B,eAAe,EAAE,UAAU,CAAC;IAC5B,GAAG,EAAE,GAAG,CAAC;IACT,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,UAAU,CAAC;IACxB,kBAAkB,EAAE,UAAU,CAAC;CAChC;AAGD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,sBAAsB;;;;EA8BxE;AAGD,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,KAAK,EACR,OAAO,EAAE,UAAU,EACnB,EAAE,EAAE,oBAAoB,EACxB,gBAAgB,EAAE,UAAU,EAC5B,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,GAAG,GACP;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAyBtC;AAGD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,GAAG,GACP,UAAU,CAQZ"}

package/dist/protocols/opaque/ake.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandLabel = expandLabel;
+exports.preamble = preamble;
+exports.deriveKeys = deriveKeys;
+exports.authClientStart = authClientStart;
+exports.authServerRespond = authServerRespond;
+exports.authClientFinalize = authClientFinalize;
+exports.authServerFinalize = authServerFinalize;
+const errors_1 = require("../../errors");
+const utils_1 = require("../../utils");
+const messages_1 = require("./messages");
+const suite_1 = require("./suite");
+function expandLabel(s, secret, label, context, length) {
+    const fullLabel = (0, suite_1.utf8)("OPAQUE-" + label);
+    const customLabel = (0, suite_1.concat)((0, suite_1.i2osp)(length, 2), (0, suite_1.i2osp)(fullLabel.length, 1), fullLabel, (0, suite_1.i2osp)(context.length, 1), context);
+    return (0, suite_1.kdfExpand)(s, secret, customLabel, length);
+}
+function preamble(p) {
+    return (0, suite_1.concat)((0, suite_1.utf8)("OPAQUEv1-"), (0, suite_1.i2osp)(p.context.length, 2), p.context, (0, suite_1.i2osp)(p.clientIdentity.length, 2), p.clientIdentity, (0, messages_1.serializeKE1)(p.ke1), (0, suite_1.i2osp)(p.serverIdentity.length, 2), p.serverIdentity, (0, messages_1.serializeCredentialResponse)(p.credentialResponse), p.serverNonce, p.serverPublicKeyshare);
+}
+function deriveKeys(s, ikm, transcript) {
+    const prk = (0, suite_1.kdfExtract)(s, new Uint8Array(0), ikm);
+    const th = s.hash(transcript);
+    const handshakeSecret = expandLabel(s, prk, "HandshakeSecret", th, s.Nh);
+    const none = new Uint8Array(0);
+    return {
+        handshakeSecret,
+        sessionKey: expandLabel(s, prk, "SessionKey", th, s.Nh),
+        km2: expandLabel(s, handshakeSecret, "ServerMAC", none, s.Nh),
+        km3: expandLabel(s, handshakeSecret, "ClientMAC", none, s.Nh),
+    };
+}
+function transcriptMacs(s, keys, transcript) {
+    const serverMac = (0, suite_1.mac)(s, keys.km2, s.hash(transcript));
+    const clientMac = (0, suite_1.mac)(s, keys.km3, s.hash((0, suite_1.concat)(transcript, serverMac)));
+    return { serverMac, clientMac };
+}
+function authClientStart(s, credentialRequest, clientNonce, clientKeyshareSeed) {
+    const kp = (0, suite_1.deriveDiffieHellmanKeyPair)(s, clientKeyshareSeed);
+    const ke1 = {
+        credentialRequest,
+        authRequest: {
+            clientNonce: clientNonce.slice(),
+            clientPublicKeyshare: kp.publicKey,
+        },
+    };
+    return { clientSecret: kp.privateKey, ke1 };
+}
+function authServerRespond(s, input) {
+    const kp = (0, suite_1.deriveDiffieHellmanKeyPair)(s, input.serverKeyshareSeed);
+    const cc = input.cleartextCredentials;
+    const transcript = preamble({
+        context: input.context,
+        clientIdentity: cc.clientIdentity,
+        ke1: input.ke1,
+        serverIdentity: cc.serverIdentity,
+        credentialResponse: input.credentialResponse,
+        serverNonce: input.serverNonce,
+        serverPublicKeyshare: kp.publicKey,
+    });
+    const clientKeyshare = input.ke1.authRequest.clientPublicKeyshare;
+    const ikm = (0, suite_1.concat)((0, suite_1.diffieHellman)(s, kp.privateKey, clientKeyshare), (0, suite_1.diffieHellman)(s, input.serverPrivateKey, clientKeyshare), (0, suite_1.diffieHellman)(s, kp.privateKey, input.clientPublicKey));
+    const keys = deriveKeys(s, ikm, transcript);
+    const { serverMac, clientMac } = transcriptMacs(s, keys, transcript);
+    const authResponse = {
+        serverNonce: input.serverNonce.slice(),
+        serverPublicKeyshare: kp.publicKey,
+        serverMac,
+    };
+    const state = {
+        expectedClientMac: clientMac,
+        sessionKey: keys.sessionKey,
+    };
+    return { authResponse, state, keys };
+}
+function authClientFinalize(s, context, cc, clientPrivateKey, state, ke2) {
+    const serverKeyshare = ke2.authResponse.serverPublicKeyshare;
+    const ikm = (0, suite_1.concat)((0, suite_1.diffieHellman)(s, state.clientSecret, serverKeyshare), (0, suite_1.diffieHellman)(s, state.clientSecret, cc.serverPublicKey), (0, suite_1.diffieHellman)(s, clientPrivateKey, serverKeyshare));
+    const transcript = preamble({
+        context,
+        clientIdentity: cc.clientIdentity,
+        ke1: state.ke1,
+        serverIdentity: cc.serverIdentity,
+        credentialResponse: ke2.credentialResponse,
+        serverNonce: ke2.authResponse.serverNonce,
+        serverPublicKeyshare: serverKeyshare,
+    });
+    const keys = deriveKeys(s, ikm, transcript);
+    const { serverMac, clientMac } = transcriptMacs(s, keys, transcript);
+    if (!(0, utils_1.timingSafeEqual)(ke2.authResponse.serverMac, serverMac)) {
+        throw new errors_1.CryptoError("OPAQUE server authentication failed: invalid server MAC", suite_1.OpaqueErrorCode.SERVER_AUTHENTICATION);
+    }
+    return { ke3: { clientMac }, sessionKey: keys.sessionKey };
+}
+function authServerFinalize(state, ke3) {
+    if (!(0, utils_1.timingSafeEqual)(ke3.clientMac, state.expectedClientMac)) {
+        throw new errors_1.CryptoError("OPAQUE client authentication failed: invalid client MAC", suite_1.OpaqueErrorCode.CLIENT_AUTHENTICATION);
+    }
+    return state.sessionKey.slice();
+}
+//# sourceMappingURL=ake.js.map

package/dist/protocols/opaque/client.d.ts

@@ -0,0 +1,45 @@
+import type { OpaqueConfig } from "./config";
+import type { Identities } from "./envelope";
+import type { KE1, KE2, KE3, RegistrationRecord, RegistrationRequest, RegistrationResponse } from "./messages";
+export interface ClientLoginState {
+    config: OpaqueConfig;
+    password: Uint8Array;
+    blind: Uint8Array;
+    clientSecret: Uint8Array;
+    ke1: KE1;
+}
+export interface KE1Randomness {
+    blind?: Uint8Array;
+    clientNonce?: Uint8Array;
+    clientKeyshareSeed?: Uint8Array;
+}
+export declare function createRegistrationRequestWith(password: Uint8Array | string, config: OpaqueConfig, blind?: Uint8Array): {
+    request: RegistrationRequest;
+    blind: Uint8Array;
+};
+export declare function createRegistrationRequest(password: Uint8Array | string, config?: OpaqueConfig): {
+    request: RegistrationRequest;
+    blind: Uint8Array;
+};
+export declare function finalizeRegistrationRequestWith(password: Uint8Array | string, blind: Uint8Array, response: RegistrationResponse, identities: Identities, config: OpaqueConfig, envelopeNonce?: Uint8Array): {
+    record: RegistrationRecord;
+    exportKey: Uint8Array;
+};
+export declare function finalizeRegistrationRequest(password: Uint8Array | string, blind: Uint8Array, response: RegistrationResponse, identities?: Identities, config?: OpaqueConfig): {
+    record: RegistrationRecord;
+    exportKey: Uint8Array;
+};
+export declare function generateKE1With(password: Uint8Array | string, config: OpaqueConfig, r: KE1Randomness): {
+    ke1: KE1;
+    state: ClientLoginState;
+};
+export declare function generateKE1(password: Uint8Array | string, config?: OpaqueConfig): {
+    ke1: KE1;
+    state: ClientLoginState;
+};
+export declare function generateKE3(state: ClientLoginState, ke2: KE2, identities?: Identities): {
+    ke3: KE3;
+    sessionKey: Uint8Array;
+    exportKey: Uint8Array;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/protocols/opaque/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/client.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAO7C,OAAO,KAAK,EACV,GAAG,EACH,GAAG,EACH,GAAG,EACH,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB,MAAM,WAAW,gBAAgB;IAE/B,MAAM,EAAE,YAAY,CAAC;IAErB,QAAQ,EAAE,UAAU,CAAC;IAErB,KAAK,EAAE,UAAU,CAAC;IAElB,YAAY,EAAE,UAAU,CAAC;IAEzB,GAAG,EAAE,GAAG,CAAC;CACV;AAGD,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,kBAAkB,CAAC,EAAE,UAAU,CAAC;CACjC;AAGD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,MAAM,EAAE,YAAY,EACpB,KAAK,CAAC,EAAE,UAAU,GACjB;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAIrD;AAUD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,MAAM,GAAE,YAAiB,GACxB;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAErD;AAGD,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,oBAAoB,EAC9B,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,EACpB,aAAa,GAAE,UAA4B,GAC1C;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,SAAS,EAAE,UAAU,CAAA;CAAE,CAyBvD;AAeD,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,oBAAoB,EAC9B,UAAU,GAAE,UAAe,EAC3B,MAAM,GAAE,YAAiB,GACxB;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,SAAS,EAAE,UAAU,CAAA;CAAE,CAQvD;AAGD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,aAAa,GACf;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,CAkBvC;AASD,wBAAgB,WAAW,CACzB,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,MAAM,GAAE,YAAiB,GACxB;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,CAEvC;AAgBD,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,GAAG,EACR,UAAU,GAAE,UAAe,GAC1B;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,UAAU,CAAA;CAAE,CAoB7D"}

package/dist/protocols/opaque/client.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegistrationRequestWith = createRegistrationRequestWith;
+exports.createRegistrationRequest = createRegistrationRequest;
+exports.finalizeRegistrationRequestWith = finalizeRegistrationRequestWith;
+exports.finalizeRegistrationRequest = finalizeRegistrationRequest;
+exports.generateKE1With = generateKE1With;
+exports.generateKE1 = generateKE1;
+exports.generateKE3 = generateKE3;
+const utils_js_1 = require("@noble/hashes/utils.js");
+const ake_1 = require("./ake");
+const config_1 = require("./config");
+const credentials_1 = require("./credentials");
+const envelope_1 = require("./envelope");
+const messages_1 = require("./messages");
+const suite_1 = require("./suite");
+function createRegistrationRequestWith(password, config, blind) {
+    const { s } = (0, config_1.resolveConfig)(config);
+    const r = (0, credentials_1.blindPassword)(s, (0, suite_1.toBytes)(password), blind);
+    return { request: { blindedMessage: r.blindedMessage }, blind: r.blind };
+}
+function createRegistrationRequest(password, config = {}) {
+    return createRegistrationRequestWith(password, config);
+}
+function finalizeRegistrationRequestWith(password, blind, response, identities, config, envelopeNonce = (0, utils_js_1.randomBytes)(suite_1.Nn)) {
+    const { s, ksf } = (0, config_1.resolveConfig)(config);
+    const res = (0, messages_1.deserializeRegistrationResponse)((0, messages_1.serializeRegistrationResponse)(response), s.id);
+    const { randomizedPassword } = (0, credentials_1.finalizeOprf)(s, ksf, (0, suite_1.toBytes)(password), blind, res.evaluatedMessage);
+    const stored = (0, envelope_1.store)(s, randomizedPassword, res.serverPublicKey, identities, envelopeNonce);
+    const { clientPublicKey, maskingKey, envelope } = stored;
+    return {
+        record: { clientPublicKey, maskingKey, envelope },
+        exportKey: stored.exportKey,
+    };
+}
+function finalizeRegistrationRequest(password, blind, response, identities = {}, config = {}) {
+    return finalizeRegistrationRequestWith(password, blind, response, identities, config);
+}
+function generateKE1With(password, config, r) {
+    const { s } = (0, config_1.resolveConfig)(config);
+    const pw = (0, suite_1.toBytes)(password);
+    const blinded = (0, credentials_1.blindPassword)(s, pw, r.blind);
+    const ake = (0, ake_1.authClientStart)(s, { blindedMessage: blinded.blindedMessage }, r.clientNonce ?? (0, utils_js_1.randomBytes)(suite_1.Nn), r.clientKeyshareSeed ?? (0, utils_js_1.randomBytes)(suite_1.Nseed));
+    const state = {
+        config,
+        password: pw,
+        blind: blinded.blind,
+        clientSecret: ake.clientSecret,
+        ke1: ake.ke1,
+    };
+    return { ke1: ake.ke1, state };
+}
+function generateKE1(password, config = {}) {
+    return generateKE1With(password, config, {});
+}
+function generateKE3(state, ke2, identities = {}) {
+    const { s, ksf, context } = (0, config_1.resolveConfig)(state.config);
+    const k = (0, messages_1.deserializeKE2)((0, messages_1.serializeKE2)(ke2), s.id);
+    const recovered = (0, credentials_1.recoverCredentials)(s, ksf, state.password, state.blind, k.credentialResponse, identities);
+    const { ke3, sessionKey } = (0, ake_1.authClientFinalize)(s, context, recovered.cleartextCredentials, recovered.clientPrivateKey, state, k);
+    return { ke3, sessionKey, exportKey: recovered.exportKey };
+}
+//# sourceMappingURL=client.js.map

package/dist/protocols/opaque/config.d.ts

@@ -0,0 +1,14 @@
+import type { Ksf } from "./ksf";
+import type { Suite, SuiteId } from "./suite";
+export interface OpaqueConfig {
+    suite?: SuiteId;
+    ksf?: Ksf;
+    context?: Uint8Array | string;
+}
+export interface ResolvedConfig {
+    s: Suite;
+    ksf: Ksf;
+    context: Uint8Array;
+}
+export declare function resolveConfig(config: OpaqueConfig): ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/protocols/opaque/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/config.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAEjC,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAG9C,MAAM,WAAW,YAAY;IAE3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAKhB,GAAG,CAAC,EAAE,GAAG,CAAC;IAMV,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAC/B;AAGD,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,KAAK,CAAC;IACT,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,UAAU,CAAC;CACrB;AAGD,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,CAalE"}

package/dist/protocols/opaque/config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+const errors_1 = require("../../errors");
+const ksf_1 = require("./ksf");
+const suite_1 = require("./suite");
+function resolveConfig(config) {
+    const context = (0, suite_1.toBytes)(config.context ?? new Uint8Array(0));
+    if (context.length > 0xffff) {
+        throw new errors_1.CryptoError("OPAQUE context must be at most 65535 bytes", suite_1.OpaqueErrorCode.INVALID_INPUT);
+    }
+    return {
+        s: (0, suite_1.getSuite)(config.suite ?? "P256-SHA256"),
+        ksf: config.ksf ?? ksf_1.DEFAULT_KSF,
+        context,
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/protocols/opaque/credentials.d.ts

@@ -0,0 +1,29 @@
+import type { Ksf } from "./ksf";
+import type { Identities } from "./envelope";
+import type { CredentialRequest, CredentialResponse, RegistrationRecord } from "./messages";
+import type { Suite } from "./suite";
+export declare function deriveOprfKey(s: Suite, oprfSeed: Uint8Array, credentialIdentifier: Uint8Array | string): Uint8Array;
+export declare function blindPassword(s: Suite, password: Uint8Array, blind?: Uint8Array): {
+    blind: Uint8Array;
+    blindedMessage: Uint8Array;
+};
+export declare function evaluateOprf(s: Suite, oprfSeed: Uint8Array, credentialIdentifier: Uint8Array | string, blindedMessage: Uint8Array): Uint8Array;
+export declare function finalizeOprf(s: Suite, ksf: Ksf, password: Uint8Array, blind: Uint8Array, evaluatedMessage: Uint8Array): {
+    oprfOutput: import("@noble/curves/abstract/oprf").Bytes & Uint8Array<ArrayBuffer>;
+    randomizedPassword: Uint8Array<ArrayBufferLike>;
+};
+export interface CredentialResponseInput {
+    request: CredentialRequest;
+    serverPublicKey: Uint8Array;
+    record: RegistrationRecord;
+    credentialIdentifier: Uint8Array | string;
+    oprfSeed: Uint8Array;
+    maskingNonce: Uint8Array;
+}
+export declare function createCredentialResponse(s: Suite, input: CredentialResponseInput): CredentialResponse;
+export declare function recoverCredentials(s: Suite, ksf: Ksf, password: Uint8Array, blind: Uint8Array, response: CredentialResponse, ids: Identities): {
+    clientPrivateKey: import("@noble/curves/abstract/oprf").ScalarBytes & Uint8Array<ArrayBuffer>;
+    cleartextCredentials: import("./envelope").CleartextCredentials;
+    exportKey: Uint8Array<ArrayBufferLike>;
+};
+//# sourceMappingURL=credentials.d.ts.map

package/dist/protocols/opaque/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/credentials.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAEjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAOrC,wBAAgB,aAAa,CAC3B,CAAC,EAAE,KAAK,EACR,QAAQ,EAAE,UAAU,EACpB,oBAAoB,EAAE,UAAU,GAAG,MAAM,GACxC,UAAU,CAIZ;AAOD,wBAAgB,aAAa,CAC3B,CAAC,EAAE,KAAK,EACR,QAAQ,EAAE,UAAU,EACpB,KAAK,CAAC,EAAE,UAAU,GACjB;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,cAAc,EAAE,UAAU,CAAA;CAAE,CAMnD;AAOD,wBAAgB,YAAY,CAC1B,CAAC,EAAE,KAAK,EACR,QAAQ,EAAE,UAAU,EACpB,oBAAoB,EAAE,UAAU,GAAG,MAAM,EACzC,cAAc,EAAE,UAAU,GACzB,UAAU,CAGZ;AAGD,wBAAgB,YAAY,CAC1B,CAAC,EAAE,KAAK,EACR,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,UAAU,EACjB,gBAAgB,EAAE,UAAU;;;EAO7B;AASD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,eAAe,EAAE,UAAU,CAAC;IAC5B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,oBAAoB,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1C,QAAQ,EAAE,UAAU,CAAC;IACrB,YAAY,EAAE,UAAU,CAAC;CAC1B;AAOD,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,KAAK,EACR,KAAK,EAAE,uBAAuB,GAC7B,kBAAkB,CAiBpB;AAGD,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,KAAK,EACR,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,UAAU;;;;EAkBhB"}

package/dist/protocols/opaque/credentials.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveOprfKey = deriveOprfKey;
+exports.blindPassword = blindPassword;
+exports.evaluateOprf = evaluateOprf;
+exports.finalizeOprf = finalizeOprf;
+exports.createCredentialResponse = createCredentialResponse;
+exports.recoverCredentials = recoverCredentials;
+const envelope_1 = require("./envelope");
+const messages_1 = require("./messages");
+const suite_1 = require("./suite");
+function deriveOprfKey(s, oprfSeed, credentialIdentifier) {
+    const info = (0, suite_1.concat)((0, suite_1.toBytes)(credentialIdentifier), (0, suite_1.utf8)("OprfKey"));
+    const seed = (0, suite_1.kdfExpand)(s, oprfSeed, info, s.Nok);
+    return s.oprf.deriveKeyPair(seed, (0, suite_1.utf8)("OPAQUE-DeriveKeyPair")).secretKey;
+}
+function blindPassword(s, password, blind) {
+    if (blind !== undefined) {
+        return { blind, blindedMessage: (0, suite_1.blindWith)(s, password, blind) };
+    }
+    const r = s.oprf.blind(password);
+    return { blind: r.blind, blindedMessage: r.blinded };
+}
+function evaluateOprf(s, oprfSeed, credentialIdentifier, blindedMessage) {
+    const key = deriveOprfKey(s, oprfSeed, credentialIdentifier);
+    return s.oprf.blindEvaluate(key, blindedMessage);
+}
+function finalizeOprf(s, ksf, password, blind, evaluatedMessage) {
+    const oprfOutput = s.oprf.finalize(password, blind, evaluatedMessage);
+    return {
+        oprfOutput,
+        randomizedPassword: (0, envelope_1.randomizePassword)(s, ksf, oprfOutput),
+    };
+}
+function responsePad(s, maskingKey, nonce) {
+    const info = (0, suite_1.concat)(nonce, (0, suite_1.utf8)("CredentialResponsePad"));
+    return (0, suite_1.kdfExpand)(s, maskingKey, info, (0, messages_1.maskedResponseLength)(s));
+}
+function createCredentialResponse(s, input) {
+    const evaluatedMessage = evaluateOprf(s, input.oprfSeed, input.credentialIdentifier, input.request.blindedMessage);
+    const pad = responsePad(s, input.record.maskingKey, input.maskingNonce);
+    const plain = (0, suite_1.concat)(input.serverPublicKey, (0, messages_1.serializeEnvelope)(input.record.envelope));
+    return {
+        evaluatedMessage,
+        maskingNonce: input.maskingNonce.slice(),
+        maskedResponse: (0, suite_1.xor)(pad, plain),
+    };
+}
+function recoverCredentials(s, ksf, password, blind, response, ids) {
+    const { randomizedPassword } = finalizeOprf(s, ksf, password, blind, response.evaluatedMessage);
+    const maskingKey = (0, envelope_1.maskingKeyFor)(s, randomizedPassword);
+    const pad = responsePad(s, maskingKey, response.maskingNonce);
+    const plain = (0, suite_1.xor)(pad, response.maskedResponse);
+    const serverPublicKey = plain.slice(0, s.Npk);
+    const envelope = {
+        nonce: plain.slice(s.Npk, s.Npk + suite_1.Nn),
+        authTag: plain.slice(s.Npk + suite_1.Nn),
+    };
+    return (0, envelope_1.recover)(s, randomizedPassword, serverPublicKey, envelope, ids);
+}
+//# sourceMappingURL=credentials.js.map

package/dist/protocols/opaque/envelope.d.ts

@@ -0,0 +1,36 @@
+import type { Ksf } from "./ksf";
+import type { Envelope } from "./messages";
+import type { Suite } from "./suite";
+export interface Identities {
+    clientIdentity?: Uint8Array | string;
+    serverIdentity?: Uint8Array | string;
+}
+export interface CleartextCredentials {
+    serverPublicKey: Uint8Array;
+    serverIdentity: Uint8Array;
+    clientIdentity: Uint8Array;
+}
+export declare function createCleartextCredentials(serverPublicKey: Uint8Array, clientPublicKey: Uint8Array, ids: Identities): CleartextCredentials;
+export declare function serializeCleartextCredentials(cc: CleartextCredentials): Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+export declare function randomizePassword(s: Suite, ksf: Ksf, oprfOutput: Uint8Array): Uint8Array;
+export declare function maskingKeyFor(s: Suite, randomizedPassword: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function envelopeKeys(s: Suite, randomizedPassword: Uint8Array, nonce: Uint8Array): {
+    authKey: Uint8Array<ArrayBufferLike>;
+    exportKey: Uint8Array<ArrayBufferLike>;
+    keyPair: {
+        privateKey: import("@noble/curves/abstract/oprf").ScalarBytes & Uint8Array<ArrayBuffer>;
+        publicKey: import("@noble/curves/abstract/oprf").PointBytes & Uint8Array<ArrayBuffer>;
+    };
+};
+export declare function store(s: Suite, randomizedPassword: Uint8Array, serverPublicKey: Uint8Array, ids: Identities, nonce: Uint8Array): {
+    envelope: Envelope;
+    clientPublicKey: import("@noble/curves/abstract/oprf").PointBytes & Uint8Array<ArrayBuffer>;
+    maskingKey: Uint8Array<ArrayBufferLike>;
+    exportKey: Uint8Array<ArrayBufferLike>;
+};
+export declare function recover(s: Suite, randomizedPassword: Uint8Array, serverPublicKey: Uint8Array, envelope: Envelope, ids: Identities): {
+    clientPrivateKey: import("@noble/curves/abstract/oprf").ScalarBytes & Uint8Array<ArrayBuffer>;
+    cleartextCredentials: CleartextCredentials;
+    exportKey: Uint8Array<ArrayBufferLike>;
+};
+//# sourceMappingURL=envelope.d.ts.map

package/dist/protocols/opaque/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/envelope.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAa3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,MAAM,WAAW,UAAU;IAEzB,cAAc,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAErC,cAAc,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CACtC;AAGD,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,UAAU,CAAC;IAC5B,cAAc,EAAE,UAAU,CAAC;IAC3B,cAAc,EAAE,UAAU,CAAC;CAC5B;AAmBD,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,UAAU,EAC3B,eAAe,EAAE,UAAU,EAC3B,GAAG,EAAE,UAAU,GACd,oBAAoB,CAMtB;AAGD,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,oBAAoB,yDAQrE;AAOD,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,KAAK,EACR,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,UAAU,GACrB,UAAU,CAGZ;AAGD,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,kBAAkB,EAAE,UAAU,+BAErE;AAGD,wBAAgB,YAAY,CAC1B,CAAC,EAAE,KAAK,EACR,kBAAkB,EAAE,UAAU,EAC9B,KAAK,EAAE,UAAU;;;;;;;EASlB;AAaD,wBAAgB,KAAK,CACnB,CAAC,EAAE,KAAK,EACR,kBAAkB,EAAE,UAAU,EAC9B,eAAe,EAAE,UAAU,EAC3B,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,UAAU;;;;;EAsBlB;AAOD,wBAAgB,OAAO,CACrB,CAAC,EAAE,KAAK,EACR,kBAAkB,EAAE,UAAU,EAC9B,eAAe,EAAE,UAAU,EAC3B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,UAAU;;;;EAwBhB"}