keri 0.0.0-dev.8b0703e

package/dist/parser/base64.js

@@ -0,0 +1,74 @@
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const B64_URL_MAP = ALPHABET.split("");
+const B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+export function encodeBase64(uint8) {
+    // CREDIT: https://github.com/denoland/std/blob/main/encoding/base64.ts
+    // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+    let result = "";
+    let i;
+    const l = uint8.length;
+    for (i = 2; i < l; i += 3) {
+        result += B64_ALPHABET[uint8[i - 2] >> 2];
+        result += B64_ALPHABET[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += B64_ALPHABET[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
+        result += B64_ALPHABET[uint8[i] & 0x3f];
+    }
+    if (i === l + 1) {
+        // 1 octet yet to write
+        result += B64_ALPHABET[uint8[i - 2] >> 2];
+        result += B64_ALPHABET[(uint8[i - 2] & 0x03) << 4];
+        result += "==";
+    }
+    if (i === l) {
+        // 2 octets yet to write
+        result += B64_ALPHABET[uint8[i - 2] >> 2];
+        result += B64_ALPHABET[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += B64_ALPHABET[(uint8[i - 1] & 0x0f) << 2];
+        result += "=";
+    }
+    return result;
+}
+export function decodeBase64(b64) {
+    // CREDIT: https://github.com/denoland/std/blob/main/encoding/base64.ts
+    const binString = atob(b64);
+    const size = binString.length;
+    const bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        bytes[i] = binString.charCodeAt(i);
+    }
+    return bytes;
+}
+export function decodeBase64Int(value) {
+    return value
+        .split("")
+        .reverse()
+        .reduce((result, character, index) => {
+        const value = ALPHABET.indexOf(character);
+        const factor = 64 ** index;
+        return result + value * factor;
+    }, 0);
+}
+export function encodeBase64Int(value, length = 1) {
+    let current = value;
+    let result = "";
+    while (length != 0) {
+        result = B64_URL_MAP[current % 64] + result;
+        current = Math.floor(current / 64);
+        if (current == 0) {
+            break;
+        }
+    }
+    return result.padStart(length, "A");
+}
+export function encodeBase64Url(buffer) {
+    return encodeBase64(buffer).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+/, "");
+}
+export function decodeBase64Url(input) {
+    if (!(typeof input === "string")) {
+        throw new TypeError("`input` must be a string.");
+    }
+    const n = input.length % 4;
+    const padded = input + "=".repeat(n > 0 ? 4 - n : n);
+    const base64String = padded.replace(/-/g, "+").replace(/_/g, "/");
+    return decodeBase64(base64String);
+}

package/dist/parser/cesr-encoding.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Represents the Raw domain
+ */
+export interface Raw {
+    code: string;
+    buffer: Uint8Array;
+}
+export declare function decode(text: string): Raw;
+export declare function encodeDate(date: Date): string;
+export declare function encode(code: string, raw: Uint8Array): string;
+/**
+ * Converts a cryptographic primitive to indexed material
+ */
+export declare function index(text: string, index: number): string;
+export interface Indexed {
+    value: string;
+    index: number;
+}
+/**
+ * Converts indexed material to primitive and index
+ */
+export declare function deindex(text: string): Indexed;
+export declare function sign(message: Uint8Array, privateKey: Uint8Array, curve: "ed25519"): string;
+export declare function verify(message: Uint8Array, publicKey: string, signature: string): boolean;
+declare const cesr: {
+    encode: typeof encode;
+    decode: typeof decode;
+    sign: typeof sign;
+    verify: typeof verify;
+    index: typeof index;
+    deindex: typeof deindex;
+    encodeDate: typeof encodeDate;
+};
+export default cesr;

package/dist/parser/cesr-encoding.js

@@ -0,0 +1,158 @@
+import { ed25519 } from "@noble/curves/ed25519";
+import { decodeBase64Int, decodeBase64Url, encodeBase64Int, encodeBase64Url } from "./base64.js";
+import { IndexerCode, IndexerCodeTable, MatterCode, MatterCodeTable } from "./codes.js";
+function padNumber(num, length) {
+    return num.toString().padStart(length, "0");
+}
+function findPrimitiveCode(text) {
+    let i = 0;
+    let code = "";
+    let size = null;
+    while (!size && i <= 4) {
+        code = text.slice(0, i);
+        size = MatterCodeTable[text.slice(0, i)];
+        ++i;
+    }
+    if (!size) {
+        throw new Error(`Unable to find code table for ${text}`);
+    }
+    return [code, size];
+}
+function findIndexCode(text) {
+    let i = 0;
+    let code = "";
+    let size = null;
+    while (!size && i <= 4) {
+        code = text.slice(0, i);
+        size = IndexerCodeTable[text.slice(0, i)];
+        ++i;
+    }
+    if (!size) {
+        throw new Error(`Unable to find code table for ${text}`);
+    }
+    return [code, size];
+}
+export function decode(text) {
+    const [code, size] = findPrimitiveCode(text);
+    if (!size) {
+        throw new Error(`Unable to find code table for ${text}`);
+    }
+    const padSize = (size.hs + size.ss) % 4;
+    const padding = "A".repeat(padSize);
+    const paw = decodeBase64Url(padding + text.substring(size.hs + size.ss));
+    const buffer = paw.slice(padSize + (size.ls ?? 0));
+    return { code, buffer };
+}
+export function encodeDate(date) {
+    if (date.toString() === "Invalid Date") {
+        throw new Error("Invalid date");
+    }
+    const YYYY = date.getFullYear();
+    const MM = padNumber(date.getUTCMonth() + 1, 2);
+    const dd = padNumber(date.getUTCDate(), 2);
+    const hh = padNumber(date.getUTCHours(), 2);
+    const mm = padNumber(date.getUTCMinutes(), 2);
+    const ss = padNumber(date.getUTCSeconds(), 2);
+    const ms = padNumber(date.getMilliseconds(), 3);
+    const format = `${YYYY}-${MM}-${dd}T${hh}c${mm}c${ss}d${ms}000p00c00`;
+    return `${MatterCode.DateTime}${format}`;
+}
+export function encode(code, raw) {
+    const both = code;
+    const rs = raw.byteLength;
+    const size = MatterCodeTable[code];
+    if (!size) {
+        throw new Error(`Unable to find code table for ${code}`);
+    }
+    const { hs, ss, xs, fs } = size;
+    const ls = size.ls ?? 0;
+    const cs = hs + ss;
+    let full;
+    if (!fs) {
+        if ((ls + rs) % 3 !== 0 || cs % 4 !== 0) {
+            throw new Error(`Invalid full code=${both} with variable raw size=${rs} given cs=${cs}, hs=${hs}, ss=${ss}, fs=${fs}, and ls=${ls}.`);
+        }
+        const paddedRaw = new Uint8Array(ls + rs);
+        paddedRaw.set(raw, ls);
+        full = both + encodeBase64Url(paddedRaw);
+    }
+    else {
+        const ps = (3 - ((rs + ls) % 3)) % 3;
+        if (ps !== cs % 4) {
+            throw new Error(`Invalid full code=${both} with fixed raw size=${rs} given cs=${cs}, hs=${hs}, ss=${ss}, fs=${fs}, and ls=${ls}.`);
+        }
+        const paddedRaw = new Uint8Array(ps + ls + rs);
+        paddedRaw.set(raw, ps + ls);
+        full = both + encodeBase64Url(paddedRaw).slice(ps);
+    }
+    if (full.length % 4 !== 0 || (fs && full.length !== fs)) {
+        throw new Error(`Invalid full size given code=${both} with raw size=${rs}, cs=${cs}, hs=${hs}, ss=${ss}, xs=${xs}, fs=${fs}, and ls=${ls}.`);
+    }
+    return full;
+}
+function resolveIndexCode(primitiveCode) {
+    switch (primitiveCode) {
+        case MatterCode.Ed25519_Sig:
+            return [IndexerCode.Ed25519_Sig, IndexerCodeTable[IndexerCode.Ed25519_Sig]];
+        case MatterCode.Ed448_Sig:
+            return [IndexerCode.Ed448_Sig, IndexerCodeTable[IndexerCode.Ed448_Sig]];
+    }
+    throw new Error(`Unable to find indexed code for '${primitiveCode}'`);
+}
+function resolvePrimitiveCode(indexCode) {
+    switch (indexCode) {
+        case IndexerCode.Ed25519_Sig:
+            return [MatterCode.Ed25519_Sig, MatterCodeTable[IndexerCode.Ed25519_Sig]];
+        case IndexerCode.Ed448_Sig:
+            return [MatterCode.Ed448_Sig, MatterCodeTable[IndexerCode.Ed448_Sig]];
+    }
+    throw new Error(`Unable to find primitive code for '${indexCode}'`);
+}
+/**
+ * Converts a cryptographic primitive to indexed material
+ */
+export function index(text, index) {
+    const [code, size] = findPrimitiveCode(text);
+    const [indexCode, indexCodeSize] = resolveIndexCode(code);
+    return indexCode + encodeBase64Int(index, indexCodeSize.ss) + text.slice(size.hs + size.ss);
+}
+/**
+ * Converts indexed material to primitive and index
+ */
+export function deindex(text) {
+    const [indexCode, indexCodeSize] = findIndexCode(text);
+    const [primitiveCode] = resolvePrimitiveCode(indexCode);
+    const index = decodeBase64Int(text.slice(indexCodeSize.hs, indexCodeSize.ss));
+    const value = primitiveCode + text.slice(indexCodeSize.hs + indexCodeSize.ss);
+    return {
+        index,
+        value,
+    };
+}
+export function sign(message, privateKey, curve) {
+    switch (curve) {
+        case "ed25519":
+            return cesr.encode(MatterCode.Ed25519_Sig, ed25519.sign(message, privateKey));
+        default:
+            throw new Error(`Unsupported curve ${curve}`);
+    }
+}
+export function verify(message, publicKey, signature) {
+    const decodedPublicKey = cesr.decode(publicKey);
+    const decodedSignature = cesr.decode(signature);
+    switch (decodedSignature.code) {
+        case MatterCode.Ed25519_Sig:
+            return ed25519.verify(decodedSignature.buffer, message, decodedPublicKey.buffer);
+    }
+    throw new Error(`Unsupported signature code ${decodedSignature.code}`);
+}
+const cesr = {
+    encode,
+    decode,
+    sign,
+    verify,
+    index,
+    deindex,
+    encodeDate,
+};
+export default cesr;

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,11 @@
+import type { KeyEvent } from "../events/main.ts";
+export declare class Parser {
+    #private;
+    parse(data: Uint8Array): string[];
+}
+export declare function parse(data: Uint8Array): string[];
+export declare function parseStream(stream: ReadableStream<Uint8Array>): AsyncIterableIterator<Message>;
+export interface Message {
+    payload: KeyEvent;
+    attachments: string[];
+}