keri 0.0.0-dev.0ddd65e

package/dist/parser/codes.d.ts

@@ -0,0 +1,143 @@
+export interface CodeSize {
+    hs: number;
+    ss: number;
+    xs: number | null;
+    fs: number | null;
+    ls: number | null;
+}
+export declare const MatterCode: {
+    Big: string;
+    Blake2b_256: string;
+    Blake2b_512: string;
+    Blake2s_256: string;
+    Blake3_256: string;
+    Blake3_512: string;
+    Blind: string;
+    Bytes_Big_L0: string;
+    Bytes_Big_L1: string;
+    Bytes_Big_L2: string;
+    Bytes_L0: string;
+    Bytes_L1: string;
+    Bytes_L2: string;
+    DateTime: string;
+    ECDSA_256k1: string;
+    ECDSA_256k1N: string;
+    ECDSA_256k1_Seed: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256r1: string;
+    ECDSA_256r1N: string;
+    ECDSA_256r1_Seed: string;
+    ECDSA_256r1_Sig: string;
+    Ed25519: string;
+    Ed25519N: string;
+    Ed25519_Seed: string;
+    Ed25519_Sig: string;
+    Ed448: string;
+    Ed448N: string;
+    Ed448_Seed: string;
+    Ed448_Sig: string;
+    Great: string;
+    Label1: string;
+    Label2: string;
+    Large: string;
+    Long: string;
+    No: string;
+    Null: string;
+    SHA2_256: string;
+    SHA2_512: string;
+    SHA3_256: string;
+    SHA3_512: string;
+    Salt_128: string;
+    Short: string;
+    StrB64_Big_L0: string;
+    StrB64_Big_L1: string;
+    StrB64_Big_L2: string;
+    StrB64_L0: string;
+    StrB64_L1: string;
+    StrB64_L2: string;
+    TBD0: string;
+    TBD0S: string;
+    TBD1: string;
+    TBD1S: string;
+    TBD2: string;
+    TBD2S: string;
+    Tag1: string;
+    Tag10: string;
+    Tag2: string;
+    Tag3: string;
+    Tag4: string;
+    Tag5: string;
+    Tag6: string;
+    Tag7: string;
+    Tag8: string;
+    Tag9: string;
+    Tall: string;
+    Vast: string;
+    X25519: string;
+    X25519_Cipher_Big_L0: string;
+    X25519_Cipher_Big_L1: string;
+    X25519_Cipher_Big_L2: string;
+    X25519_Cipher_L0: string;
+    X25519_Cipher_L1: string;
+    X25519_Cipher_L2: string;
+    X25519_Cipher_QB2_Big_L0: string;
+    X25519_Cipher_QB2_Big_L1: string;
+    X25519_Cipher_QB2_Big_L2: string;
+    X25519_Cipher_QB2_L0: string;
+    X25519_Cipher_QB2_L1: string;
+    X25519_Cipher_QB2_L2: string;
+    X25519_Cipher_QB64_Big_L0: string;
+    X25519_Cipher_QB64_Big_L1: string;
+    X25519_Cipher_QB64_Big_L2: string;
+    X25519_Cipher_QB64_L0: string;
+    X25519_Cipher_QB64_L1: string;
+    X25519_Cipher_QB64_L2: string;
+    X25519_Cipher_Salt: string;
+    X25519_Cipher_Seed: string;
+    X25519_Private: string;
+    X448: string;
+    Yes: string;
+};
+export declare const MatterCodeTable: Record<string, CodeSize>;
+export declare const IndexerCode: {
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    ECDSA_256r1_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    Ed25519_Big_Sig: string;
+    Ed25519_Crt_Sig: string;
+    Ed25519_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+    Ed448_Big_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed448_Sig: string;
+    TBD0: string;
+    TBD1: string;
+    TBD4: string;
+};
+export declare const IndexerCodeTable: Record<string, CodeSize>;
+export declare const CounterCode: {
+    AttachmentGroup: string;
+    BigAttachmentGroup: string;
+    BigPathedMaterialGroup: string;
+    ControllerIdxSigs: string;
+    ESSRPayloadGroup: string;
+    FirstSeenReplayCouples: string;
+    KERIACDCGenusVersion: string;
+    NonTransReceiptCouples: string;
+    PathedMaterialGroup: string;
+    RootSadPathSigGroups: string;
+    SadPathSigGroups: string;
+    SealSourceCouples: string;
+    SealSourceTriples: string;
+    TransIdxSigGroups: string;
+    TransLastIdxSigGroups: string;
+    TransReceiptQuadruples: string;
+    WitnessIdxSigs: string;
+};
+export declare const CounterCodeTable: Record<string, CodeSize>;

