cesr-ts 0.3.0 → 0.4.0

package/esm/src/primitives/indexer.js

@@ -1,10 +1,15 @@
-import { b64ToInt, codeB2ToB64, codeB64ToB2, decodeB64, nabSextets, sceil, } from "../core/bytes.js";
-import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
-import { INDEXER_HARDS, INDEXER_SIZES } from "../tables/indexer.tables.js";
+import { b, b64ToInt, codeB2ToB64, codeB64ToB2, concatBytes, decodeB64, encodeB64, intToB64, nabSextets, sceil, } from "../core/bytes.js";
+import { DeserializeError, ShortageError, UnknownCodeError } from "../core/errors.js";
+import { INDEXER_HARDS, INDEXER_SIZES } from "../tables/indexer.tables.generated.js";
 const INDEXER_BARDS = new Map([...INDEXER_HARDS.entries()].map(([code, hs]) => [
     String.fromCharCode(codeB64ToB2(code)[0]),
     hs,
 ]));
+function isIndexerData(value) {
+    return typeof value === "object" && value !== null
+        && "code" in value && "raw" in value && "qb64" in value
+        && "fullSize" in value && "fullSizeB2" in value && "index" in value;
+}
 function parseIndexerCodeFromText(txt) {
     const hs = INDEXER_HARDS.get(txt[0]);
     if (!hs) {
@@ -16,7 +21,19 @@ function parseIndexerCodeFromText(txt) {
     }
     return { code };
 }
-export function parseIndexerFromText(input) {
+function parseIndexFields(code, qb64) {
+    const sizage = INDEXER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown indexer code ${code}`);
+    }
+    const cs = sizage.hs + sizage.ss;
+    const soft = qb64.slice(sizage.hs, cs);
+    const ms = sizage.ss - sizage.os;
+    const index = ms > 0 ? b64ToInt(soft.slice(0, ms)) : 0;
+    const ondex = sizage.os > 0 ? b64ToInt(soft.slice(ms, sizage.ss)) : undefined;
+    return { index, ondex };
+}
+function parseIndexerFromTextData(input) {
     const txt = String.fromCharCode(...input);
     if (txt.length === 0) {
         throw new DeserializeError("Empty indexer input");
@@ -29,16 +46,20 @@ export function parseIndexerFromText(input) {
     if (txt.length < fullSize) {
         throw new ShortageError(fullSize, txt.length);
     }
-    const raw = decodeB64(txt.slice(cs, fullSize)).slice(sizage.ls);
+    const qb64 = txt.slice(0, fullSize);
+    const raw = decodeB64(qb64.slice(cs)).slice(sizage.ls);
+    const { index, ondex } = parseIndexFields(code, qb64);
     return {
         code,
         raw,
-        qb64: txt.slice(0, fullSize),
+        qb64,
         fullSize,
         fullSizeB2: sceil((fullSize * 3) / 4),
+        index,
+        ondex,
     };
 }
-export function parseIndexerFromBinary(input) {
+function parseIndexerFromBinaryData(input) {
     if (input.length === 0) {
         throw new ShortageError(1, 0);
     }
@@ -71,14 +92,185 @@ export function parseIndexerFromBinary(input) {
     const qb2 = input.slice(0, bfs);
     const qb64 = codeB2ToB64(qb2, fs);
     const raw = decodeB64(qb64.slice(cs)).slice(sizage.ls);
+    const { index, ondex } = parseIndexFields(hard, qb64);
     return {
         code: hard,
         raw,
         qb64,
         fullSize: fs,
         fullSizeB2: bfs,
+        index,
+        ondex,
+    };
+}
+function encodeIndexerFromRaw(code, raw, index, ondex) {
+    const sizage = INDEXER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown indexer code ${code}`);
+    }
+    const ms = sizage.ss - sizage.os;
+    if (ms < 0) {
+        throw new DeserializeError(`Invalid indexer sizage for ${code}`);
+    }
+    if (!Number.isInteger(index) || index < 0) {
+        throw new DeserializeError(`Invalid index ${index} for ${code}`);
+    }
+    const ondexValue = sizage.os > 0 ? (ondex ?? index) : undefined;
+    if (sizage.os > 0 && (ondexValue === undefined || ondexValue < 0)) {
+        throw new DeserializeError(`Invalid ondex ${ondexValue} for ${code}`);
+    }
+    const cs = sizage.hs + sizage.ss;
+    const ps = cs % 4;
+    const paw = concatBytes(new Uint8Array(ps + sizage.ls), raw);
+    const body = encodeB64(paw).slice(ps);
+    const soft = `${intToB64(index, ms)}${sizage.os > 0 ? intToB64(ondexValue ?? 0, sizage.os) : ""}`;
+    const qb64 = `${code}${soft}${body}`;
+    const fullSize = qb64.length;
+    if (sizage.fs !== null && fullSize !== sizage.fs) {
+        throw new DeserializeError(`Encoded indexer size mismatch for ${code}: expected=${sizage.fs} got=${fullSize}`);
+    }
+    return {
+        code,
+        raw: raw.slice(),
+        qb64,
+        fullSize,
+        fullSizeB2: sceil((fullSize * 3) / 4),
+        index,
+        ondex: ondexValue,
     };
 }
