@macula-io/ts 0.18.0 → 0.19.0

package/dist/directdial.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"directdial.js","sourceRoot":"","sources":["../src/directdial.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,iEAAiE;AACjE,sEAAsE;AACtE,kEAAkE;AAClE,wEAAwE;AACxE,uEAAuE;AACvE,0EAA0E;AAC1E,uEAAuE;AACvE,sEAAsE;AACtE,yEAAyE;AACzE,0EAA0E;AAC1E,0EAA0E;AAC1E,qEAAqE;AACrE,qEAAqE;AACrE,qEAAqE;AACrE,uEAAuE;AACvE,oEAAoE;AACpE,4DAA4D;AAC5D,wEAAwE;AAmCxE;;;;;;;mCAOmC;AACnC,MAAM,CAAC,MAAM,kCAAkC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;;sBAuBsB;AACtB,MAAM,UAAU,oBAAoB,CAAC,OAAgB,EAAE,SAAiB,EAAE,IAAI,GAAgC,EAAE;IAC9G,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,kCAAkC,CAAC;IACzE,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,MAAM,IAAI,GAAG,GAAS,EAAE;QACtB,OAAO,CAAC,eAAe,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;YAClG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,IAAI,EAAE,CAAC;IACP,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC5C,oEAAoE;IACpE,uEAAuE;IACvE,sEAAsE;IACtE,qEAAqE;IACrE,sEAAsE;IACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IAEhB,OAAO,GAAS,EAAE;QAChB,IAAI,OAAO;YAAE,OAAO;QACpB,OAAO,GAAG,IAAI,CAAC;QACf,aAAa,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC,CAAC;AACJ,CAAC"}

package/dist/identity.d.ts

@@ -1,43 +0,0 @@
-import { type Handle } from "./binding.js";
-export declare class Identity {
-    #private;
-    private constructor();
-    /** Mints a fresh identity, grinding an Ed25519 keypair until its
-     * NodeID's SHA-256 has the required S/Kademlia puzzle difficulty
-     * (macula-go's DefaultPuzzleDifficulty = 8 leading zero bits). This
-     * is real work done on the Go side -- not instant, not mocked. */
-    static generate(): Identity;
-    /** Reconstructs an identity from a previously-saved 32-byte Ed25519
-     * seed. Deterministic: does not re-grind the puzzle (a seed that
-     * already satisfied it at generation time still does). */
-    static fromSeedBytes(seed32: Uint8Array): Identity;
-    /** The 32-byte Ed25519 public key this identity is known by on the
-     * wire (CONNECT/HELLO's node_id field). */
-    get nodeId(): Uint8Array;
-    /** The 32-byte Ed25519 seed -- persist this (e.g. to a 0600 file)
-     * to reconstruct the identity later via fromSeedBytes. Treat as a
-     * private key: anyone with this seed can sign as this identity. */
-    get privateSeedBytes(): Uint8Array;
-    /** Signs data with this identity's private key (Ed25519, via
-     * macula-go's identity.KeyPair.Sign -- a direct ed25519.Sign wrapper)
-     * and returns the raw 64-byte signature. This is a generic signing
-     * primitive: no application-specific message format is baked in
-     * here or on the Go side -- data is signed exactly as given, byte
-     * for byte. A caller that needs a particular byte-layout convention
-     * (e.g. an ownership-proof format binding this signature to some
-     * other value) builds those bytes itself and passes the result in;
-     * that convention is the caller's concern, not this method's.
-     * Deterministic: signing the same data twice with the same identity
-     * produces the same signature (Ed25519 has no per-signature nonce
-     * randomness the way ECDSA does). */
-    sign(data: Uint8Array): Uint8Array;
-    /** Frees the Go-side handle. Safe to call more than once. */
-    dispose(): void;
-    /** The raw native handle, for Session.connect/close only -- they need
-     * it to establish/close a connection under this identity. JS private
-     * fields (#handle) are genuinely inaccessible from outside this
-     * class body, even to other code in this package, so this method is
-     * how Session and Identity cooperate across the FFI boundary. Not
-     * part of the intended public API. */
-    handleForFfi(): Handle;
-}

package/dist/identity.js

