ts-mls/dist/proposal.js

[](https://github.com/LukaJCB/ts-mls/actions/workflows/ci.yml) [](https://badge.fury.io/js/ts-mls) [![Coverage Status](https://co

import { decodeUint16, decodeUint32, encodeUint16, encodeUint32 } from "./codec/number.js";
import { flatMapDecoder, mapDecoder, mapDecoders, orDecoder } from "./codec/tlsDecoder.js";
import { contramapEncoder, contramapEncoders } from "./codec/tlsEncoder.js";
import { decodeVarLenData, decodeVarLenType, encodeVarLenData, encodeVarLenType } from "./codec/variableLength.js";
import { decodeCiphersuite, encodeCiphersuite } from "./crypto/ciphersuite.js";
import { decodeExtension, encodeExtension } from "./extension.js";
import { decodeKeyPackage, encodeKeyPackage } from "./keyPackage.js";
import { decodePskId, encodePskId } from "./presharedkey.js";
import { decodeDefaultProposalType, encodeDefaultProposalType } from "./defaultProposalType.js";
import { decodeProtocolVersion, encodeProtocolVersion } from "./protocolVersion.js";
import { decodeLeafNodeUpdate, encodeLeafNode } from "./leafNode.js";
export const encodeAdd = contramapEncoder(encodeKeyPackage, (a) => a.keyPackage);
export const decodeAdd = mapDecoder(decodeKeyPackage, (keyPackage) => ({ keyPackage }));
export const encodeUpdate = contramapEncoder(encodeLeafNode, (u) => u.leafNode);
export const decodeUpdate = mapDecoder(decodeLeafNodeUpdate, (leafNode) => ({ leafNode }));
export const encodeRemove = contramapEncoder(encodeUint32, (r) => r.removed);
export const decodeRemove = mapDecoder(decodeUint32, (removed) => ({ removed }));
export const encodePSK = contramapEncoder(encodePskId, (p) => p.preSharedKeyId);
export const decodePSK = mapDecoder(decodePskId, (preSharedKeyId) => ({ preSharedKeyId }));
export const encodeReinit = contramapEncoders([encodeVarLenData, encodeProtocolVersion, encodeCiphersuite, encodeVarLenType(encodeExtension)], (r) => [r.groupId, r.version, r.cipherSuite, r.extensions]);
export const decodeReinit = mapDecoders([decodeVarLenData, decodeProtocolVersion, decodeCiphersuite, decodeVarLenType(decodeExtension)], (groupId, version, cipherSuite, extensions) => ({ groupId, version, cipherSuite, extensions }));
export const encodeExternalInit = contramapEncoder(encodeVarLenData, (e) => e.kemOutput);
export const decodeExternalInit = mapDecoder(decodeVarLenData, (kemOutput) => ({ kemOutput }));
export const encodeGroupContextExtensions = contramapEncoder(encodeVarLenType(encodeExtension), (g) => g.extensions);
export const decodeGroupContextExtensions = mapDecoder(decodeVarLenType(decodeExtension), (extensions) => ({ extensions }));
export const encodeProposalAdd = contramapEncoders([encodeDefaultProposalType, encodeAdd], (p) => [p.proposalType, p.add]);
export const encodeProposalUpdate = contramapEncoders([encodeDefaultProposalType, encodeUpdate], (p) => [p.proposalType, p.update]);
export const encodeProposalRemove = contramapEncoders([encodeDefaultProposalType, encodeRemove], (p) => [p.proposalType, p.remove]);
export const encodeProposalPSK = contramapEncoders([encodeDefaultProposalType, encodePSK], (p) => [p.proposalType, p.psk]);
export const encodeProposalReinit = contramapEncoders([encodeDefaultProposalType, encodeReinit], (p) => [p.proposalType, p.reinit]);
export const encodeProposalExternalInit = contramapEncoders([encodeDefaultProposalType, encodeExternalInit], (p) => [p.proposalType, p.externalInit]);
export const encodeProposalGroupContextExtensions = contramapEncoders([encodeDefaultProposalType, encodeGroupContextExtensions], (p) => [p.proposalType, p.groupContextExtensions]);
export const encodeProposalCustom = contramapEncoders([encodeUint16, encodeVarLenData], (p) => [p.proposalType, p.proposalData]);
export const encodeProposal = (p) => {
    switch (p.proposalType) {
        case "add":
            return encodeProposalAdd(p);
        case "update":
            return encodeProposalUpdate(p);
        case "remove":
            return encodeProposalRemove(p);
        case "psk":
            return encodeProposalPSK(p);
        case "reinit":
            return encodeProposalReinit(p);
        case "external_init":
            return encodeProposalExternalInit(p);
        case "group_context_extensions":
            return encodeProposalGroupContextExtensions(p);
        default:
            return encodeProposalCustom(p);
    }
};
export const decodeProposalAdd = mapDecoder(decodeAdd, (add) => ({ proposalType: "add", add }));
export const decodeProposalUpdate = mapDecoder(decodeUpdate, (update) => ({
    proposalType: "update",
    update,
}));
export const decodeProposalRemove = mapDecoder(decodeRemove, (remove) => ({
    proposalType: "remove",
    remove,
}));
export const decodeProposalPSK = mapDecoder(decodePSK, (psk) => ({ proposalType: "psk", psk }));
export const decodeProposalReinit = mapDecoder(decodeReinit, (reinit) => ({
    proposalType: "reinit",
    reinit,
}));
export const decodeProposalExternalInit = mapDecoder(decodeExternalInit, (externalInit) => ({ proposalType: "external_init", externalInit }));
export const decodeProposalGroupContextExtensions = mapDecoder(decodeGroupContextExtensions, (groupContextExtensions) => ({ proposalType: "group_context_extensions", groupContextExtensions }));
export function decodeProposalCustom(proposalType) {
    return mapDecoder(decodeVarLenData, (proposalData) => ({ proposalType, proposalData }));
}
export const decodeProposal = orDecoder(flatMapDecoder(decodeDefaultProposalType, (proposalType) => {
    switch (proposalType) {
        case "add":
            return decodeProposalAdd;
        case "update":
            return decodeProposalUpdate;
        case "remove":
            return decodeProposalRemove;
        case "psk":
            return decodeProposalPSK;
        case "reinit":
            return decodeProposalReinit;
        case "external_init":
            return decodeProposalExternalInit;
        case "group_context_extensions":
            return decodeProposalGroupContextExtensions;
    }
}), flatMapDecoder(decodeUint16, (n) => decodeProposalCustom(n)));
//# sourceMappingURL=proposal.js.map