keri 0.0.0-dev.0ddd65e → 0.0.0-dev.7be936b

package/dist/parser/base64.js

@@ -1,74 +0,0 @@
-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/buffered-reader.d.ts

@@ -1,5 +0,0 @@
-export declare class BufferedReader {
-    #private;
-    constructor(stream: AsyncIterableIterator<Uint8Array>);
-    readBytes(size: number): Promise<Uint8Array | null>;
-}

package/dist/parser/buffered-reader.js

@@ -1,47 +0,0 @@
-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 _BufferedReader_stream, _BufferedReader_buffer;
-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 BufferedReader {
-    constructor(stream) {
-        _BufferedReader_stream.set(this, void 0);
-        _BufferedReader_buffer.set(this, void 0);
-        __classPrivateFieldSet(this, _BufferedReader_stream, stream, "f");
-    }
-    async readBytes(size) {
-        if (typeof size !== "number") {
-            throw new Error(`Size must be a number, got '${size}'`);
-        }
-        while (!__classPrivateFieldGet(this, _BufferedReader_buffer, "f") || __classPrivateFieldGet(this, _BufferedReader_buffer, "f").length < size) {
-            const result = await __classPrivateFieldGet(this, _BufferedReader_stream, "f").next();
-            if (result.done) {
-                return null;
-            }
-            __classPrivateFieldSet(this, _BufferedReader_buffer, concat(__classPrivateFieldGet(this, _BufferedReader_buffer, "f") ?? new Uint8Array(0), result.value), "f");
-        }
-        const chunk = __classPrivateFieldGet(this, _BufferedReader_buffer, "f").slice(0, size);
-        __classPrivateFieldSet(this, _BufferedReader_buffer, __classPrivateFieldGet(this, _BufferedReader_buffer, "f").slice(size), "f");
-        return chunk;
-    }
-}
-_BufferedReader_stream = new WeakMap(), _BufferedReader_buffer = new WeakMap();

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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,158 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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>;