@rapidmx/meet-plugin 0.6.0 → 0.8.1

package/dist/apps/shared/webrtc/MeshConnectionManager.d.ts

@@ -28,7 +28,7 @@
  * ## Join announcement and roster discovery
  *
  * The channel has no history (a push event published while a socket was down is never replayed - see
- * `@rapidmx/react-shared`'s `pushClient.ts` doc comment for the identical guarantee on the mail push channel this
+ * `@rapidmx/web-client`'s `lib/mail/pushClient.ts` doc comment for the identical guarantee on the mail push channel this
  * one shares its transport with), so a newcomer's `hello` would only reach participants who happened to already be
  * subscribed *and* who joined before them - never the other way around. Every participant who learns of a
  * genuinely new peer (from any message, not just `hello`) therefore echoes its own `hello` right back, once, the
@@ -57,10 +57,37 @@
  * `presenter-release`) once it observes the winning claim. See `handlePresenterClaim()`.
  *
  * Sharing a screen is `setLocalTrack("video", screenTrack)`; stopping is `setLocalTrack("video", cameraTrack)`.
+ *
+ * ## Three media paths, tried in order
+ *
+ * Each pair of participants reaches for the best path that works, and `MeshParticipant.transport` says which one it
+ * got:
+ *
+ * 1. **Direct peer-to-peer** (`"p2p"`). The `RTCPeerConnection` is given the STUN servers and the TURN server
+ * together, and ICE ranks a direct pair above a relayed one, so this is what a pair gets whenever it can.
+ * 2. **Relayed through the TURN server** (`"turn"`). The same connection, on the relay candidate ICE falls back to
+ * when the direct pairs fail - a participant behind a symmetric NAT or a firewall that blocks direct UDP. Which of
+ * the two ICE picked is read from the selected candidate pair once connected (`RTCPeerConnectionLike.connectionType()`).
+ * 3. **Proxied by this server over a WebSocket** (`"websocket"`, `apps/shared/relay/`). For a participant whose
+ * network lets nothing but ordinary HTTPS out, neither of the above ever connects. A pair whose connection has not
+ * come up within `connectTimeoutMs`, has failed, or has stayed `disconnected` for `disconnectedGraceMs` gives up
+ * on WebRTC and switches to it, telling the other side with a `relay-fallback` message so both switch even when
+ * only one of them noticed. Nothing is renegotiated - the pair simply stops using the `RTCPeerConnection` - and the
+ * relay's stream replaces the one WebRTC would have filled (a `remote-stream` event again). When the relay is
+ * unavailable (turned off by the operator, or a browser without WebCodecs) the pair is marked `"failed"` and stays
+ * in the roster, rather than the participant vanishing with no explanation as it used to.
+ *
+ * A pair never moves back up: once on the relay it stays there for the rest of the call.
  */
-import { type MeshEvent, type MeshParticipant, type ParticipantState, type RTCPeerConnectionFactory, type SignalingChannel } from "./types.js";
+import { type MeshEvent, type MeshParticipant, type ParticipantState, type RTCPeerConnectionFactory, type RelayTransportLike, type SignalingChannel } from "./types.js";
 /** The lexicographically smaller uid is always the offerer for that pair - see this module's doc comment. */
 export declare function isOfferer(selfId: string, peerId: string): boolean;
