cesr-ts 0.3.0 → 0.4.0

package/esm/src/primitives/tagger.js

@@ -0,0 +1,44 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { TAG_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Extract unpadded tag payload from a tag-coded qb64 token.
+ *
+ * Tag codes store the value in soft-code characters, optionally with xtra
+ * prepad (`xs`) that must be removed before exposing the semantic tag value.
+ */
+function extractTag(code, qb64) {
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown tag code ${code}`);
+    }
+    const soft = qb64.slice(sizage.hs, sizage.hs + sizage.ss);
+    return soft.slice(sizage.xs);
+}
+/** True when `code` belongs to KERIpy `TagCodex` family. */
+export function isTaggerCode(code) {
+    return TAG_CODES.has(code);
+}
+/**
+ * Compact "special" primitive for CESR tag values stored in soft-code fields.
+ *
+ * Invariant: instances always represent one of `TagCodex` codes.
+ */
+export class Tagger extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!isTaggerCode(this.code)) {
+            throw new UnknownCodeError(`Expected tag code, got ${this.code}`);
+        }
+    }
+    /** Decoded tag value with prepad removed. */
+    get tag() {
+        return extractTag(this.code, this.qb64);
+    }
+}
+/** Parse and hydrate a `Tagger` from txt or qb2 stream bytes. */
+export function parseTagger(input, cold) {
+    return new Tagger(parseMatter(input, cold));
+}

package/esm/src/primitives/texter.js

@@ -1,20 +1,29 @@
+import { t } from "../core/bytes.js";
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+import { TEXTER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
 function isTexterCode(code) {
-    const name = MATTER_CODE_NAMES[code] ?? "";
-    return name.startsWith("Bytes_") || name.startsWith("Bytes_Big_");
+    return TEXTER_CODES.has(code);
 }
-export function parseTexter(input, cold) {
-    const matter = parseMatter(input, cold);
-    if (!isTexterCode(matter.code)) {
-        throw new UnknownCodeError(`Expected texter bytes code, got ${matter.code}`);
+/**
+ * Raw-bytes text primitive.
+ *
+ * KERIpy substance: `Texter` carries variable-length byte-string text (UTF-8
+ * friendly) with Bytes codex families.
+ */
+export class Texter extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!isTexterCode(this.code)) {
+            throw new UnknownCodeError(`Expected texter bytes code, got ${this.code}`);
+        }
+    }
+    get text() {
+        return t(this.raw);
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        text: new TextDecoder().decode(matter.raw),
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `Texter` from txt/qb2 bytes. */
+export function parseTexter(input, cold) {
+    return new Texter(parseMatter(input, cold));
 }

package/esm/src/primitives/tholder.js

@@ -1,28 +1,31 @@
+import { t } from "../core/bytes.js";
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
-function isNumericName(name) {
-    return name === "Short" || name === "Long" || name === "Big" ||
-        name === "Tall" ||
-        name === "Large" || name === "Great" || name === "Vast";
-}
-function isWeightedName(name) {
-    return name.startsWith("StrB64_") || name.startsWith("StrB64_Big_");
+import { THOLDER_NUMERIC_CODES, THOLDER_WEIGHTED_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Threshold expression primitive.
+ *
+ * KERIpy substance: `Tholder` supports both numeric thresholds and weighted
+ * threshold expressions encoded as StrB64 payloads.
+ */
+export class Tholder extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!THOLDER_NUMERIC_CODES.has(this.code)
+            && !THOLDER_WEIGHTED_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected threshold code, got ${this.code}`);
+        }
+    }
+    get sith() {
+        if (THOLDER_NUMERIC_CODES.has(this.code)) {
+            return [...this.raw].reduce((acc, b) => (acc << 8n) | BigInt(b), 0n)
+                .toString(16);
+        }
+        return t(this.raw);
+    }
 }