+function parseIndexerInit(init) {
+    if (init.raw && init.code) {
+        return encodeIndexerFromRaw(init.code, init.raw, init.index ?? 0, init.ondex);
+    }
+    if (init.qb64b) {
+        return parseIndexerFromTextData(init.qb64b);
+    }
+    if (init.qb64) {
+        return parseIndexerFromTextData(b(init.qb64));
+    }
+    if (init.qb2) {
+        return parseIndexerFromBinaryData(init.qb2);
+    }
+    throw new DeserializeError("Indexer requires (raw + code) or qb64/qb64b/qb2 initialization");
+}
+/**
+ * Base indexed CESR primitive.
+ *
+ * KERIpy substance: `Indexer` extends matter semantics with index/ondex fields
+ * used by indexed signatures and other attachment-indexed material families.
+ */
+export class Indexer {
+    constructor(init) {
+        Object.defineProperty(this, "_code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_qb64", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_fullSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_fullSizeB2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_ondex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const data = init instanceof Indexer
+            ? init.toIndexerData()
+            : isIndexerData(init)
+                ? init
+                : parseIndexerInit(init);
+        this._code = data.code;
+        this._raw = data.raw.slice();
+        this._qb64 = data.qb64;
+        this._fullSize = data.fullSize;
+        this._fullSizeB2 = data.fullSizeB2;
+        this._index = data.index;
+        this._ondex = data.ondex;
+    }
+    toIndexerData() {
+        return {
+            code: this._code,
+            raw: this._raw.slice(),
+            qb64: this._qb64,
+            fullSize: this._fullSize,
+            fullSizeB2: this._fullSizeB2,
+            index: this._index,
+            ondex: this._ondex,
+        };
+    }
+    get code() {
+        return this._code;
+    }
+    get raw() {
+        return this._raw;
+    }
+    get qb64() {
+        return this._qb64;
+    }
+    get qb64b() {
+        return b(this._qb64);
+    }
+    get qb2() {
+        return codeB64ToB2(this._qb64);
+    }
+    get fullSize() {
+        return this._fullSize;
+    }
+    get fullSizeB2() {
+        return this._fullSizeB2;
+    }
+    get index() {
+        return this._index;
+    }
+    get ondex() {
+        return this._ondex;
+    }
+    equals(other) {
+        return this._qb64 === other.qb64;
+    }
+    toString() {
+        return this._qb64;
+    }
+}
+/** Parse indexer material from text-domain CESR bytes. */
+export function parseIndexerFromText(input) {
+    return new Indexer(parseIndexerFromTextData(input));
+}
+/** Parse indexer material from binary-domain CESR bytes. */
+export function parseIndexerFromBinary(input) {
+    return new Indexer(parseIndexerFromBinaryData(input));
+}
+/** Parse indexer using caller-provided cold-start domain hint (`txt` or `bny`). */
 export function parseIndexer(input, cold) {
     return cold === "bny"
         ? parseIndexerFromBinary(input)

package/esm/src/primitives/labeler.js

@@ -1,31 +1,81 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
+import { Bexter } from "./bexter.js";
+import { BEXTER_CODES, isAttLabel, LABELER_CODES, TAG_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+import { Tagger } from "./tagger.js";
 const TEXT_DECODER = new TextDecoder();
-const LABELER_CODES = new Set(["V", "W"]);
+/** True when code belongs to KERIpy `LabelCodex` accepted by native map labels. */
 export function isLabelerCode(code) {
     return LABELER_CODES.has(code);
 }
-/** Parse a V/W label primitive into decoded map-label metadata. */
+/**
+ * Decode a label/text token according to LabelCodex encoding rules.
+ *
+ * Tag/Bext encodings require specialized decoding logic; all other label forms
+ * project directly from raw bytes.
+ */
+function decodeLabelText(matter) {
+    if (TAG_CODES.has(matter.code)) {
+        return new Tagger(matter).tag;
+    }
+    if (BEXTER_CODES.has(matter.code)) {
+        const bext = Bexter.derawify(matter.raw, matter.code);
+        return bext.startsWith("-") && isAttLabel(bext.slice(1))
+            ? bext.slice(1)
+            : bext;
+    }
+    return TEXT_DECODER.decode(matter.raw);
+}
+/**
+ * Label/text primitive used for native map keys and textual field values.
+ *
+ * KERIpy semantics: `Labeler` accepts Tag/Bext/Bytes families (plus compact
+ * label codes) and provides both strict attribute-label projection (`label`)
+ * and generic text projection (`text`).
+ */
+export class Labeler extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!isLabelerCode(this.code)) {
+            throw new UnknownCodeError(`Expected labeler code, got ${this.code}`);
+        }
+    }
+    /** Canonical qb64 token for emit/roundtrip paths. */
+    get token() {
+        return this.qb64;
+    }
+    /** Attribute-safe label projection used for map key semantics. */
+    get label() {
+        const label = decodeLabelText(this);
+        if (!isAttLabel(label)) {
+            throw new UnknownCodeError(`Invalid label text: ${label}`);
+        }
+        return label;
+    }
+    /** Raw text projection without attribute-name validation. */
+    get text() {
+        return decodeLabelText(this);
+    }
+    /** Numeric projection helper used for compact fixed-width label values. */
+    get index() {
+        let index = 0;
+        for (const b of this.raw) {
+            index = (index << 8) | b;
+        }
+        return index;
+    }
+    /** Raw decoded bytes backing the label/text token. */
+    get bytes() {
+        return this.raw;
+    }
+}
+/**
+ * Parse and hydrate a `Labeler` from txt/qb2 bytes.
+ *
+ * Boundary contract: parsing is syntactic; semantic label validity is enforced
+ * when `label` accessor is read.
+ */
 export function parseLabeler(input, cold) {
-    // Labelers are fixed-size matter primitives used as map field keys.
-    const matter = parseMatter(input, cold);
-    if (!isLabelerCode(matter.code)) {
-        throw new UnknownCodeError(`Expected labeler code (V/W), got ${matter.code}`);
-    }
-    let index = 0;
-    for (const b of matter.raw) {
-        index = (index << 8) | b;
-    }
-    const text = TEXT_DECODER.decode(matter.raw).replace(/\u0000/g, "");
-    const label = text.length > 0 ? text : matter.qb64.slice(matter.code.length);
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-        token: matter.qb64,
-        label,
-        index,
-        bytes: matter.raw,
-    };
+    return new Labeler(parseMatter(input, cold));
 }