package/dist/parser/codes.js

@@ -0,0 +1,266 @@
+export const MatterCode = {
+    Big: "N",
+    Blake2b_256: "F",
+    Blake2b_512: "0E",
+    Blake2s_256: "G",
+    Blake3_256: "E",
+    Blake3_512: "0D",
+    Blind: "Z",
+    Bytes_Big_L0: "7AAB",
+    Bytes_Big_L1: "8AAB",
+    Bytes_Big_L2: "9AAB",
+    Bytes_L0: "4B",
+    Bytes_L1: "5B",
+    Bytes_L2: "6B",
+    DateTime: "1AAG",
+    ECDSA_256k1: "1AAB",
+    ECDSA_256k1N: "1AAA",
+    ECDSA_256k1_Seed: "J",
+    ECDSA_256k1_Sig: "0C",
+    ECDSA_256r1: "1AAJ",
+    ECDSA_256r1N: "1AAI",
+    ECDSA_256r1_Seed: "Q",
+    ECDSA_256r1_Sig: "0I",
+    Ed25519: "D",
+    Ed25519N: "B",
+    Ed25519_Seed: "A",
+    Ed25519_Sig: "0B",
+    Ed448: "1AAD",
+    Ed448N: "1AAC",
+    Ed448_Seed: "K",
+    Ed448_Sig: "1AAE",
+    Great: "T",
+    Label1: "V",
+    Label2: "W",
+    Large: "S",
+    Long: "0H",
+    No: "1AAL",
+    Null: "1AAK",
+    SHA2_256: "I",
+    SHA2_512: "0G",
+    SHA3_256: "H",
+    SHA3_512: "0F",
+    Salt_128: "0A",
+    Short: "M",
+    StrB64_Big_L0: "7AAA",
+    StrB64_Big_L1: "8AAA",
+    StrB64_Big_L2: "9AAA",
+    StrB64_L0: "4A",
+    StrB64_L1: "5A",
+    StrB64_L2: "6A",
+    TBD0: "1___",
+    TBD0S: "1__-",
+    TBD1: "2___",
+    TBD1S: "2__-",
+    TBD2: "3___",
+    TBD2S: "3__-",
+    Tag1: "0J",
+    Tag10: "0O",
+    Tag2: "0K",
+    Tag3: "X",
+    Tag4: "1AAF",
+    Tag5: "0L",
+    Tag6: "0M",
+    Tag7: "Y",
+    Tag8: "1AAN",
+    Tag9: "0N",
+    Tall: "R",
+    Vast: "U",
+    X25519: "C",
+    X25519_Cipher_Big_L0: "7AAC",
+    X25519_Cipher_Big_L1: "8AAC",
+    X25519_Cipher_Big_L2: "9AAC",
+    X25519_Cipher_L0: "4C",
+    X25519_Cipher_L1: "5C",
+    X25519_Cipher_L2: "6C",
+    X25519_Cipher_QB2_Big_L0: "7AAE",
+    X25519_Cipher_QB2_Big_L1: "8AAE",
+    X25519_Cipher_QB2_Big_L2: "9AAE",
+    X25519_Cipher_QB2_L0: "4E",
+    X25519_Cipher_QB2_L1: "5E",
+    X25519_Cipher_QB2_L2: "6E",
+    X25519_Cipher_QB64_Big_L0: "7AAD",
+    X25519_Cipher_QB64_Big_L1: "8AAD",
+    X25519_Cipher_QB64_Big_L2: "9AAD",
+    X25519_Cipher_QB64_L0: "4D",
+    X25519_Cipher_QB64_L1: "5D",
+    X25519_Cipher_QB64_L2: "6D",
+    X25519_Cipher_Salt: "1AAH",
+    X25519_Cipher_Seed: "P",
+    X25519_Private: "O",
+    X448: "L",
+    Yes: "1AAM",
+};
+export const MatterCodeTable = {
+    ["N"]: { hs: 1, ss: 0, xs: 0, fs: 12, ls: 0 },
+    ["F"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0E"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["G"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["E"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0D"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["Z"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["7AAB"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 0 },
+    ["8AAB"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 1 },
+    ["9AAB"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 2 },
+    ["4B"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 0 },
+    ["5B"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 1 },
+    ["6B"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 2 },
+    ["1AAG"]: { hs: 4, ss: 0, xs: 0, fs: 36, ls: 0 },
+    ["1AAB"]: { hs: 4, ss: 0, xs: 0, fs: 48, ls: 0 },
+    ["1AAA"]: { hs: 4, ss: 0, xs: 0, fs: 48, ls: 0 },
+    ["J"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0C"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["1AAJ"]: { hs: 4, ss: 0, xs: 0, fs: 48, ls: 0 },
+    ["1AAI"]: { hs: 4, ss: 0, xs: 0, fs: 48, ls: 0 },
+    ["Q"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0I"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["D"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["B"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["A"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0B"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["1AAD"]: { hs: 4, ss: 0, xs: 0, fs: 80, ls: 0 },
+    ["1AAC"]: { hs: 4, ss: 0, xs: 0, fs: 80, ls: 0 },
+    ["K"]: { hs: 1, ss: 0, xs: 0, fs: 76, ls: 0 },
+    ["1AAE"]: { hs: 4, ss: 0, xs: 0, fs: 56, ls: 0 },
+    ["T"]: { hs: 1, ss: 0, xs: 0, fs: 20, ls: 0 },
+    ["V"]: { hs: 1, ss: 0, xs: 0, fs: 4, ls: 1 },
+    ["W"]: { hs: 1, ss: 0, xs: 0, fs: 4, ls: 0 },
+    ["S"]: { hs: 1, ss: 0, xs: 0, fs: 16, ls: 0 },
+    ["0H"]: { hs: 2, ss: 0, xs: 0, fs: 8, ls: 0 },
+    ["1AAL"]: { hs: 4, ss: 0, xs: 0, fs: 4, ls: 0 },
+    ["1AAK"]: { hs: 4, ss: 0, xs: 0, fs: 4, ls: 0 },
+    ["I"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0G"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["H"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["0F"]: { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 },
+    ["0A"]: { hs: 2, ss: 0, xs: 0, fs: 24, ls: 0 },
+    ["M"]: { hs: 1, ss: 0, xs: 0, fs: 4, ls: 0 },
+    ["7AAA"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 0 },
+    ["8AAA"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 1 },
+    ["9AAA"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 2 },
+    ["4A"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 0 },
+    ["5A"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 1 },
+    ["6A"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 2 },
+    ["1___"]: { hs: 4, ss: 0, xs: 0, fs: 8, ls: 0 },
+    ["1__-"]: { hs: 4, ss: 2, xs: 0, fs: 12, ls: 0 },
+    ["2___"]: { hs: 4, ss: 0, xs: 0, fs: 8, ls: 1 },
+    ["2__-"]: { hs: 4, ss: 2, xs: 1, fs: 12, ls: 1 },
+    ["3___"]: { hs: 4, ss: 0, xs: 0, fs: 8, ls: 2 },
+    ["3__-"]: { hs: 4, ss: 2, xs: 0, fs: 12, ls: 2 },
+    ["0J"]: { hs: 2, ss: 2, xs: 1, fs: 4, ls: 0 },
+    ["0O"]: { hs: 2, ss: 10, xs: 0, fs: 12, ls: 0 },
+    ["0K"]: { hs: 2, ss: 2, xs: 0, fs: 4, ls: 0 },
+    ["X"]: { hs: 1, ss: 3, xs: 0, fs: 4, ls: 0 },
+    ["1AAF"]: { hs: 4, ss: 4, xs: 0, fs: 8, ls: 0 },
+    ["0L"]: { hs: 2, ss: 6, xs: 1, fs: 8, ls: 0 },
+    ["0M"]: { hs: 2, ss: 6, xs: 0, fs: 8, ls: 0 },
+    ["Y"]: { hs: 1, ss: 7, xs: 0, fs: 8, ls: 0 },
+    ["1AAN"]: { hs: 4, ss: 8, xs: 0, fs: 12, ls: 0 },
+    ["0N"]: { hs: 2, ss: 10, xs: 1, fs: 12, ls: 0 },
+    ["R"]: { hs: 1, ss: 0, xs: 0, fs: 8, ls: 0 },
+    ["U"]: { hs: 1, ss: 0, xs: 0, fs: 24, ls: 0 },
+    ["C"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["7AAC"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 0 },
+    ["8AAC"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 1 },
+    ["9AAC"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 2 },
+    ["4C"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 0 },
+    ["5C"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 1 },
+    ["6C"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 2 },
+    ["7AAE"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 0 },
+    ["8AAE"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 1 },
+    ["9AAE"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 2 },
+    ["4E"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 0 },
+    ["5E"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 1 },
+    ["6E"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 2 },
+    ["7AAD"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 0 },
+    ["8AAD"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 1 },
+    ["9AAD"]: { hs: 4, ss: 4, xs: 0, fs: null, ls: 2 },
+    ["4D"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 0 },
+    ["5D"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 1 },
+    ["6D"]: { hs: 2, ss: 2, xs: 0, fs: null, ls: 2 },
+    ["1AAH"]: { hs: 4, ss: 0, xs: 0, fs: 100, ls: 0 },
+    ["P"]: { hs: 1, ss: 0, xs: 0, fs: 124, ls: 0 },
+    ["O"]: { hs: 1, ss: 0, xs: 0, fs: 44, ls: 0 },
+    ["L"]: { hs: 1, ss: 0, xs: 0, fs: 76, ls: 0 },
+    ["1AAM"]: { hs: 4, ss: 0, xs: 0, fs: 4, ls: 0 },
+};
+export const IndexerCode = {
+    ECDSA_256k1_Big_Crt_Sig: "2D",
+    ECDSA_256k1_Big_Sig: "2C",
+    ECDSA_256k1_Crt_Sig: "D",
+    ECDSA_256k1_Sig: "C",
+    ECDSA_256r1_Big_Crt_Sig: "2F",
+    ECDSA_256r1_Big_Sig: "2E",
+    ECDSA_256r1_Crt_Sig: "F",
+    ECDSA_256r1_Sig: "E",
+    Ed25519_Big_Crt_Sig: "2B",
+    Ed25519_Big_Sig: "2A",
+    Ed25519_Crt_Sig: "B",
+    Ed25519_Sig: "A",
+    Ed448_Big_Crt_Sig: "3B",
+    Ed448_Big_Sig: "3A",
+    Ed448_Crt_Sig: "0B",
+    Ed448_Sig: "0A",
+    TBD0: "0z",
+    TBD1: "1z",
+    TBD4: "4z",
+};
+export const IndexerCodeTable = {
+    ["2D"]: { hs: 2, ss: 4, xs: null, fs: 92, ls: 0 },
+    ["2C"]: { hs: 2, ss: 4, xs: null, fs: 92, ls: 0 },
+    ["D"]: { hs: 1, ss: 1, xs: null, fs: 88, ls: 0 },
+    ["C"]: { hs: 1, ss: 1, xs: null, fs: 88, ls: 0 },
+    ["2F"]: { hs: 2, ss: 4, xs: null, fs: 92, ls: 0 },
+    ["2E"]: { hs: 2, ss: 4, xs: null, fs: 92, ls: 0 },
+    ["F"]: { hs: 1, ss: 1, xs: null, fs: 88, ls: 0 },
+    ["E"]: { hs: 1, ss: 1, xs: null, fs: 88, ls: 0 },
+    ["2B"]: { hs: 2, ss: 4, xs: null, fs: 92, ls: 0 },
+    ["2A"]: { hs: 2, ss: 4, xs: null, fs: 92, ls: 0 },
+    ["B"]: { hs: 1, ss: 1, xs: null, fs: 88, ls: 0 },
+    ["A"]: { hs: 1, ss: 1, xs: null, fs: 88, ls: 0 },
+    ["3B"]: { hs: 2, ss: 6, xs: null, fs: 160, ls: 0 },
+    ["3A"]: { hs: 2, ss: 6, xs: null, fs: 160, ls: 0 },
+    ["0B"]: { hs: 2, ss: 2, xs: null, fs: 156, ls: 0 },
+    ["0A"]: { hs: 2, ss: 2, xs: null, fs: 156, ls: 0 },
+    ["0z"]: { hs: 2, ss: 2, xs: null, fs: null, ls: 0 },
+    ["1z"]: { hs: 2, ss: 2, xs: null, fs: 76, ls: 1 },
+    ["4z"]: { hs: 2, ss: 6, xs: null, fs: 80, ls: 1 },
+};
+export const CounterCode = {
+    AttachmentGroup: "-V",
+    BigAttachmentGroup: "-0V",
+    BigPathedMaterialGroup: "-0L",
+    ControllerIdxSigs: "-A",
+    ESSRPayloadGroup: "-Z",
+    FirstSeenReplayCouples: "-E",
+    KERIACDCGenusVersion: "--AAA",
+    NonTransReceiptCouples: "-C",
+    PathedMaterialGroup: "-L",
+    RootSadPathSigGroups: "-K",
+    SadPathSigGroups: "-J",
+    SealSourceCouples: "-G",
+    SealSourceTriples: "-I",
+    TransIdxSigGroups: "-F",
+    TransLastIdxSigGroups: "-H",
+    TransReceiptQuadruples: "-D",
+    WitnessIdxSigs: "-B",
+};
+export const CounterCodeTable = {
+    ["-V"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-0V"]: { hs: 3, ss: 5, xs: null, fs: 8, ls: null },
+    ["-0L"]: { hs: 3, ss: 5, xs: null, fs: 8, ls: null },
+    ["-A"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-Z"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-E"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["--AAA"]: { hs: 5, ss: 3, xs: null, fs: 8, ls: null },
+    ["-C"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-L"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-K"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-J"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-G"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-I"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-F"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-H"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-D"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+    ["-B"]: { hs: 2, ss: 2, xs: null, fs: 4, ls: null },
+};

package/dist/parser/parser.d.ts

@@ -0,0 +1,16 @@
+import type { KeyEvent } from "../events/main.ts";
+export declare class Parser {
+    #private;
+    constructor(stream: AsyncIterableIterator<Uint8Array>);
+    readOne(): Promise<string | null>;
+}
+export declare function decode(input: AsyncIterable<Uint8Array>): AsyncIterableIterator<string>;
+export interface Message {
+    payload: KeyEvent;
+    attachments: string[];
+}
+export declare function parse(input: AsyncIterable<Uint8Array>): AsyncIterableIterator<Message>;
+export interface Message {
+    payload: KeyEvent;
+    attachments: string[];
+}

package/dist/parser/parser.js

@@ -0,0 +1,161 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Parser_instances, _Parser_decoder, _Parser_countContext, _Parser_stream, _Parser_buffer, _Parser_readBytes, _Parser_readCharacters;
+import { parseVersion } from "./version.js";
+import { decodeBase64Int } from "./base64.js";
+import { CounterCode, CounterCodeTable, IndexerCodeTable, MatterCodeTable } from "./codes.js";
+function concat(a, b) {
+    if (a.length === 0) {
+        return b;
+    }
+    if (b.length === 0) {
+        return a;
+    }
+    const merged = new Uint8Array(a.length + b.length);
+    merged.set(a);
+    merged.set(b, a.length);
+    return merged;
+}
+export class Parser {
+    constructor(stream) {
+        _Parser_instances.add(this);
+        _Parser_decoder.set(this, new TextDecoder());
+        _Parser_countContext.set(this, void 0);
+        _Parser_stream.set(this, void 0);
+        _Parser_buffer.set(this, void 0);
+        __classPrivateFieldSet(this, _Parser_stream, stream, "f");
+    }
+    async readOne() {
+        let code = "";
+        while (code.length < 4) {
+            const next = await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readBytes).call(this, 1);
+            if (next === null) {
+                return null;
+            }
+            code += __classPrivateFieldGet(this, _Parser_decoder, "f").decode(next);
+            if (code === "{") {
+                const prefix = code + (await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readCharacters).call(this, 22));
+                const version = parseVersion(prefix);
+                return prefix + (await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readCharacters).call(this, version.size - prefix.length));
+            }
+            if (code.startsWith("-") && code in CounterCodeTable) {
+                const size = CounterCodeTable[code];
+                if (size && size.fs !== null) {
+                    const qb64 = await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readCharacters).call(this, size.fs - size.hs);
+                    const count = decodeBase64Int(qb64);
+                    if (code === CounterCode.AttachmentGroup || code === CounterCode.BigAttachmentGroup) {
+                        // Attachment group, currently no need to keep track of the count
+                    }
+                    else {
+                        // Stores the counter and expected count so we know what to expect next
+                        __classPrivateFieldSet(this, _Parser_countContext, {
+                            code,
+                            count,
+                        }, "f");
+                    }
+                    return code + qb64;
+                }
+                else if (!size || size.fs === null) {
+                    throw new Error(`Variable length currently not supported code=${code}`);
+                }
+            }
+            else if (__classPrivateFieldGet(this, _Parser_countContext, "f") &&
+                __classPrivateFieldGet(this, _Parser_countContext, "f").count > 0 &&
+                [
+                    CounterCode.ControllerIdxSigs,
+                    CounterCode.WitnessIdxSigs,
+                    CounterCode.TransIdxSigGroups,
+                    CounterCode.TransLastIdxSigGroups,
+                ].includes(__classPrivateFieldGet(this, _Parser_countContext, "f").code)) {
+                if (code in IndexerCodeTable) {
+                    const size = IndexerCodeTable[code];
+                    if (size && size.fs) {
+                        __classPrivateFieldGet(this, _Parser_countContext, "f").count--;
+                        const qb64 = await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readCharacters).call(this, size.fs - size.hs);
+                        return code + qb64;
+                    }
+                    else if (size) {
+                        throw new Error(`Variable length currently not supported code=${code}`);
+                    }
+                }
+            }
+            else if (code in MatterCodeTable) {
+                const size = MatterCodeTable[code];
+                if (size && size.fs) {
+                    const qb64 = await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readCharacters).call(this, size.fs - size.hs);
+                    return code + qb64;
+                }
+                else if (size) {
+                    throw new Error(`Variable length currently not supported code=${code}`);
+                }
+            }
+        }
+        throw new Error(`Unknown code in ${code}`);
+    }
+}
+_Parser_decoder = new WeakMap(), _Parser_countContext = new WeakMap(), _Parser_stream = new WeakMap(), _Parser_buffer = new WeakMap(), _Parser_instances = new WeakSet(), _Parser_readBytes = async function _Parser_readBytes(size) {
+    if (typeof size !== "number") {
+        throw new Error(`Size must be a number, got '${size}'`);
+    }
+    while (!__classPrivateFieldGet(this, _Parser_buffer, "f") || __classPrivateFieldGet(this, _Parser_buffer, "f").length < size) {
+        const result = await __classPrivateFieldGet(this, _Parser_stream, "f").next();
+        if (result.done) {
+            return null;
+        }
+        __classPrivateFieldSet(this, _Parser_buffer, concat(__classPrivateFieldGet(this, _Parser_buffer, "f") ?? new Uint8Array(0), result.value), "f");
+    }
+    const chunk = __classPrivateFieldGet(this, _Parser_buffer, "f").slice(0, size);
+    __classPrivateFieldSet(this, _Parser_buffer, __classPrivateFieldGet(this, _Parser_buffer, "f").slice(size), "f");
+    return chunk;
+}, _Parser_readCharacters = async function _Parser_readCharacters(count) {
+    const chunk = await __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_readBytes).call(this, count);
+    return __classPrivateFieldGet(this, _Parser_decoder, "f").decode(chunk);
+};
+async function* iter(iterator) {
+    for await (const item of iterator) {
+        yield item;
+    }
+}
+export async function* decode(input) {
+    const decoder = new Parser(iter(input));
+    while (true) {
+        const frame = await decoder.readOne();
+        if (frame === null) {
+            return;
+        }
+        yield frame;
+    }
+}
+export async function* parse(input) {
+    let payload = null;
+    let attachments = [];
+    function reset() {
+        const result = { payload, attachments };
+        payload = null;
+        attachments = [];
+        return result;
+    }
+    for await (const frame of decode(input)) {
+        if (frame.startsWith("{")) {
+            if (payload) {
+                yield reset();
+            }
+            payload = JSON.parse(frame);
+        }
+        else {
+            attachments.push(frame);
+        }
+    }
+    if (payload) {
+        yield reset();
+    }
+}

package/dist/parser/version.d.ts

@@ -0,0 +1,11 @@
+import { type DataObject } from "../data-type.ts";
+export interface Version {
+    protocol: string;
+    format: string;
+    version: string;
+    size: number;
+}
+export declare function parseVersion(data: Uint8Array | string): Version;
+export declare function versify<T extends DataObject>(data: T): T & {
+    v: string;
+};

package/dist/parser/version.js

@@ -0,0 +1,56 @@
+import { decodeBase64Int } from "./base64.js";
+// PPPPvvKKKKllllll_
+const LEGACY_MATCH = /^[A-Z]{4}[0-9]{2}[A-Z]{4}.*$/;
+// PPPPVVVKKKKBBBB.
+const MATCH = /^[A-Z]{4}[0-9]{3}[A-Z]{4}.*$/;
+export function parseVersion(data) {
+    if (typeof data !== "string") {
+        return parseVersion(new TextDecoder().decode(data));
+    }
+    const value = data.slice(6);
+    if (LEGACY_MATCH.test(value)) {
+        const protocol = value.slice(0, 4);
+        const version = value.slice(4, 6);
+        const format = value.slice(6, 10);
+        const size = parseInt(value.slice(10, 16), 16);
+        return {
+            protocol,
+            version,
+            format,
+            size,
+        };
+    }
+    else if (MATCH.test(value)) {
+        const protocol = value.slice(0, 4);
+        const version = value.slice(4, 7);
+        const format = value.slice(7, 11);
+        const size = decodeBase64Int(value.slice(12, 15));
+        return {
+            protocol,
+            version,
+            format,
+            size,
+        };
+    }
+    throw new Error(`Unexpected version string ${value}`);
+}
+function formatSize(size) {
+    return size.toString(16).padStart(6, "0");
+}
+function formatVersion(label, size) {
+    return `${label}JSON${formatSize(size)}_`;
+}
+// const DUMMY_VERSION = "PPPPVVVKKKKBBBB.";
+// const DUMMY_LEGACY_VERSION = "PPPPvvKKKKllllll_";
+export function versify(data) {
+    const encoder = new TextEncoder();
+    const str = encoder.encode(JSON.stringify({
+        v: formatVersion("KERI10", 0),
+        ...data,
+    }));
+    const version = formatVersion("KERI10", str.byteLength);
+    return {
+        v: version,
+        ...data,
+    };
+}