+/** Parse and hydrate `Tholder` from txt/qb2 bytes. */
 export function parseTholder(input, cold) {
-    const matter = parseMatter(input, cold);
-    const name = MATTER_CODE_NAMES[matter.code] ?? "";
-    if (!isNumericName(name) && !isWeightedName(name)) {
-        throw new UnknownCodeError(`Expected threshold code, got ${matter.code}`);
-    }
-    const sith = isNumericName(name)
-        ? [...matter.raw].reduce((acc, b) => (acc << 8n) | BigInt(b), 0n).toString(16)
-        : new TextDecoder().decode(matter.raw);
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        sith,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+    return new Tholder(parseMatter(input, cold));
 }

package/esm/src/primitives/traitor.js

@@ -1,20 +1,27 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
-function isTraitName(name) {
-    return name.startsWith("Tag") || name === "No" || name === "Yes";
+import { TRAIT_TAGS } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+import { Tagger } from "./tagger.js";
+/**
+ * Configuration-trait primitive for key-event trait tags.
+ *
+ * KERIpy semantics: trait values are compact tags validated against canonical
+ * `TraitDex` membership rather than a local string list.
+ */
+export class Traitor extends Tagger {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!TRAIT_TAGS.has(this.tag)) {
+            throw new UnknownCodeError(`Invalid trait tag for Traitor: ${this.tag}`);
+        }
+    }
+    /** Trait string token (alias of validated tag payload). */
+    get trait() {
+        return this.tag;
+    }
 }
+/** Parse and hydrate `Traitor` from txt/qb2 bytes. */
 export function parseTraitor(input, cold) {
-    const matter = parseMatter(input, cold);
-    const name = MATTER_CODE_NAMES[matter.code] ?? "";
-    if (!isTraitName(name)) {
-        throw new UnknownCodeError(`Expected trait code, got ${matter.code}`);
-    }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        trait: name,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+    return new Traitor(parseMatter(input, cold));
 }

package/esm/src/primitives/unknown.js