package/esm/src/primitives/mapper.js

@@ -1,30 +1,14 @@
-import { encodeB64 } from "../core/bytes.js";
 import { DeserializeError, SemanticInterpretationError, ShortageError, SyntaxParseError, UnknownCodeError, } from "../core/errors.js";
 import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
-import { CtrDexV2 } from "../tables/counter-codex.js";
+import { AGGOR_LIST_CODES, AGGOR_MAP_CODES } from "../tables/counter-groups.js";
 import { parseCounter } from "./counter.js";
 import { parseLabeler } from "./labeler.js";
 import { parseMatter } from "./matter.js";
-const MAP_GROUP_CODES = new Set([
-    CtrDexV2.MapBodyGroup,
-    CtrDexV2.BigMapBodyGroup,
-    CtrDexV2.GenericMapGroup,
-    CtrDexV2.BigGenericMapGroup,
-]);
-const LIST_GROUP_CODES = new Set([
-    CtrDexV2.GenericGroup,
-    CtrDexV2.BigGenericGroup,
-    CtrDexV2.GenericListGroup,
-    CtrDexV2.BigGenericListGroup,
-]);
 function tokenSize(token, domain) {
     return domain === "bny" ? token.fullSizeB2 : token.fullSize;
 }
 function isMapGroupCode(code) {
-    return MAP_GROUP_CODES.has(code);
-}
-function asQb64(raw, domain) {
-    return domain === "txt" ? String.fromCharCode(...raw) : encodeB64(raw);
+    return AGGOR_MAP_CODES.has(code);
 }
 function parseCounterProbe(input, version, domain) {
     /**
@@ -46,8 +30,8 @@ function parseCounterProbe(input, version, domain) {
             if (error instanceof ShortageError) {
                 throw error;
             }
-            if (error instanceof UnknownCodeError ||
-                error instanceof DeserializeError) {
+            if (error instanceof UnknownCodeError
+                || error instanceof DeserializeError) {
                 continue;
             }
             throw error;
@@ -64,8 +48,8 @@ function parseLabelProbe(input, domain) {
         if (error instanceof ShortageError) {
             throw error;
         }
-        if (error instanceof UnknownCodeError ||
-            error instanceof DeserializeError) {
+        if (error instanceof UnknownCodeError
+            || error instanceof DeserializeError) {
             return null;
         }
         throw error;
@@ -81,11 +65,9 @@ function parseMapperValueSyntax(input, version, domain) {
     const counter = parseCounterProbe(input, version, domain);
     if (counter) {
         const dispatch = parseAttachmentDispatch(input, version, domain);
-        const raw = input.slice(0, dispatch.consumed);
         const value = {
             kind: "value",
-            code: dispatch.group.code,
-            qb64: asQb64(raw, domain),
+            primitive: dispatch.group,
             isCounter: true,
             consumed: dispatch.consumed,
         };
@@ -97,8 +79,7 @@ function parseMapperValueSyntax(input, version, domain) {
     const matter = parseMatter(input, domain);
     return {
         kind: "value",
-        code: matter.code,
-        qb64: matter.qb64,
+        primitive: matter,
         isCounter: false,
         consumed: tokenSize(matter, domain),
     };
@@ -119,8 +100,7 @@ function parseMapPayloadSyntax(input, version, domain, start, end) {
             const consumed = tokenSize(maybeLabel, domain);
             entries.push({
                 kind: "label",
-                code: maybeLabel.code,
-                qb64: maybeLabel.token,
+                primitive: parseMatter(at, domain),
                 label: maybeLabel.label,
                 consumed,
             });
@@ -147,8 +127,7 @@ export function interpretMapperBodySyntax(syntax) {
         }
         fields.push({
             label: pendingLabel,
-            code: entry.code,
-            qb64: entry.qb64,
+            primitive: entry.primitive,
             isCounter: entry.isCounter,
             children: entry.children
                 ? interpretMapperBodySyntax(entry.children)
@@ -190,9 +169,9 @@ export function parseMapperBodySyntax(input, version, domain) {
         };
     }
     catch (error) {
-        if (error instanceof ShortageError ||
-            error instanceof UnknownCodeError ||
-            error instanceof DeserializeError) {
+        if (error instanceof ShortageError
+            || error instanceof UnknownCodeError
+            || error instanceof DeserializeError) {
             throw new SyntaxParseError(`Map-body syntax parse failed: ${error.message}`, error);
         }
         throw error;
@@ -235,5 +214,5 @@ export function parseMapperBody(input, version, domain) {
 }
 /** True for counter codes that represent map/list-native aggregate primitives. */
 export function isMapperCounterCode(code) {
-    return MAP_GROUP_CODES.has(code) || LIST_GROUP_CODES.has(code);
+    return AGGOR_MAP_CODES.has(code) || AGGOR_LIST_CODES.has(code);
 }

package/esm/src/primitives/matter.js

@@ -1,10 +1,19 @@
-import { b64ToInt, codeB2ToB64, codeB64ToB2, decodeB64, nabSextets, sceil, } from "../core/bytes.js";
-import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
-import { MATTER_HARDS, MATTER_SIZES, } from "../tables/matter.tables.generated.js";
+import { b, b64ToInt, codeB2ToB64, codeB64ToB2, concatBytes, decodeB64, encodeB64, intToB64, nabSextets, sceil, } from "../core/bytes.js";
+import { DeserializeError, ShortageError, UnknownCodeError } from "../core/errors.js";
+import { MATTER_HARDS, MATTER_SIZES } from "../tables/matter.tables.generated.js";
 const MATTER_BARDS = new Map([...MATTER_HARDS.entries()].map(([code, hs]) => [
     String.fromCharCode(codeB64ToB2(code)[0]),
     hs,
 ]));
+function isMatterData(value) {
+    return typeof value === "object"
+        && value !== null
+        && "code" in value
+        && "raw" in value
+        && "qb64" in value
+        && "fullSize" in value
+        && "fullSizeB2" in value;
+}
 function parseMatterCodeFromText(txt) {
     const hs = MATTER_HARDS.get(txt[0]);
     if (!hs) {
@@ -23,7 +32,7 @@ function parseMatterCodeFromText(txt) {
     }
     return { code, hs: sizage.hs };
 }
-export function parseMatterFromText(input) {
+function parseMatterFromTextData(input) {
     const txt = String.fromCharCode(...input);
     if (txt.length === 0) {
         throw new ShortageError(1, 0);
@@ -48,7 +57,7 @@ export function parseMatterFromText(input) {
         fullSizeB2: sceil((fullSize * 3) / 4),
     };
 }
-export function parseMatterFromBinary(input) {
+function parseMatterFromBinaryData(input) {
     if (input.length === 0) {
         throw new ShortageError(1, 0);
     }
@@ -93,7 +102,8 @@ export function parseMatterFromBinary(input) {
         }
     }
     const qb64 = codeB2ToB64(qb2, fs);
-    const raw = decodeB64(qb64.slice(cs)).slice(sizage.ls);
+    const paw = decodeB64("A".repeat(ps) + qb64.slice(cs));
+    const raw = paw.slice(ps + sizage.ls);
     return {
         code: hard,
         raw,
@@ -102,6 +112,150 @@ export function parseMatterFromBinary(input) {
         fullSizeB2: bfs,
     };
 }
+function encodeMatterFromRaw(code, raw) {
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown matter code ${code}`);
+    }
+    const cs = sizage.hs + sizage.ss;
+    const ps = cs % 4;
+    const paw = concatBytes(new Uint8Array(ps + sizage.ls), raw);
+    const body = encodeB64(paw).slice(ps);
+    let soft = "";
+    if (sizage.ss > 0) {
+        const softLen = sizage.ss - sizage.xs;
+        if (softLen < 0) {
+            throw new DeserializeError(`Invalid sizage soft width for code ${code}`);
+        }
+        const count = sizage.fs === null ? body.length / 4 : (sizage.fs - cs) / 4;
+        if (!Number.isInteger(count) || count < 0) {
+            throw new DeserializeError(`Invalid computed count for code ${code}`);
+        }
+        soft = "_".repeat(sizage.xs) + intToB64(count, softLen);
+    }
+    const qb64 = `${code}${soft}${body}`;
+    const fullSize = qb64.length;
+    if (sizage.fs !== null && fullSize !== sizage.fs) {
+        throw new DeserializeError(`Encoded size mismatch for ${code}: expected=${sizage.fs} got=${fullSize}`);
+    }
+    return {
+        code,
+        raw: raw.slice(),
+        qb64,
+        fullSize,
+        fullSizeB2: sceil((fullSize * 3) / 4),
+    };
+}
+function parseMatterInit(init) {
+    if (init.raw && init.code) {
+        return encodeMatterFromRaw(init.code, init.raw);
+    }
+    if (init.qb64b) {
+        return parseMatterFromTextData(init.qb64b);
+    }
+    if (init.qb64) {
+        return parseMatterFromTextData(b(init.qb64));
+    }
+    if (init.qb2) {
+        return parseMatterFromBinaryData(init.qb2);
+    }
+    throw new DeserializeError("Matter requires (raw + code) or qb64/qb64b/qb2 initialization");
+}
+/**
+ * Base CESR primitive carrying qualified matter material.
+ *
+ * KERIpy substance: `Matter` is the foundational primitive abstraction that
+ * handles exfil/infil between raw bytes and qualified CESR encodings.
+ */
+export class Matter {
+    constructor(init) {
+        Object.defineProperty(this, "_code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_qb64", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_fullSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_fullSizeB2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const data = init instanceof Matter
+            ? init.toMatterData()
+            : isMatterData(init)
+                ? init
+                : parseMatterInit(init);
+        this._code = data.code;
+        this._raw = data.raw.slice();
+        this._qb64 = data.qb64;
+        this._fullSize = data.fullSize;
+        this._fullSizeB2 = data.fullSizeB2;
+    }
+    toMatterData() {
+        return {
+            code: this._code,
+            raw: this._raw.slice(),
+            qb64: this._qb64,
+            fullSize: this._fullSize,
+            fullSizeB2: this._fullSizeB2,
+        };
+    }
+    get code() {
+        return this._code;
+    }
+    get raw() {
+        return this._raw;
+    }
+    get qb64() {
+        return this._qb64;
+    }
+    get qb64b() {
+        return b(this._qb64);
+    }
+    get qb2() {
+        return codeB64ToB2(this._qb64);
+    }
+    get fullSize() {
+        return this._fullSize;
+    }
+    get fullSizeB2() {
+        return this._fullSizeB2;
+    }
+    equals(other) {
+        return this._qb64 === other.qb64;
+    }
+    toString() {
+        return this._qb64;
+    }
+}
+/** Parse matter from text-domain CESR bytes. */
+export function parseMatterFromText(input) {
+    return new Matter(parseMatterFromTextData(input));
+}
+/** Parse matter from binary-domain CESR bytes. */
+export function parseMatterFromBinary(input) {
+    return new Matter(parseMatterFromBinaryData(input));
+}
+/** Parse matter using caller-provided cold-start domain hint (`txt` or `bny`). */
 export function parseMatter(input, cold) {
     return cold === "bny"
         ? parseMatterFromBinary(input)