+/** How long a connection may stay in `connecting` before the pair gives up on WebRTC. ICE with an unreachable TURN
+ * server can take the better part of a minute to report `failed`; a person waiting on a call will not. It is still long
+ * enough for a slow TURN allocation and a few round trips of signaling. */
+export declare const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
+/** How long a connection may stay `disconnected` (ICE lost the path but may still recover) before giving up on it. */
+export declare const DEFAULT_DISCONNECTED_GRACE_MS = 8000;
 type MediaKind = "audio" | "video";
 export interface MeshConnectionManagerOptions {
     /** The authenticated uid - what `from` must be on the wire (see `SignalMessage.from`). */
@@ -81,6 +108,13 @@ export interface MeshConnectionManagerOptions {
     /** Builds the (initially empty) stream one peer's incoming tracks are gathered into. Defaults to
      * `new MediaStream()`; a test supplies a fake. */
     createMediaStream?: () => MediaStream;
+    /** The WebSocket media relay, the last-resort path - see this module's doc comment. Leave unset when the
+     * operator has turned it off; without one a pair WebRTC cannot connect is marked `"failed"`. */
+    relay?: RelayTransportLike;
+    /** Defaults to `DEFAULT_CONNECT_TIMEOUT_MS`. */
+    connectTimeoutMs?: number;
+    /** Defaults to `DEFAULT_DISCONNECTED_GRACE_MS`. */
+    disconnectedGraceMs?: number;
 }
 export declare class MeshConnectionManager {
     private readonly options;
@@ -131,6 +165,22 @@ export declare class MeshConnectionManager {
     private updatePeer;
     private handleBye;
     private createPeer;
+    /** Reacts to the peer connection's state: notes which path a connected pair got, and gives up on WebRTC for a
+     * pair that failed or stays disconnected - see `fallBack()`. Ignores a pair that already left WebRTC. */
+    private handleConnectionState;
+    /** Records whether a connected pair is direct or relayed through TURN, from the candidate pair ICE selected. */
+    private detectTransport;
+    private setTransport;
+    private clearTimers;
+    /**
+     * Gives up on WebRTC for `peer` and moves the pair to the WebSocket relay (the third path - see this module's doc
+     * comment), or marks it `"failed"` when there is no relay to move to. `notify` tells the other side, which may not
+     * have noticed yet; a pair told by the other side does not tell it back.
+     */
+    private fallBack;
+    private handleRelayFallback;
+    /** The relay only encodes and uploads the local media while at least one pair is actually using it. */
+    private syncRelaySending;
     private initiateOffer;
     private handleOffer;
     private handleAnswer;

package/dist/apps/shared/webrtc/MeshConnectionManager.js

@@ -32,7 +32,7 @@
  * ## Join announcement and roster discovery
  *
  * The channel has no history (a push event published while a socket was down is never replayed - see
- * `@rapidmx/react-shared`'s `pushClient.ts` doc comment for the identical guarantee on the mail push channel this
+ * `@rapidmx/web-client`'s `lib/mail/pushClient.ts` doc comment for the identical guarantee on the mail push channel this
  * one shares its transport with), so a newcomer's `hello` would only reach participants who happened to already be
  * subscribed *and* who joined before them - never the other way around. Every participant who learns of a
  * genuinely new peer (from any message, not just `hello`) therefore echoes its own `hello` right back, once, the
@@ -61,6 +61,27 @@
  * `presenter-release`) once it observes the winning claim. See `handlePresenterClaim()`.
  *
  * Sharing a screen is `setLocalTrack("video", screenTrack)`; stopping is `setLocalTrack("video", cameraTrack)`.
+ *
+ * ## Three media paths, tried in order
+ *
+ * Each pair of participants reaches for the best path that works, and `MeshParticipant.transport` says which one it
+ * got:
+ *
+ * 1. **Direct peer-to-peer** (`"p2p"`). The `RTCPeerConnection` is given the STUN servers and the TURN server
+ * together, and ICE ranks a direct pair above a relayed one, so this is what a pair gets whenever it can.
+ * 2. **Relayed through the TURN server** (`"turn"`). The same connection, on the relay candidate ICE falls back to
+ * when the direct pairs fail - a participant behind a symmetric NAT or a firewall that blocks direct UDP. Which of
+ * the two ICE picked is read from the selected candidate pair once connected (`RTCPeerConnectionLike.connectionType()`).
+ * 3. **Proxied by this server over a WebSocket** (`"websocket"`, `apps/shared/relay/`). For a participant whose
+ * network lets nothing but ordinary HTTPS out, neither of the above ever connects. A pair whose connection has not
+ * come up within `connectTimeoutMs`, has failed, or has stayed `disconnected` for `disconnectedGraceMs` gives up
+ * on WebRTC and switches to it, telling the other side with a `relay-fallback` message so both switch even when
+ * only one of them noticed. Nothing is renegotiated - the pair simply stops using the `RTCPeerConnection` - and the
+ * relay's stream replaces the one WebRTC would have filled (a `remote-stream` event again). When the relay is
+ * unavailable (turned off by the operator, or a browser without WebCodecs) the pair is marked `"failed"` and stays
+ * in the roster, rather than the participant vanishing with no explanation as it used to.
+ *
+ * A pair never moves back up: once on the relay it stays there for the rest of the call.
  */
 import { REACTION_EMOJIS, } from "./types.js";
 /** The lexicographically smaller uid is always the offerer for that pair - see this module's doc comment. */
@@ -71,6 +92,12 @@ export function isOfferer(selfId, peerId) {
  * misbehaving participant could make this hold for peers that never materialize. */
 const MAX_ORPHAN_PEERS = 32;
 const MAX_ORPHAN_CANDIDATES = 64;
+/** How long a connection may stay in `connecting` before the pair gives up on WebRTC. ICE with an unreachable TURN
+ * server can take the better part of a minute to report `failed`; a person waiting on a call will not. It is still long
+ * enough for a slow TURN allocation and a few round trips of signaling. */
+export const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
+/** How long a connection may stay `disconnected` (ICE lost the path but may still recover) before giving up on it. */
+export const DEFAULT_DISCONNECTED_GRACE_MS = 8000;
 export class MeshConnectionManager {
     constructor(options) {
         this.options = options;
@@ -87,6 +114,8 @@ export class MeshConnectionManager {
             handRaised: false,
             ...options.localState,
         };
+        options.relay?.setLocalTrack("audio", this.localTracks.audio);
+        options.relay?.setLocalTrack("video", this.localTracks.video);
     }
     get participants() {
         return [...this.peers.values()].map((peer) => toParticipant(peer));
@@ -122,11 +151,13 @@ export class MeshConnectionManager {
         this.unsubscribe?.();
         this.unsubscribe = undefined;
         for (const peer of this.peers.values()) {
+            this.clearTimers(peer);
             peer.pc.close();
         }
         this.peers.clear();
         this.orphanCandidates.clear();
         this.listeners.clear();
+        this.options.relay?.close();
     }
     /** Sets the track sent as `kind` (`null` to send nothing) on every connection, now and for every peer that
      * joins later - see this module's doc comment. */
@@ -135,6 +166,7 @@ export class MeshConnectionManager {
         for (const peer of this.peers.values()) {
             void peer.senders[kind]?.replaceTrack(track);
         }
+        this.options.relay?.setLocalTrack(kind, track);
     }
     /** Updates what this participant announces (`audioOn`/`videoOn`/`handRaised`) and tells everyone if anything
      * actually changed. Before `start()` it only records the state, which `hello` then carries. */
@@ -231,6 +263,9 @@ export class MeshConnectionManager {
             case "reaction":
                 this.handleReaction(message);
                 return;
+            case "relay-fallback":
+                this.handleRelayFallback(message.from);
+                return;
         }
     }
     handleHello(message) {
@@ -288,8 +323,13 @@ export class MeshConnectionManager {
         if (!peer) {
             return;
         }
+        this.clearTimers(peer);
         peer.pc.close();
         this.peers.delete(uid);
+        if (peer.transport === "websocket") {
+            this.options.relay?.stopReceivingFrom(uid);
+            this.syncRelaySending();
+        }
         this.emit({ type: "participant-left", uid });
         if (this.currentPresenterUid === uid) {
             this.currentPresenterUid = undefined;
@@ -312,6 +352,9 @@ export class MeshConnectionManager {
             remoteStream: (this.options.createMediaStream ?? (() => new MediaStream()))(),
             remoteDescriptionSet: false,
             pendingCandidates: this.orphanCandidates.get(uid) ?? [],
+            transport: "connecting",
+            connectTimer: undefined,
+            disconnectTimer: undefined,
         };
         this.orphanCandidates.delete(uid);
         this.peers.set(uid, peer);
@@ -326,13 +369,101 @@ export class MeshConnectionManager {
             }
             this.emit({ type: "remote-stream", uid, stream: peer.remoteStream });
         };
-        pc.onconnectionstatechange = () => {
-            if (pc.connectionState === "failed" || pc.connectionState === "closed") {
-                this.handleBye(uid);
-            }
-        };
+        pc.onconnectionstatechange = () => this.handleConnectionState(peer);
+        // Cleared the moment the connection comes up, so this only ever fires for a pair still waiting on WebRTC.
+        peer.connectTimer = setTimeout(() => this.fallBack(peer), this.options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
         return peer;
     }
+    /** Reacts to the peer connection's state: notes which path a connected pair got, and gives up on WebRTC for a
+     * pair that failed or stays disconnected - see `fallBack()`. Ignores a pair that already left WebRTC. */
+    handleConnectionState(peer) {
+        if (peer.transport === "websocket" || this.peers.get(peer.uid) !== peer) {
+            return;
+        }
+        switch (peer.pc.connectionState) {
+            case "connected":
+                this.clearTimers(peer);
+                void this.detectTransport(peer);
+                return;
+            case "disconnected":
+                // ICE often recovers from this on its own, so it is only given up on after a grace period.
+                peer.disconnectTimer ?? (peer.disconnectTimer = setTimeout(() => this.fallBack(peer), this.options.disconnectedGraceMs ?? DEFAULT_DISCONNECTED_GRACE_MS));
+                return;
+            case "failed":
+                this.fallBack(peer);
+                return;
+            case "closed":
+                this.handleBye(peer.uid);
+                return;
+        }
+    }
+    /** Records whether a connected pair is direct or relayed through TURN, from the candidate pair ICE selected. */
+    async detectTransport(peer) {
+        let type;
+        try {
+            type = await peer.pc.connectionType();
+        }
+        catch {
+            type = "unknown";
+        }
+        // The pair may have moved on (fallen back, left, or dropped again) while the stats were being read.
+        if (peer.transport !== "websocket" && this.peers.get(peer.uid) === peer && peer.pc.connectionState === "connected") {
+            this.setTransport(peer, type === "turn" ? "turn" : "p2p");
+        }
+    }
+    setTransport(peer, transport) {
+        if (peer.transport !== transport) {
+            peer.transport = transport;
+            this.emit({ type: "participant-updated", participant: toParticipant(peer) });
+        }
+    }
+    clearTimers(peer) {
+        clearTimeout(peer.connectTimer);
+        clearTimeout(peer.disconnectTimer);
+        peer.connectTimer = undefined;
+        peer.disconnectTimer = undefined;
+    }
+    /**
+     * Gives up on WebRTC for `peer` and moves the pair to the WebSocket relay (the third path - see this module's doc
+     * comment), or marks it `"failed"` when there is no relay to move to. `notify` tells the other side, which may not
+     * have noticed yet; a pair told by the other side does not tell it back.
+     */
+    fallBack(peer, notify = true) {
+        if (peer.transport === "websocket" || this.peers.get(peer.uid) !== peer) {
+            return;
+        }
+        this.clearTimers(peer);
+        const relay = this.options.relay;
+        if (!relay?.supported) {
+            this.setTransport(peer, "failed");
+            return;
+        }
+        // Stop listening to the dead connection before closing it, so closing it cannot be mistaken for the peer leaving.
+        peer.pc.onconnectionstatechange = null;
+        peer.pc.onicecandidate = null;
+        peer.pc.ontrack = null;
+        peer.pc.close();
+        peer.transport = "websocket";
+        relay.receiveFrom(peer.uid, (stream) => {
+            peer.remoteStream = stream;
+            this.emit({ type: "remote-stream", uid: peer.uid, stream });
+        });
+        this.syncRelaySending();
+        this.emit({ type: "participant-updated", participant: toParticipant(peer) });
+        if (notify) {
+            this.send({ kind: "relay-fallback", to: peer.uid });
+        }
+    }
+    handleRelayFallback(from) {
+        const peer = this.peers.get(from);
+        if (peer) {
+            this.fallBack(peer, false);
+        }
+    }
+    /** The relay only encodes and uploads the local media while at least one pair is actually using it. */
+    syncRelaySending() {
+        this.options.relay?.setSending([...this.peers.values()].some((peer) => peer.transport === "websocket"));
+    }
     async initiateOffer(peer) {
         const offer = await peer.pc.createOffer();
         await peer.pc.setLocalDescription(offer);
@@ -438,7 +569,7 @@ export class MeshConnectionManager {
     }
 }
 function toParticipant(peer) {
-    return { uid: peer.uid, name: peer.name, audioOn: peer.audioOn, videoOn: peer.videoOn, handRaised: peer.handRaised };
+    return { uid: peer.uid, name: peer.name, audioOn: peer.audioOn, videoOn: peer.videoOn, handRaised: peer.handRaised, transport: peer.transport };
 }
 function sameState(a, b) {
     return a.audioOn === b.audioOn && a.videoOn === b.videoOn && a.handRaised === b.handRaised;

package/dist/apps/shared/webrtc/realPeerConnection.d.ts

@@ -4,4 +4,11 @@
  * module scope, so importing this file is safe during this plugin's page SSR, where `RTCPeerConnection` does not
  * exist at all - it would only throw if actually *called* outside a browser. */
 import type { RTCPeerConnectionFactory } from "./types.js";
+/**
+ * Whether the pair ICE settled on goes through a TURN relay. The selected pair is found the standard way (the
+ * `transport` report's `selectedCandidatePairId`) and, for a browser that does not fill that in, as the succeeded and
+ * nominated `candidate-pair`. A relay on *either* end means the media passes through a TURN server, so it counts as
+ * `"turn"`; `"unknown"` when no pair is reported at all.
+ */
+export declare function selectedConnectionType(pc: Pick<RTCPeerConnection, "getStats">): Promise<"p2p" | "turn" | "unknown">;
 export declare const createBrowserPeerConnection: RTCPeerConnectionFactory;

package/dist/apps/shared/webrtc/realPeerConnection.js

@@ -1,3 +1,22 @@
+/**
+ * Whether the pair ICE settled on goes through a TURN relay. The selected pair is found the standard way (the
+ * `transport` report's `selectedCandidatePairId`) and, for a browser that does not fill that in, as the succeeded and
+ * nominated `candidate-pair`. A relay on *either* end means the media passes through a TURN server, so it counts as
+ * `"turn"`; `"unknown"` when no pair is reported at all.
+ */
+export async function selectedConnectionType(pc) {
+    const reports = new Map();
+    (await pc.getStats()).forEach((report) => reports.set(String(report.id), report));
+    const transport = [...reports.values()].find((report) => report.type === "transport" && report.selectedCandidatePairId);
+    const pair = (transport ? reports.get(String(transport.selectedCandidatePairId)) : undefined) ??
+        [...reports.values()].find((report) => report.type === "candidate-pair" && (report.selected || (report.nominated && report.state === "succeeded")));
+    if (!pair) {
+        return "unknown";
+    }
+    const local = reports.get(String(pair.localCandidateId));
+    const remote = reports.get(String(pair.remoteCandidateId));
+    return local?.candidateType === "relay" || remote?.candidateType === "relay" ? "turn" : "p2p";
+}
 export const createBrowserPeerConnection = (config) => {
     const pc = new RTCPeerConnection(config);
     const like = {
@@ -22,6 +41,7 @@ export const createBrowserPeerConnection = (config) => {
         setRemoteDescription: (description) => pc.setRemoteDescription(description),
         addIceCandidate: (candidate) => pc.addIceCandidate(candidate),
         close: () => pc.close(),
+        connectionType: () => selectedConnectionType(pc),
         onicecandidate: null,
         ontrack: null,
         onconnectionstatechange: null,

package/dist/apps/shared/webrtc/types.d.ts

@@ -28,7 +28,7 @@ export declare const REACTION_EMOJIS: readonly ["👍", "👏", "❤️", "🎉"
  */
 export interface SignalMessage {
     type: "video-meeting-signal";
-    kind: "hello" | "bye" | "offer" | "answer" | "ice-candidate" | "presenter-claim" | "presenter-release" | "state" | "reaction";
+    kind: "hello" | "bye" | "offer" | "answer" | "ice-candidate" | "presenter-claim" | "presenter-release" | "state" | "reaction" | "relay-fallback";
     /** The sender's authenticated uid - the real caller's own uid when `join()` returned `authenticated: true`, else
      * the `guest:<random>` uid `BaseVideoMeetingRoute.join()` minted. The server refuses a published message whose
      * `from` isn't the authenticated caller's uid (it stops one participant speaking as another), so this must be
@@ -39,7 +39,7 @@ export interface SignalMessage {
      * ignored, so it can't name someone else's tab. Absent from a sender that predates it (the participant is then
      * identified by `from`). */
     peer?: string;
-    /** Set only on a point-to-point message (`offer`/`answer`/`ice-candidate`). */
+    /** Set only on a point-to-point message (`offer`/`answer`/`ice-candidate`/`relay-fallback`). */
     to?: string;
     /** `hello` only - the display name the sender chose in the lobby. */
     name?: string;
@@ -99,6 +99,31 @@ export interface RTCPeerConnectionLike {
     }) => void) | null;
     onconnectionstatechange: (() => void) | null;
     connectionState: string;
+    /** Which path the connected pair is using - read from the selected candidate pair once `connectionState` is
+     * `connected`. `"unknown"` when the browser does not report one (treated as direct by the caller). */
+    connectionType(): Promise<"p2p" | "turn" | "unknown">;
+}
+/** Which of the three media paths a participant's audio and video currently take, in the order they are tried:
+ *
+ * - `"p2p"`: a direct peer-to-peer WebRTC connection, the preferred path.
+ * - `"turn"`: still WebRTC, but relayed through the TURN server, for a participant a direct path cannot reach.
+ * - `"websocket"`: not WebRTC at all - encoded frames proxied by this server over a WebSocket (see
+ * `apps/shared/relay/`), the last resort when neither of the above connects.
+ * - `"connecting"`: no path established yet. `"failed"`: every path this browser can try has failed. */
+export type MediaTransport = "connecting" | "p2p" | "turn" | "websocket" | "failed";
+/** What `MeshConnectionManager` needs from the WebSocket media relay (`apps/shared/relay/RelayTransport.ts` implements
+ * it) - declared here so the mesh, and its tests, depend on the shape alone. */
+export interface RelayTransportLike {
+    /** `false` when this browser cannot do it (no WebSocket, no WebCodecs) - the mesh then never falls back to it. */
+    readonly supported: boolean;
+    /** Starts receiving `peerId`'s media. `onStream` is given the `MediaStream` that plays it. */
+    receiveFrom(peerId: string, onStream: (stream: MediaStream) => void): void;
+    stopReceivingFrom(peerId: string): void;
+    /** Starts or stops publishing the local tracks to the relay. */
+    setSending(active: boolean): void;
+    /** Same as `MeshConnectionManager.setLocalTrack()` - `null` sends nothing for that kind. */
+    setLocalTrack(kind: "audio" | "video", track: MediaStreamTrack | null): void;
+    close(): void;
 }
 export type RTCPeerConnectionFactory = (config: {
     iceServers: RTCIceServer[];
@@ -108,6 +133,8 @@ export type RTCPeerConnectionFactory = (config: {
 export interface MeshParticipant extends ParticipantState {
     uid: string;
     name: string;
+    /** How this participant's media currently reaches the local one - see `MediaTransport`. */
+    transport: MediaTransport;
 }
 export type MeshEvent = {
     type: "participant-joined";

package/dist/lib/index.js

@@ -19,6 +19,8 @@ export * from "./models/types.js";
 export * from "./util/BookingIntegrationUtils.js";
 export * from "./util/IceServerUtils.js";
 export * from "./util/PublicUrlUtils.js";
+export * from "./util/RedisRelayBus.js";
+export * from "./util/RelayHub.js";
 export * from "./util/RouteAccessUtils.js";
 export * from "./util/TokenUtils.js";
 export * from "./routes/BaseVideoMeetingRoute.js";

package/dist/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,mEAAmE;AACnE,mCAAmC;AACnC,+EAA+E;AAC/E;;;;;;;;;;;;GAYG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,mEAAmE;AACnE,mCAAmC;AACnC,+EAA+E;AAC/E;;;;;;;;;;;;GAYG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC"}