@@ -0,0 +1,89 @@
+import { codeB64ToB2, encodeB64 } from "../core/bytes.js";
+/**
+ * Lossless placeholder for unrecognized CESR units encountered during parse.
+ *
+ * In compat fallback paths we preserve unknown payload bytes as instances of
+ * this class so roundtrip serialization can remain byte-accurate.
+ */
+export class UnknownPrimitive {
+    constructor(qb64, qb2, sourceDomain) {
+        Object.defineProperty(this, "code", {
+            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, "qb2", {
+            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, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sourceDomain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.code = "?";
+        this.qb64 = qb64;
+        this.qb2 = qb2.slice();
+        this.fullSize = qb64.length;
+        this.fullSizeB2 = qb2.length;
+        this.raw = qb2.slice();
+        this.sourceDomain = sourceDomain;
+    }
+    /**
+     * Build an unknown primitive directly from parser payload bytes.
+     *
+     * When `domain="txt"` and content is not valid base64, `qb2` intentionally
+     * keeps the original bytes to remain lossless.
+     */
+    static fromPayload(payload, domain) {
+        if (domain === "bny") {
+            return new UnknownPrimitive(encodeB64(payload), payload, domain);
+        }
+        const qb64 = String.fromCharCode(...payload);
+        let qb2;
+        try {
+            qb2 = codeB64ToB2(qb64);
+        }
+        catch {
+            // Keep unknown text tokens lossless even when not valid base64 quads.
+            qb2 = payload.slice();
+        }
+        return new UnknownPrimitive(qb64, qb2, domain);
+    }
+    /** Equality by canonical text form used throughout primitive graph comparisons. */
+    equals(other) {
+        return this.qb64 === other.qb64;
+    }
+    /** String coercion returns canonical qb64 text token. */
+    toString() {
+        return this.qb64;
+    }
+}

package/esm/src/primitives/verfer.js

@@ -1,28 +1,28 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
-const VERFER_CODE_NAMES = new Set([
-    "Ed25519N",
-    "Ed25519",
-    "ECDSA_256k1N",
-    "ECDSA_256k1",
-    "ECDSA_256r1N",
-    "ECDSA_256r1",
-    "Ed448N",
-    "Ed448",
-]);
-export function parseVerfer(input, cold) {
-    const matter = parseMatter(input, cold);
-    const name = MATTER_CODE_NAMES[matter.code] ?? "";
-    if (!VERFER_CODE_NAMES.has(name)) {
-        throw new UnknownCodeError(`Expected verification key code, got ${matter.code}`);
+import { matterCodexName, VERFER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Verification-key primitive.
+ *
+ * KERIpy substance: `Verfer` wraps public verification key material and
+ * constrains accepted derivation codes to verifier key families.
+ */
+export class Verfer extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!VERFER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected verification key code, got ${this.code}`);
+        }
+    }
+    get key() {
+        return this.raw;
+    }
+    get algorithm() {
+        return matterCodexName(this.code) ?? "UnknownKey";
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        key: matter.raw,
-        algorithm: name,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `Verfer` from txt/qb2 bytes. */
+export function parseVerfer(input, cold) {
+    return new Verfer(parseMatter(input, cold));
 }

package/esm/src/primitives/verser.js

@@ -1,30 +1,61 @@
 import { b64ToInt } from "../core/bytes.js";
 import { DeserializeError, UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-const PROTOCOLS = new Set(["KERI", "ACDC"]);
-export function parseVerser(input, cold) {
-    const matter = parseMatter(input, cold);
-    if (matter.code !== "0O" && matter.code !== "1O") {
-        throw new UnknownCodeError(`Expected verser code (0O/1O), got ${matter.code}`);
-    }
-    const body = matter.qb64.slice(matter.code.length);
-    if (body.length < 6) {
-        throw new DeserializeError(`Invalid verser body length=${body.length}`);
+import { VERSER_CODES, VERSER_PROTOCOLS } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+import { Tagger } from "./tagger.js";
+/** Decode 3-char CESR version token (`Mmm`) into major/minor version tuple. */
+function parseVersion(text) {
+    if (text.length !== 3) {
+        throw new DeserializeError(`Invalid version text length=${text.length}`);
     }
-    const proto = body.slice(0, 4);
-    if (!PROTOCOLS.has(proto)) {
-        throw new DeserializeError(`Unsupported verser proto=${proto}`);
+    const major = b64ToInt(text[0]);
+    if (major !== 1 && major !== 2) {
+        throw new DeserializeError(`Unsupported version major=${major}`);
     }
-    const major = b64ToInt(body[4]) === 1 ? 1 : 2;
-    const minor = b64ToInt(body[5]);
-    const versage = { major, minor };
     return {
-        code: matter.code,
-        qb64: matter.qb64,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-        proto,
-        pvrsn: versage,
-        gvrsn: versage,
+        major,
+        minor: b64ToInt(text.slice(1)),
     };
 }
+/**
+ * Compact version primitive for protocol/genus version metadata.
+ *
+ * KERIpy semantics: payload tag is `proto + pvrsn (+ gvrsn optional)` where
+ * proto is `KERI|ACDC`, `pvrsn` is always present, and `gvrsn` is present only
+ * for 10-char tags.
+ */
+export class Verser extends Tagger {
+    constructor(init) {
+        const tagger = init instanceof Matter ? init : new Matter(init);
+        super(tagger);
+        if (!VERSER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected verser code (Y/0O), got ${this.code}`);
+        }
+        const body = this.tag;
+        if (body.length !== 7 && body.length !== 10) {
+            throw new DeserializeError(`Invalid verser tag length=${body.length}`);
+        }
+        if (!VERSER_PROTOCOLS.has(body.slice(0, 4))) {
+            throw new DeserializeError(`Unsupported verser proto=${body.slice(0, 4)}`);
+        }
+        parseVersion(body.slice(4, 7));
+        if (body.length === 10)
+            parseVersion(body.slice(7, 10));
+    }
+    /** Protocol namespace extracted from verser tag payload. */
+    get proto() {
+        return this.tag.slice(0, 4);
+    }
+    /** Protocol-version tuple (`major`, `minor`) decoded from tag payload. */
+    get pvrsn() {
+        return parseVersion(this.tag.slice(4, 7));
+    }
+    /** Optional genus-version tuple decoded when 10-char verser payload is present. */
+    get gvrsn() {
+        return this.tag.length === 10 ? parseVersion(this.tag.slice(7, 10)) : null;
+    }
+}
+/** Parse and hydrate `Verser` from txt/qb2 bytes. */
+export function parseVerser(input, cold) {
+    return new Verser(parseMatter(input, cold));
+}

package/esm/src/serder/serder.js

@@ -1,6 +1,13 @@
-import { DeserializeError } from "../core/errors.js";
 import { decode as decodeMsgpack } from "@msgpack/msgpack";
-import { decode as decodeCbor } from "cbor-x/decode";
+import { t } from "../core/bytes.js";
+import { decodeKeriCbor } from "../core/cbor.js";
+import { DeserializeError } from "../core/errors.js";
+import { Aggor, isAggorCode } from "../primitives/aggor.js";
+import { Blinder, isBlinderCode } from "../primitives/blinder.js";
+import { isMediarCode, Mediar } from "../primitives/mediar.js";
+import { isCounterGroupLike, isPrimitiveTuple, } from "../primitives/primitive.js";
+import { isSealerCode, Sealer } from "../primitives/sealer.js";
+import { Protocols } from "../tables/versions.js";
 function normalizeDecodedMap(value, kind) {
     if (value && typeof value === "object" && !Array.isArray(value)) {
         if (value instanceof Map) {
@@ -17,9 +24,171 @@ function normalizeDecodedMap(value, kind) {
     }
     throw new DeserializeError(`${kind} root must be a map/object`);
 }
-// TODO should this be called parseBody?
-//   If we're going to say parseSerder then it should doo a full deserialization
-//   and the CesrBody should be a Serder with subclasses for SerderKERI and SerderACDC
+function collectNestedGroups(entries, out) {
+    for (const entry of entries) {
+        if (isPrimitiveTuple(entry)) {
+            collectNestedGroups(entry, out);
+            continue;
+        }
+        if (isCounterGroupLike(entry)) {
+            out.push(entry);
+            collectNestedGroups(entry.items, out);
+        }
+    }
+}
+/** Extract all top-level + nested counted groups from one parsed message. */
+function collectMessageGroups(message) {
+    const groups = [];
+    for (const attachment of message.attachments) {
+        groups.push(attachment);
+        collectNestedGroups(attachment.items, groups);
+    }
+    return groups;
+}
+/**
+ * Base Serder body class.
+ *
+ * KERIpy substance: Serders carry raw serialized event bytes plus decoded KED
+ * projections (`ilk`/`said`) and protocol/version metadata.
+ */
+export class Serder {
+    constructor(init) {
+        Object.defineProperty(this, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "proto", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pvrsn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gvrsn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ilk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "said", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.raw = init.raw;
+        this.ked = init.ked;
+        this.kind = init.smellage.kind;
+        this.size = init.smellage.size;
+        this.proto = init.smellage.proto;
+        this.pvrsn = init.smellage.pvrsn;
+        this.gvrsn = init.smellage.gvrsn;
+        this.ilk = init.ilk;
+        this.said = init.said;
+    }
+    /** True when this body belongs to KERI protocol domain. */
+    get isKeri() {
+        return this.proto === Protocols.keri;
+    }
+    /** True when this body belongs to ACDC protocol domain. */
+    get isAcdc() {
+        return this.proto === Protocols.acdc;
+    }
+    /**
+     * Project counted attachment groups into structor subclasses.
+     *
+     * This keeps Serder + attachment processing cohesive for consumers that
+     * immediately need typed structor families after frame parsing.
+     */
+    projectStructors(message) {
+        const groups = collectMessageGroups(message);
+        const projection = {
+            aggor: [],
+            sealer: [],
+            blinder: [],
+            mediar: [],
+            other: [],
+        };
+        for (const group of groups) {
+            if (isSealerCode(group.code)) {
+                projection.sealer.push(Sealer.fromGroup(group));
+                continue;
+            }
+            if (isBlinderCode(group.code)) {
+                projection.blinder.push(Blinder.fromGroup(group));
+                continue;
+            }
+            if (isMediarCode(group.code)) {
+                projection.mediar.push(Mediar.fromGroup(group));
+                continue;
+            }
+            if (isAggorCode(group.code)) {
+                projection.aggor.push(Aggor.fromGroup(group));
+                continue;
+            }
+            projection.other.push(group);
+        }
+        return projection;
+    }
+}
+/** KERI-protocol Serder subtype (`proto=KERI`). */
+export class SerderKERI extends Serder {
+    constructor(init) {
+        super(init);
+        if (!this.isKeri) {
+            throw new DeserializeError(`Expected KERI protocol serder, got ${this.proto}`);
+        }
+    }
+}
+/** ACDC-protocol Serder subtype (`proto=ACDC`). */
+export class SerderACDC extends Serder {
+    constructor(init) {
+        super(init);
+        if (!this.isAcdc) {
+            throw new DeserializeError(`Expected ACDC protocol serder, got ${this.proto}`);
+        }
+    }
+}
+/**
+ * Parse one raw Serder body and hydrate protocol-specific Serder subclasses.
+ */
 export function parseSerder(raw, smellage) {
     const { proto, kind, pvrsn, gvrsn, size } = smellage;
     let ked = null;
@@ -27,14 +196,14 @@ export function parseSerder(raw, smellage) {
     let said = null;
     try {
         if (kind === "JSON") {
-            const text = new TextDecoder().decode(raw);
+            const text = t(raw);
             ked = JSON.parse(text);
         }
         else if (kind === "MGPK") {
             ked = normalizeDecodedMap(decodeMsgpack(raw), kind);
         }
         else if (kind === "CBOR") {
-            ked = normalizeDecodedMap(decodeCbor(raw), kind);
+            ked = normalizeDecodedMap(decodeKeriCbor(raw), kind);
         }
         if (ked) {
             ilk = typeof ked.t === "string" ? ked.t : null;
@@ -53,7 +222,18 @@ export function parseSerder(raw, smellage) {
         }
         throw error;
     }
-    // TODO support SerderKERI and SerderACDC.
-    //   Is that done at this level or the next level up?
-    return { raw, ked, proto, kind, size, pvrsn, gvrsn, ilk, said };
+    const init = {
+        raw,
+        smellage: { proto, kind, pvrsn, gvrsn, size },
+        ked,
+        ilk,
+        said,
+    };
+    if (proto === Protocols.keri) {
+        return new SerderKERI(init);
+    }
+    if (proto === Protocols.acdc) {
+        return new SerderACDC(init);
+    }
+    return new Serder(init);
 }

package/esm/src/serder/serdery.js

@@ -1,6 +1,6 @@
-import { smell } from "./smell.js";
-import { parseSerder } from "./serder.js";
 import { ShortageError } from "../core/errors.js";
+import { parseSerder } from "./serder.js";
+import { smell } from "./smell.js";
 export function reapSerder(input) {
     const { smellage } = smell(input);
     if (input.length < smellage.size) {

package/esm/src/tables/codex-utils.js

@@ -0,0 +1,9 @@
+export function codexValues(codex) {
+    return new Set(Object.values(codex));
+}
+export function invertCodex(codex) {
+    return new Map(Object.entries(codex).map(([name, code]) => [
+        code,
+        name,
+    ]));
+}

package/esm/src/tables/counter-codex.js

@@ -1,4 +1,4 @@
-import { COUNTER_CODE_NAMES_V1, COUNTER_CODE_NAMES_V2, } from "./counter.tables.generated.js";
+import { COUNTER_CODE_NAMES_V1, COUNTER_CODE_NAMES_V2 } from "./counter.tables.generated.js";
 function invertCodeNames(map) {
     const out = {};
     for (const [code, name] of Object.entries(map)) {