@tribe-nest/media-protocol 1.0.0

package/build/frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../src/frames.ts"],"names":[],"mappings":"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"}

package/build/frames.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEvent = exports.serverFrameSchema = exports.eventFrameSchema = exports.peerSchema = exports.responseFrameSchema = exports.requestFrameSchema = void 0;
+const zod_1 = require("zod");
+const errorSchema_1 = require("./errorSchema");
+const grants_1 = require("./grants");
+/**
+ * The client <-> node signalling wire.
+ *
+ * One envelope, stated once. Six phase plans independently invented four
+ * different ones (`m` / `type` / `method` / `action`, numeric versus string
+ * ids, `result` versus `data`), and every mismatch is a hard parse failure
+ * discovered at integration by a different pair of people.
+ *
+ * ## Shape
+ *
+ * Requests carry an `id` and get exactly one reply with the same `id`. Events
+ * carry no `id` and are never replied to. That is the whole protocol; anything
+ * needing more structure is a request that returns a handle.
+ *
+ * ## What is deliberately NOT here
+ *
+ * No pipe verb, no node id, no mesh address. A client cannot express "pipe this
+ * producer to that node", because piping is a side effect of `consume` and the
+ * only way to keep it lazy is for eager piping to be unsayable.
+ */
+exports.requestFrameSchema = zod_1.z.discriminatedUnion("method", [
+    zod_1.z.object({
+        method: zod_1.z.literal("join"),
+        id: zod_1.z.number().int().nonnegative(),
+        protocolVersion: zod_1.z.number().int(),
+        /** The token travels in the first frame, NEVER in the URL: a query string
+         * lands in load-balancer access logs, and a join ticket in a log is a join
+         * ticket for anyone who can read logs. */
+        token: zod_1.z.string().min(1),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("createTransport"),
+        id: zod_1.z.number().int().nonnegative(),
+        direction: zod_1.z.enum(["send", "recv"]),
+        /**
+         * Deliberately absent: which KIND of transport this is.
+         *
+         * The kind comes from the token's `transport` claim and from nowhere else.
+         * Letting a client ask would mean a browser holding a valid join token
+         * could request a PlainTransport pointed at an address of its choosing -
+         * an RTP reflector, plus an unauthenticated publish path into whatever room
+         * the token names. Three phases independently needed to refuse that and
+         * none could, because nothing carried the fact.
+         *
+         * So there is no field here to refuse. The claim decides.
+         */
+        sctp: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("connectTransport"),
+        id: zod_1.z.number().int().nonnegative(),
+        transportId: zod_1.z.string(),
+        /** WebRTC. */
+        dtlsParameters: zod_1.z.unknown().optional(),
+        /**
+         * Plain and pipe transports have no DTLS handshake to carry the address, so
+         * a server-side participant names where its RTP comes from. This is the
+         * half the token claim cannot cover: the claim says WHO may create a plain
+         * transport, and `MEDIA_SERVER_PEER_CIDRS` says WHERE its media may be
+         * pointed. Both are required; either alone leaves a reflector.
+         */
+        ip: zod_1.z.string().optional(),
+        port: zod_1.z.number().int().positive().max(65535).optional(),
+        rtcpPort: zod_1.z.number().int().positive().max(65535).optional(),
+        srtpParameters: zod_1.z.unknown().optional(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("produce"),
+        id: zod_1.z.number().int().nonnegative(),
+        transportId: zod_1.z.string(),
+        kind: zod_1.z.enum(["audio", "video"]),
+        /** Opaque to this package: only mediasoup interprets it. */
+        rtpParameters: zod_1.z.unknown(),
+        appData: zod_1.z.record(zod_1.z.unknown()).optional(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("consume"),
+        id: zod_1.z.number().int().nonnegative(),
+        transportId: zod_1.z.string(),
+        producerId: zod_1.z.string(),
+        rtpCapabilities: zod_1.z.unknown(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("pauseProducer"),
+        id: zod_1.z.number().int().nonnegative(),
+        producerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("resumeProducer"),
+        id: zod_1.z.number().int().nonnegative(),
+        producerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("resumeConsumer"),
+        id: zod_1.z.number().int().nonnegative(),
+        consumerId: zod_1.z.string(),
+    }),
+    /**
+     * Drop a subscription.
+     *
+     * Needed because the active set CHURNS: as the conversation moves, a client
+     * following it stops wanting producers it wanted a moment ago. Closing only
+     * the client's own consumer leaves the node holding a Consumer object per
+     * dropped subscription, and in a large room that accumulates for the life of
+     * the call - on the node, which is the side with the ceiling.
+     */
+    zod_1.z.object({
+        method: zod_1.z.literal("closeConsumer"),
+        id: zod_1.z.number().int().nonnegative(),
+        consumerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("closeProducer"),
+        id: zod_1.z.number().int().nonnegative(),
+        producerId: zod_1.z.string(),
+    }),
+    /** A keyframe request. Without it every active-speaker switch shows garbage
+     * until the encoder happens to send one. */
+    zod_1.z.object({
+        method: zod_1.z.literal("requestKeyFrame"),
+        id: zod_1.z.number().int().nonnegative(),
+        consumerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({ method: zod_1.z.literal("leave"), id: zod_1.z.number().int().nonnegative() }),
+]);
+exports.responseFrameSchema = zod_1.z.union([
+    zod_1.z.object({ id: zod_1.z.number().int().nonnegative(), ok: zod_1.z.literal(true), data: zod_1.z.unknown() }),
+    zod_1.z.object({
+        id: zod_1.z.number().int().nonnegative(),
+        ok: zod_1.z.literal(false),
+        /** The client sees a CODE, never why a token was refused. Telling a caller
+         * whether the signature or the room was wrong turns this into an oracle. */
+        code: errorSchema_1.mediaErrorCodeSchema,
+        message: zod_1.z.string().optional(),
+    }),
+]);
+/** A participant as everyone else sees them. Grants are NOT included: what
+ * someone else is permitted to do is not the room's business. */
+exports.peerSchema = zod_1.z.object({
+    identity: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    kind: grants_1.participantKindSchema,
+});
+exports.eventFrameSchema = zod_1.z.discriminatedUnion("event", [
+    zod_1.z.object({
+        event: zod_1.z.literal("joined"),
+        identity: zod_1.z.string(),
+        room: zod_1.z.string(),
+        /** Everything the client needs to build its device before any transport. */
+        routerRtpCapabilities: zod_1.z.unknown(),
+        peers: zod_1.z.array(exports.peerSchema),
+        /** Producers this participant is ALLOWED to see. The barrier is applied to
+         * the snapshot, not only at consume: an identity it may not receive must
+         * not be discoverable either. */
+        producers: zod_1.z.array(zod_1.z.object({ producerId: zod_1.z.string(), identity: zod_1.z.string(), kind: zod_1.z.enum(["audio", "video"]) })),
+        iceServers: zod_1.z.array(zod_1.z.object({ urls: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]), username: zod_1.z.string().optional(), credential: zod_1.z.string().optional() })),
+        /** True while any `kind: "egress"` participant is present. A consent
+         * requirement, not a nicety. */
+        recording: zod_1.z.boolean(),
+        /**
+         * What this token was minted with, echoed back.
+         *
+         * The client already holds the token but must not parse it: a signed blob
+         * a client reads is a signed blob a client eventually trusts its own
+         * reading of. This is the node's understanding of the grants, which is the
+         * one that will actually be enforced, so a UI built from it cannot offer a
+         * control the node is about to refuse.
+         */
+        grants: grants_1.mediaGrantsSchema.optional(),
+    }),
+    zod_1.z.object({ event: zod_1.z.literal("peerJoined"), peer: exports.peerSchema }),
+    zod_1.z.object({ event: zod_1.z.literal("peerLeft"), identity: zod_1.z.string() }),
+    zod_1.z.object({
+        event: zod_1.z.literal("producerAppeared"),
+        producerId: zod_1.z.string(),
+        identity: zod_1.z.string(),
+        kind: zod_1.z.enum(["audio", "video"]),
+    }),
+    zod_1.z.object({ event: zod_1.z.literal("producerClosed"), producerId: zod_1.z.string() }),
+    zod_1.z.object({ event: zod_1.z.literal("producerPaused"), producerId: zod_1.z.string(), paused: zod_1.z.boolean() }),
+    /**
+     * The active set the node wants this client to consume. How a 1,000-person
+     * room stays survivable: the server decides, the client follows.
+     *
+     * `producerIds` is the whole set and is what a simple client renders.
+     * `audio` and `video` are the same set split, because the two limits differ
+     * (you can follow more voices than you can fit faces). `enforced` says
+     * whether a consume outside the set will actually be REFUSED - below the
+     * threshold the set is advisory and a client that ignores it is not wrong.
+     *
+     * `speakers` carries the ordering and the levels, which is what drives a
+     * layout switch and a level meter. Ordered loudest first.
+     */
+    zod_1.z.object({
+        event: zod_1.z.literal("activeSpeakers"),
+        producerIds: zod_1.z.array(zod_1.z.string()),
+        audio: zod_1.z.array(zod_1.z.string()).optional(),
+        video: zod_1.z.array(zod_1.z.string()).optional(),
+        enforced: zod_1.z.boolean().optional(),
+        speakers: zod_1.z
+            .array(zod_1.z.object({ identity: zod_1.z.string(), producerId: zod_1.z.string(), volumeDb: zod_1.z.number() }))
+            .optional(),
+    }),
+    zod_1.z.object({ event: zod_1.z.literal("recordingChanged"), recording: zod_1.z.boolean() }),
+    /** This node is going away. Reconnect through MEDIA_URL; do not retry here. */
+    zod_1.z.object({ event: zod_1.z.literal("draining"), reconnectAfterMs: zod_1.z.number().int().nonnegative() }),
+    zod_1.z.object({ event: zod_1.z.literal("roomClosed"), reason: zod_1.z.string() }),
+    /** Barrier changes are pushed, because a rule that only applies at join is a
+     * rule that does not apply to anyone already in the room. */
+    zod_1.z.object({ event: zod_1.z.literal("subscribeRuleChanged"), subscribe: grants_1.subscribeRuleSchema }),
+]);
+/** Anything arriving from a node. */
+exports.serverFrameSchema = zod_1.z.union([exports.responseFrameSchema, exports.eventFrameSchema]);
+const isEvent = (frame) => "event" in frame;
+exports.isEvent = isEvent;
+//# sourceMappingURL=frames.js.map

package/build/frames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.js","sourceRoot":"","sources":["../src/frames.ts"],"names":[],"mappings":"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"}

package/build/grants.d.ts

@@ -0,0 +1,307 @@
+import { z } from "zod";
+/**
+ * What a participant is allowed to do, and - the part that matters most - who
+ * they may receive.
+ *
+ * ## Why the schema is `.strict()`
+ *
+ * This is the single line that stops the information barrier failing open.
+ *
+ * Ten phase plans were written in parallel and two of them disagreed on a name:
+ * one minted `grants.subscribeOnly`, the other read `grants.subscribe`. The
+ * reader would have found nothing, applied its documented default ("an absent
+ * rule means everyone"), and two Mandanten in one room would have received each
+ * other with nothing anywhere erroring. That is a §203 incident whose start
+ * date is unrecoverable from logs.
+ *
+ * `.strict()` turns that class of mistake from silent permissiveness into a
+ * loud verification failure: a token carrying an unknown grant key is rejected
+ * with `bad_claims` rather than partially understood. Any future rename fails
+ * the same way, at mint time, in a test.
+ */
+/**
+ * Who a participant may receive, or be received by.
+ *
+ * A boolean cannot express an information barrier. "A and B are in one room and
+ * must not receive each other, while C may receive both" is the actual
+ * requirement for a Kanzlei, and it is a per-identity rule rather than a
+ * per-room one.
+ */
+export declare const subscribeRuleSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"all">;
+}, "strict", z.ZodTypeAny, {
+    mode: "all";
+}, {
+    mode: "all";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"none">;
+}, "strict", z.ZodTypeAny, {
+    mode: "none";
+}, {
+    mode: "none";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"allow">;
+    identities: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    mode: "allow";
+    identities: string[];
+}, {
+    mode: "allow";
+    identities: string[];
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"deny">;
+    identities: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    mode: "deny";
+    identities: string[];
+}, {
+    mode: "deny";
+    identities: string[];
+}>]>;
+export type SubscribeRule = z.infer<typeof subscribeRuleSchema>;
+export declare const participantKindSchema: z.ZodEnum<["human", "agent", "egress", "sip", "ingress"]>;
+export type ParticipantKind = z.infer<typeof participantKindSchema>;
+/**
+ * Transport authority is NOT media authority, which is why this is its own
+ * claim rather than something inferred from `kind`.
+ *
+ * A browser holding a perfectly valid join token must not be able to ask for a
+ * `PlainTransport` pointed at an address of its choosing. That is an RTP
+ * reflector and an unauthenticated publish path into whatever room the token
+ * names. Three phases independently needed to refuse it and none could, because
+ * nothing carried the fact.
+ */
+export declare const transportKindSchema: z.ZodEnum<["webrtc", "plain", "pipe"]>;
+export type TransportKind = z.infer<typeof transportKindSchema>;
+/**
+ * The two vocabularies, and the ONE place they are reconciled.
+ *
+ * A grant is written in kinds - "audio", "video", "screen" - because that is
+ * what a person minting a token thinks in: may this seat talk, may it be seen,
+ * may it present. A publisher labels its track with a SOURCE, because that is
+ * what it knows and what the other side renders: "microphone", "camera",
+ * "screen", "rtmp". The two lists overlap on one word and disagree on the rest.
+ *
+ * That disagreement shipped as a defect. The node compared the declared source
+ * against `publishKinds` directly, so a booking token minted with the full
+ * `["audio", "video", "screen"]` refused every microphone and every camera the
+ * browser SDK offered it - "microphone" is not in the list - and the only thing
+ * a coaching call could publish was a screen share. It refused the RTMP ingress
+ * for the same reason, whose source is "rtmp".
+ *
+ * So the translation lives here, next to the schema that creates the need for
+ * it, and both the node and the UI read it. An unrecognised source falls back to
+ * the TRACK's kind, which is a fact about the media rather than a claim: that is
+ * what lets a new source ("rtmp") work without a protocol change while a token
+ * granting audio only still cannot send video by inventing a label for it. The
+ * one thing a client can never do is send a screen share on an audio-or-video
+ * grant, because "screen" is only ever reachable by declaring it.
+ *
+ * ## A declaration is only honoured when the track could carry it
+ *
+ * The label is the client's claim; the track's kind is a fact mediasoup already
+ * knows. Translating the claim UNCONDITIONALLY made the claim outrank the fact,
+ * which is the bypass restated: `{ source: "microphone", kind: "video" }`
+ * resolved to "audio", so a seat minted `publishKinds: ["audio"]` published a
+ * camera and the node created a video producer with the real kind. The two
+ * audio-only grants in the product are a SIP gateway and an assistant runtime,
+ * and `publishKinds` is precisely the claim that has to survive the holder being
+ * compromised.
+ *
+ * So a source is translated only when it can actually carry the track in hand
+ * (a microphone carries audio, a camera carries video, a screen share carries
+ * either, because a shared window may bring system audio with it). A declaration
+ * the track contradicts is not a translation, it is a relabelling, and it is
+ * discarded in favour of the fact.
+ */
+export declare const publishKindSchema: z.ZodEnum<["audio", "video", "screen"]>;
+export type PublishKind = z.infer<typeof publishKindSchema>;
+/** The sources the browser SDK publishes with. Others are legal on the wire. */
+export declare const publishSourceSchema: z.ZodEnum<["microphone", "camera", "screen"]>;
+export type PublishSource = z.infer<typeof publishSourceSchema>;
+/** Which grant a publish needs, from what it declares and what it carries. */
+export declare function requiredPublishKind(source: string | undefined, trackKind: "audio" | "video"): PublishKind;
+/**
+ * May this token publish this? The node's decision, and the UI's hint, from one
+ * function so the button and the enforcement cannot disagree.
+ */
+export declare function mayPublish(grants: MediaGrants | undefined, input: {
+    source: string | undefined;
+    trackKind: "audio" | "video";
+}): boolean;
+export declare const mediaGrantsSchema: z.ZodObject<{
+    canPublish: z.ZodBoolean;
+    canSubscribe: z.ZodBoolean;
+    canPublishData: z.ZodBoolean;
+    /** Who I may receive. Omitted means `{ mode: "all" }`. */
+    subscribe: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"all">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "all";
+    }, {
+        mode: "all";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "none";
+    }, {
+        mode: "none";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"allow">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "allow";
+        identities: string[];
+    }, {
+        mode: "allow";
+        identities: string[];
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"deny">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "deny";
+        identities: string[];
+    }, {
+        mode: "deny";
+        identities: string[];
+    }>]>>;
+    /**
+     * Who may receive ME. Enforced on the PRODUCER side from the owner's stored
+     * grants, so a barrier holds even if the other party's token is generous.
+     */
+    visibleTo: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"all">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "all";
+    }, {
+        mode: "all";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "none";
+    }, {
+        mode: "none";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"allow">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "allow";
+        identities: string[];
+    }, {
+        mode: "allow";
+        identities: string[];
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"deny">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "deny";
+        identities: string[];
+    }, {
+        mode: "deny";
+        identities: string[];
+    }>]>>;
+    /**
+     * Which kinds of media this token may send, in the vocabulary of
+     * `publishKindSchema`. A publisher labels its track with a SOURCE
+     * ("microphone", "camera", "screen", "rtmp", ...) and those are not the same
+     * words: `requiredPublishKind` below is the one translation between them.
+     */
+    publishKinds: z.ZodOptional<z.ZodArray<z.ZodEnum<["audio", "video", "screen"]>, "many">>;
+    /**
+     * Bypasses the top-N active-speaker refusal. Mintable ONLY for a non-human
+     * kind: a recorder needs every track, a human asking for 1,000 does not.
+     */
+    subscribeExempt: z.ZodOptional<z.ZodBoolean>;
+    /** Hard ceiling on concurrent consumers, for a non-human participant. */
+    maxSubscriptions: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    canPublish: boolean;
+    canSubscribe: boolean;
+    canPublishData: boolean;
+    subscribe?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    visibleTo?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    publishKinds?: ("audio" | "video" | "screen")[] | undefined;
+    subscribeExempt?: boolean | undefined;
+    maxSubscriptions?: number | undefined;
+}, {
+    canPublish: boolean;
+    canSubscribe: boolean;
+    canPublishData: boolean;
+    subscribe?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    visibleTo?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    publishKinds?: ("audio" | "video" | "screen")[] | undefined;
+    subscribeExempt?: boolean | undefined;
+    maxSubscriptions?: number | undefined;
+}>;
+export type MediaGrants = z.infer<typeof mediaGrantsSchema>;
+/**
+ * May `consumer` receive `producer`? Two-sided, and deny wins.
+ *
+ * One-sided is not enough. If only the consumer's rule were consulted, a
+ * participant whose own token was minted generously could receive someone who
+ * had been explicitly walled off from them. So the producer's `visibleTo` is
+ * checked from the OWNER's stored grants, not from anything the consumer
+ * presents.
+ *
+ * **An unreadable owner is `false`.** If the producer's grants cannot be found,
+ * this refuses rather than falling through to the permissive default. A missing
+ * record is exactly the state a race or a partial failure produces, and in a
+ * room with an information barrier the safe reading of "I do not know" is "no".
+ * Note this differs deliberately from an ABSENT RULE on a record that WAS
+ * found, which means everyone.
+ */
+export declare function maySubscribe(input: {
+    consumerIdentity: string;
+    consumerGrants: MediaGrants;
+    producerIdentity: string;
+    /** `undefined` when the owner's record could not be read. */
+    ownerGrants: MediaGrants | undefined;
+}): boolean;
+/**
+ * `subscribeExempt` and `maxSubscriptions` are meaningless for a human and
+ * dangerous if mintable for one: exemption is what lets a recorder take every
+ * track, and a human with it can pull a thousand streams through a node.
+ * Checked at MINT time so a bad token never exists.
+ */
+export declare function grantsAreValidForKind(grants: MediaGrants, kind: ParticipantKind): true | string;
+//# sourceMappingURL=grants.d.ts.map

package/build/grants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grants.d.ts","sourceRoot":"","sources":["../src/grants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,qBAAqB,2DAAyD,CAAC;AAC5F,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,wCAAsC,CAAC;AACvE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,iBAAiB,yCAAuC,CAAC;AACtE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,+CAA6C,CAAC;AAC9E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAqBhE,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,GAAG,WAAW,CASzG;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAAA;CAAE,GAClE,OAAO,CAIT;AAED,eAAO,MAAM,iBAAiB;;;;IAK1B,0DAA0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE1D;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;OAKG;;IAEH;;;OAGG;;IAEH,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlE,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAmB5D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,WAAW,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;CACtC,GAAG,OAAO,CAUV;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,GAAG,MAAM,CAW/F"}