@@ -1,83 +0,0 @@
-// Public identity API -- the one real capability this walking
-// skeleton proves end-to-end: minting a Macula peer identity (an
-// Ed25519 keypair, S/Kademlia puzzle-hardened) via macula-go's own
-// identity.Generate(), reached through cabi/'s FFI boundary rather
-// than reimplemented here.
-//
-// An Identity wraps a Go-side handle. It is a disposable, freeable
-// resource: call dispose() when done with it (or let the process
-// exit -- the Go side doesn't leak across a process lifetime, but a
-// long-running host process minting many identities should dispose
-// each one). There is no finalizer/GC integration in this skeleton;
-// forgetting to call dispose() leaks the Go-side handle for the life
-// of the process, exactly as macula-php's identical handle-based
-// design does.
-import { native } from "./binding.js";
-export class Identity {
-    #handle;
-    constructor(handle) {
-        this.#handle = handle;
-    }
-    /** Mints a fresh identity, grinding an Ed25519 keypair until its
-     * NodeID's SHA-256 has the required S/Kademlia puzzle difficulty
-     * (macula-go's DefaultPuzzleDifficulty = 8 leading zero bits). This
-     * is real work done on the Go side -- not instant, not mocked. */
-    static generate() {
-        return new Identity(native.identityGenerate());
-    }
-    /** Reconstructs an identity from a previously-saved 32-byte Ed25519
-     * seed. Deterministic: does not re-grind the puzzle (a seed that
-     * already satisfied it at generation time still does). */
-    static fromSeedBytes(seed32) {
-        return new Identity(native.identityFromSeedBytes(seed32));
-    }
-    #requireHandle() {
-        if (this.#handle === null) {
-            throw new Error("macula-ts: Identity used after dispose()");
-        }
-        return this.#handle;
-    }
-    /** The 32-byte Ed25519 public key this identity is known by on the
-     * wire (CONNECT/HELLO's node_id field). */
-    get nodeId() {
-        return native.identityNodeId(this.#requireHandle());
-    }
-    /** The 32-byte Ed25519 seed -- persist this (e.g. to a 0600 file)
-     * to reconstruct the identity later via fromSeedBytes. Treat as a
-     * private key: anyone with this seed can sign as this identity. */
-    get privateSeedBytes() {
-        return native.identityPrivateBytes(this.#requireHandle());
-    }
-    /** Signs data with this identity's private key (Ed25519, via
-     * macula-go's identity.KeyPair.Sign -- a direct ed25519.Sign wrapper)
-     * and returns the raw 64-byte signature. This is a generic signing
-     * primitive: no application-specific message format is baked in
-     * here or on the Go side -- data is signed exactly as given, byte
-     * for byte. A caller that needs a particular byte-layout convention
-     * (e.g. an ownership-proof format binding this signature to some
-     * other value) builds those bytes itself and passes the result in;
-     * that convention is the caller's concern, not this method's.
-     * Deterministic: signing the same data twice with the same identity
-     * produces the same signature (Ed25519 has no per-signature nonce
-     * randomness the way ECDSA does). */
-    sign(data) {
-        return native.identitySign(this.#requireHandle(), data);
-    }
-    /** Frees the Go-side handle. Safe to call more than once. */
-    dispose() {
-        if (this.#handle !== null) {
-            native.identityFree(this.#handle);
-            this.#handle = null;
-        }
-    }
-    /** The raw native handle, for Session.connect/close only -- they need
-     * it to establish/close a connection under this identity. JS private
-     * fields (#handle) are genuinely inaccessible from outside this
-     * class body, even to other code in this package, so this method is
-     * how Session and Identity cooperate across the FFI boundary. Not
-     * part of the intended public API. */
-    handleForFfi() {
-        return this.#requireHandle();
-    }
-}
-//# sourceMappingURL=identity.js.map

package/dist/identity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,iEAAiE;AACjE,mEAAmE;AACnE,mEAAmE;AACnE,2BAA2B;AAC3B,EAAE;AACF,mEAAmE;AACnE,iEAAiE;AACjE,oEAAoE;AACpE,mEAAmE;AACnE,oEAAoE;AACpE,qEAAqE;AACrE,iEAAiE;AACjE,eAAe;AACf,OAAO,EAAE,MAAM,EAAe,MAAM,cAAc,CAAC;AAEnD,MAAM,OAAO,QAAQ;IACnB,OAAO,CAAgB;IAEvB,YAAoB,MAAc;QAChC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED;;;sEAGkE;IAClE,MAAM,CAAC,QAAQ;QACb,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACjD,CAAC;IAED;;8DAE0D;IAC1D,MAAM,CAAC,aAAa,CAAC,MAAkB;QACrC,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,cAAc;QACZ,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;+CAC2C;IAC3C,IAAI,MAAM;QACR,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;uEAEmE;IACnE,IAAI,gBAAgB;QAClB,OAAO,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;;;yCAWqC;IACrC,IAAI,CAAC,IAAgB;QACnB,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,6DAA6D;IAC7D,OAAO;QACL,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAClC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,CAAC;IACH,CAAC;IAED;;;;;0CAKsC;IACtC,YAAY;QACV,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;IAC/B,CAAC;CACF"}

package/dist/pubsub.d.ts

@@ -1,60 +0,0 @@
-import type { BytesOutput, JsonValue } from "./rpc.js";
-/** Options for Session.publish(). */
-export interface PublishOptions {
-    /** How many milliseconds from now this event should live -- a
-     * DURATION, not a timestamp (matches every other ttlMs in this SDK,
-     * e.g. dht.ts's DHT_DEFAULT_TTL_MS) -- PublishSpec's own `ttl_ms`
-     * (frame/pubsub.go) is computed from this. Omitted means no TTL, not
-     * zero or an invented default -- macula-go's Publish has no fallback
-     * of its own for this field, unlike the DHT puts' TTL. */
-    ttlMs?: number;
-    /** The realm this PUBLISH is scoped to, as a 64-character hex string
-     * (32 bytes) -- see session.ts's CallOptions.realm for the full
-     * convention this shares. Omitted means the all-zero realm. Realm is
-     * an exact-match routing key: a subscribe() only ever receives this
-     * event if its own realm matches exactly, not a prefix or default
-     * fallback. */
-    realm?: string;
-}
-/** Options for Session.subscribe(). */
-export interface SubscribeOptions {
-    /** The realm this SUBSCRIBE listens on -- see PublishOptions.realm's
-     * own doc for the format and exact-match semantics. Omitted means the
-     * all-zero realm. Must match the realm a publisher actually used, or
-     * nothing published under a different realm is ever delivered here. */
-    realm?: string;
-    /** How bytes in each event's payload reach the handler: "hex" (the
-     * default) or "tagged" -- see rpc.ts's BytesOutput. */
-    bytes?: BytesOutput;
-    /** Called at most once, only if this subscription's background
-     * reader exits on its own -- the underlying session/connection died,
-     * or some other transport error ended the read loop -- rather than
-     * via the stop() subscribe() returned being called. See
-     * Session.subscribe()'s own doc for the full story (a real bug this
-     * SDK had and fixed: without this signal, such a subscription went
-     * silent forever and left the Session unable to close cleanly).
-     * Optional: even without a handler here, the subscription still
-     * tears itself down automatically and correctly the moment this
-     * happens -- this is purely a notification hook for a caller who
-     * wants to know why events stopped arriving. */
-    onClosed?: (error: Error) => void;
-}
-/** One delivered EVENT -- macula-go's frame.EventInfo, minus `Realm`
- * (the delivering EVENT's own realm is not surfaced back per-event here
- * -- a caller already knows it, since subscribe()'s own `realm` option
- * is what selected which realm's events reach this handler at all) and
- * `DeliveredVia` (a routing/telemetry detail, not part of this SDK's
- * scope yet). `payload`
- * follows rpc.ts's JsonValue rules exactly like a CALL payload does --
- * no boolean, embedded bytes as "0x"-prefixed hex by default or as
- * `{"$bytes": base64}` when subscribe() asked for `bytes: "tagged"`
- * (see cabi/wirevalue.go).
- * `publisher` is the raw 32-byte Ed25519 public key of whoever published
- * this event -- NOT verified against the frame's own signature by this
- * SDK, matching findRecord/findRecords/findRecordsByType's identical
- * "does not verify" posture (dht.ts). */
-export interface PubsubEvent {
-    readonly payload: JsonValue;
-    readonly publisher: Uint8Array;
-    readonly seq: number;
-}

package/dist/pubsub.js

@@ -1,8 +0,0 @@
-// Pubsub shapes -- macula-go's connection.Session.Publish/Subscribe/
-// Unsubscribe and frame.EventInfo (frame/pubsub.go, connection/
-// connection.go, connection/subscriber.go). Session (session.ts) is the
-// actual FFI entry point (publish()/subscribe()), matching call()/
-// serve()/the DHT methods' own shape -- this file holds the shapes that
-// side needs, the same split rpc.ts/dht.ts already have.
-export {};
-//# sourceMappingURL=pubsub.js.map

package/dist/pubsub.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pubsub.js","sourceRoot":"","sources":["../src/pubsub.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,gEAAgE;AAChE,wEAAwE;AACxE,mEAAmE;AACnE,wEAAwE;AACxE,yDAAyD"}

package/dist/rpc.d.ts

@@ -1,86 +0,0 @@
-/** A CALL/RESULT payload, restricted to what macula's wire CBOR can
- * actually represent (cbor.Value's Kind enum: UInt/NegInt/Bytes/Text/
- * List/Map/Null/Float -- no bool, no undefined). There is deliberately
- * no `boolean` in this union: encode true/false as 1/0 yourself, the
- * same rule this project's macula MCP server and macula-cli's own
- * wirevalue package both enforce -- a JS boolean silently reaching the
- * wire is exactly the mistake this type exists to make impossible at
- * compile time.
- *
- * Bytes have no native JSON shape either. Going IN, write them as an
- * object whose ONLY key is "$bytes", holding standard padded base64
- * (RFC 4648 section 4): `{"$bytes": "AQID"}` is the three bytes 01 02 03.
- * Any other value under that sole key is rejected, an object with more
- * keys stays an ordinary map, and a plain string is always text, even
- * one that looks like hex -- so the sole-key "$bytes" object is
- * reserved. Coming OUT, bytes are a "0x"-prefixed lowercase hex string
- * by default, or that same tagged object when the call, serve() or
- * subscribe() asked for `bytes: "tagged"` (see BytesOutput), which lets
- * a returned value be sent straight back. See cabi/wirevalue.go. */
-export type JsonValue = string | number | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/** How bytes in a RESULT, an inbound CALL or an EVENT payload reach
- * JavaScript: "hex" (the default) as a "0x"-prefixed lowercase hex
- * string, "tagged" as `{"$bytes": "<base64>"}`, the same form a payload
- * uses going IN. The choice is made on the Go side, per call, serve()
- * or subscribe(), because only Go still knows which values were bytes:
- * once rendered as hex, bytes and a text value that looks like "0x..."
- * can no longer be told apart. */
-export type BytesOutput = "hex" | "tagged";
-/** BytesOutput as the integer cabi's bytesOutput takes. An unknown value
- * (reachable from plain JavaScript) throws instead of silently falling
- * back to hex. Internal to the FFI boundary. */
-export declare function bytesModeFor(bytes: BytesOutput | undefined): number;
-/** The BOLT#4 fields a failed CALL carries -- see bolt4/bolt4.go's own
- * 17-code table (UnknownNextPeer, TemporaryRelayFailure, Unauthorized,
- * ...). `retryable` is bolt4.Code.IsRetryable()'s verdict, computed
- * Go-side from `code` (cabi/rpc.go), not re-derived here. */
-export interface Bolt4ErrorInfo {
-    readonly code: number;
-    readonly name: string;
-    readonly retryable: boolean;
-    readonly detail: string | null;
-}
-/** Thrown by Session.call() when the provider (or a relay in between)
- * answered with a real BOLT#4 ERROR frame instead of a RESULT -- e.g.
- * calling a procedure nobody has advertised comes back
- * unknown_next_peer; a provider handler that threw comes back
- * unknown_error (macula-go's connection/serve.go maps every handler
- * error to that one code, matching macula_station_link.erl's own
- * handle_inbound_call/2); a provider handler that panicked (recovered)
- * comes back temporary_relay_failure. Distinct from a plain
- * Error/rejection out of call() itself, which means this CALL never
- * got a wire-level answer at all (a local timeout, a dead connection,
- * a payload macula's CBOR can't represent). */
-export declare class MaculaCallError extends Error {
-    readonly code: number;
-    readonly bolt4Name: string;
-    readonly retryable: boolean;
-    readonly detail: string | null;
-    constructor(info: Bolt4ErrorInfo);
-}
-/** The JSON envelope cabi/rpc.go's macula_session_call returns --
- * internal to the FFI boundary, not part of the public API. Kept in
- * sync BY HAND with cabi/rpc.go's callEnvelope/callEnvelopeError Go
- * structs; there is no shared schema generating either side. */
-export type CallEnvelope = {
-    ok: true;
-    payload: JsonValue;
-} | {
-    ok: false;
-    bolt4: Bolt4ErrorInfo;
-};
-/** How long Session.call() waits for a RESULT/ERROR before giving up,
- * in milliseconds -- also becomes the wire's own `deadline_ms` (now +
- * this), matching macula-go's own examples/quickstart/main.go, which
- * derives both from one duration rather than treating the local wait
- * and the wire deadline as independent numbers. */
-export declare const DEFAULT_CALL_TIMEOUT_MS = 30000;
-/** How long one Session.serve() poll tick blocks waiting for the next
- * inbound CALL before checking whether stop() was requested --
- * mirrors macula-go's own servePollInterval (connection/serve_loop.go),
- * the exact tick length its ServeForever uses internally for the same
- * "poll with a bounded per-tick wait, check for cancellation between
- * ticks" shape. */
-export declare const SERVE_POLL_MS = 2000;

package/dist/rpc.js

@@ -1,57 +0,0 @@
-// Unary RPC -- the caller and provider roles built on top of a
-// handshaked Session's control stream, via macula-go's own
-// Session.Call (caller) and Session.Advertise + Session.ServeOneCall
-// (provider) -- see connection/connection.go and connection/serve.go.
-// The actual FFI plumbing lives on Session (session.ts); this file
-// holds the shapes both directions share: the JSON-only payload model
-// and the structured BOLT#4 error macula-go's own bolt4 package
-// defines (bolt4/bolt4.go, 17 codes).
-/** BytesOutput as the integer cabi's bytesOutput takes. An unknown value
- * (reachable from plain JavaScript) throws instead of silently falling
- * back to hex. Internal to the FFI boundary. */
-export function bytesModeFor(bytes) {
-    if (bytes === undefined || bytes === "hex")
-        return 0;
-    if (bytes === "tagged")
-        return 1;
-    throw new Error(`macula-ts: bytes must be "hex" or "tagged", got ${JSON.stringify(bytes)}`);
-}
-/** Thrown by Session.call() when the provider (or a relay in between)
- * answered with a real BOLT#4 ERROR frame instead of a RESULT -- e.g.
- * calling a procedure nobody has advertised comes back
- * unknown_next_peer; a provider handler that threw comes back
- * unknown_error (macula-go's connection/serve.go maps every handler
- * error to that one code, matching macula_station_link.erl's own
- * handle_inbound_call/2); a provider handler that panicked (recovered)
- * comes back temporary_relay_failure. Distinct from a plain
- * Error/rejection out of call() itself, which means this CALL never
- * got a wire-level answer at all (a local timeout, a dead connection,
- * a payload macula's CBOR can't represent). */
-export class MaculaCallError extends Error {
-    code;
-    bolt4Name;
-    retryable;
-    detail;
-    constructor(info) {
-        super(`macula-ts: CALL failed: ${info.name} (bolt4 code ${info.code})${info.detail ? `: ${info.detail}` : ""}`);
-        this.name = "MaculaCallError";
-        this.code = info.code;
-        this.bolt4Name = info.name;
-        this.retryable = info.retryable;
-        this.detail = info.detail;
-    }
-}
-/** How long Session.call() waits for a RESULT/ERROR before giving up,
- * in milliseconds -- also becomes the wire's own `deadline_ms` (now +
- * this), matching macula-go's own examples/quickstart/main.go, which
- * derives both from one duration rather than treating the local wait
- * and the wire deadline as independent numbers. */
-export const DEFAULT_CALL_TIMEOUT_MS = 30_000;
-/** How long one Session.serve() poll tick blocks waiting for the next
- * inbound CALL before checking whether stop() was requested --
- * mirrors macula-go's own servePollInterval (connection/serve_loop.go),
- * the exact tick length its ServeForever uses internally for the same
- * "poll with a bounded per-tick wait, check for cancellation between
- * ticks" shape. */
-export const SERVE_POLL_MS = 2_000;
-//# sourceMappingURL=rpc.js.map

package/dist/rpc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,2DAA2D;AAC3D,qEAAqE;AACrE,sEAAsE;AACtE,mEAAmE;AACnE,sEAAsE;AACtE,gEAAgE;AAChE,sCAAsC;AAgCtC;;gDAEgD;AAChD,MAAM,UAAU,YAAY,CAAC,KAA8B;IACzD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,CAAC,CAAC;IACrD,IAAI,KAAK,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACjC,MAAM,IAAI,KAAK,CAAC,mDAAmD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAC9F,CAAC;AAaD;;;;;;;;;;+CAU+C;AAC/C,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAS;IACb,SAAS,CAAS;IAClB,SAAS,CAAU;IACnB,MAAM,CAAgB;IAE/B,YAAY,IAAoB;QAC9B,KAAK,CAAC,2BAA2B,IAAI,CAAC,IAAI,gBAAgB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAChH,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC5B,CAAC;CACF;AAQD;;;;mDAImD;AACnD,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC;AAE9C;;;;;mBAKmB;AACnB,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC"}