@voltkit-rtc/client 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+## 0.2.0
+
+First release on npm, as `@voltkit-rtc/client`. Earlier builds were shared as
+a tarball under another name; only the package name changed.
+
+- **Chat.** `StreamClient` gains `sendMessage`, `getMessages`, `deleteMessage`,
+  `muteChat`, `setTyping` and `getChatState`, and the `message`,
+  `messageDeleted`, `chatMuted` and `typing` events.
+- **`ChatClient`** for chat with no media, on its own connection.
+- **`BroadcastPublisher`** for publishing a live broadcast over WHIP, H.264
+  only so the media server never has to transcode.
+- **Music.** `publishMusic`, `setMusicVolume`, `setMusicEnabled` and `stopMusic`
+  publish music playing in the page as a track of its own; `setMicEnabled` no
+  longer touches it. `track` events carry `source`, and there is a new
+  `trackMuted` event. `BroadcastPublisher` mixes music into a broadcast with
+  `setMusic`, `setMusicEnabled`, `setMusicVolume` and `clearMusic`.
+- Ships both ES module and CommonJS builds, each with its own type
+  declarations, so `import` and `require` work from JavaScript and TypeScript
+  under every module resolution mode.
+- `usageLimit` event: the project ran out of minutes or hit a usage limit, and
+  the session will be ended at `endsAt`. A server-ended session (close code
+  4003) is final and is not reconnected. Joins refused because the account is
+  out of minutes, over a limit or suspended stop reconnecting.
+- `forceMute(identity, kind?, paused?)` for moderators, and the `forceMuted`
+  event carries `kind` and `paused`: only what a moderator switched off is
+  paused locally (an audio mute includes in-app music).
+- A demoted publisher stops publishing and releases the camera and
+  microphone; the server closes a demoted publisher's tracks itself.
+- `close()` emits `closed` with `'left'`.
+- `JoinResult` includes the room's `metadata`, slot `claims` and
+  `blockedSlots`.
+
+## 0.1.0
+
+Rooms, roles, moderation, simulcast publishing and reconnection. Not
+published.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VoltKit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,296 @@
+# @voltkit-rtc/client
+
+Browser SDK for [VoltKit RTC](https://voltkit.in/rtc): realtime audio and video
+rooms, chat, and live broadcast publishing.
+
+| | |
+| --- | --- |
+| **Rooms** | `StreamClient` — join, publish camera and mic, receive everyone else, moderate |
+| **Chat** | on the room's own connection, or `ChatClient` for chat with no media |
+| **Broadcast** | `BroadcastPublisher` — go live to an audience of any size over WHIP |
+
+Your backend mints a short-lived token with
+[`@voltkit-rtc/server`](https://voltkit.in/docs/server-sdk) and
+hands the page `{ token, wsUrl }`. This package turns that into a live session.
+The API secret never reaches the browser.
+
+```bash
+npm install @voltkit-rtc/client
+```
+
+Works from JavaScript and TypeScript, with ES modules or CommonJS, and with any
+bundler (Vite, webpack, Next.js, …). Types are included. Nothing here is tied to
+a framework.
+
+```ts
+import { StreamClient } from '@voltkit-rtc/client';        // ESM or TypeScript
+// const { StreamClient } = require('@voltkit-rtc/client'); // CommonJS
+```
+
+## Rooms
+
+```ts
+import { StreamClient } from '@voltkit-rtc/client';
+
+const { token, wsUrl } = await fetch(`/api/shows/${id}/join`, { method: 'POST' }).then((r) => r.json());
+const client = new StreamClient(wsUrl, token);
+
+// Wire the events BEFORE connecting: connect() subscribes to everyone already
+// publishing, and those tracks arrive during the call.
+client.on('track', ({ identity, kind, track }) => attach(identity, kind, track));
+client.on('trackEnded', ({ identity }) => detach(identity));
+client.on('participantJoined', (p) => addToRoster(p));
+client.on('participantLeft', (p) => removeFromRoster(p.identity));
+client.on('streamInterrupted', () => showSpinner());      // the publisher is reconnecting; stay put
+client.on('closed', (reason) => leaveScreen(reason));     // terminal; nothing follows
+
+const joined = await client.connect();
+
+if (joined.role === 'host' || joined.role === 'cohost') {
+  const media = await navigator.mediaDevices.getUserMedia({ audio: true, video: true });
+  await client.publish(media);                            // simulcast: 180p / 360p / 720p
+}
+```
+
+Always call `client.close()` when leaving. A client that is dropped without
+closing keeps its reconnect loop running.
+
+### Publishing
+
+```ts
+await client.publish(media);
+await client.setMicEnabled(false);
+await client.setCamEnabled(false);
+await client.unpublish();
+
+client.publishing; client.micEnabled; client.camEnabled; client.local;   // current state
+```
+
+A `viewer` cannot publish. That is enforced at the media server, not in this
+package — a tampered client gets an error, not a stream.
+
+### Music
+
+A host can play music to the room from inside the page. It does not go through
+the microphone: it is taken straight from the element that is playing it and
+published as a track of its own, so the audience hears it clean.
+
+```ts
+const song = document.querySelector('audio')!;      // <audio src="/song.mp3" crossorigin="anonymous">
+
+await client.publishMusic(song, { volume: 0.8 });   // call it from a click
+await song.play();
+
+client.setMusicVolume(0.4);                         // for the audience
+await client.setMusicEnabled(false);                // music off, host still talking
+await client.setMicEnabled(false);                  // mic off, music still playing
+await client.stopMusic();
+```
+
+`setMicEnabled` and `setMusicEnabled` are independent, in both directions.
+`publishMusic` also takes a `MediaStream` or a `MediaStreamTrack`.
+
+The host keeps hearing the music (`monitor`, on by default for an element). A
+file from another origin must be served with CORS headers and loaded with
+`crossorigin="anonymous"`, or the browser hands the page silence.
+
+Viewers receive it as a second audio track, and `source` says which is which:
+
+```ts
+client.on('track', ({ identity, kind, source, track }) => {
+  if (source === 'music') musicAudio.srcObject = new MediaStream([track]);   // its own element = its own volume
+  else attach(identity, kind, track);
+});
+client.on('trackMuted', ({ source, paused }) => {
+  if (source === 'music') showMusicPaused(paused);
+});
+
+musicAudio.muted = true;      // "mute the music" for this viewer only
+```
+
+### Moderation
+
+```ts
+await client.raiseHand();
+await client.lowerHand();
+await client.muteParticipant(identity);        // moderating roles: asks them to mute
+await client.forceMute(identity, 'video');     // moderating roles: camera off, locked until released
+await client.forceMute(identity, 'video', false); // release
+await client.promote(identity, 'cohost');      // the promoted client reconnects by itself
+await client.kick(identity, 'spam');
+await client.endRoom();                        // host only
+await client.getRoomState();
+```
+
+### Events
+
+| Event | Fires when |
+| --- | --- |
+| `track` / `trackEnded` | someone's audio or video is ready to render, or went away; `source` is `mic`, `music`, `camera` or `screen` |
+| `trackMuted` | someone paused or resumed a track — muted their mic, switched their music off |
+| `participantJoined` / `participantLeft` | roster changes |
+| `roleChanged` | someone was promoted or demoted |
+| `handRaised` | a hand went up or down |
+| `forceMuted` | a moderator switched **your** mic or camera off |
+| `streamInterrupted` | media stopped but the connection is fine — the publisher is reconnecting |
+| `localMediaChanged` / `localStreamChanged` | your own mic, camera or stream changed |
+| `connected` / `disconnected` | the socket came up or dropped; reconnection is automatic |
+| `kicked` / `roomClosed` | you were removed, or the host ended the room |
+| `error` | something failed that the SDK could not recover from by itself |
+| `usageLimit` | your project ran out of minutes or hit a usage limit; the session ends at `endsAt` unless it is topped up |
+| `closed` | terminal — `replaced`, `kicked`, `room-closed` or `gave-up`; your own `close()` does not fire it |
+
+`on()` returns a function that removes the listener.
+
+### Reconnection
+
+Handled for you. A dropped socket is retried with backoff, the session is
+rejoined, and if you were publishing, your media is published again. `closed`
+with `gave-up` means it stopped trying.
+
+`replaced` means the same identity joined the same room somewhere else, and
+this connection lost. Do not reconnect on it: the two would take turns evicting
+each other.
+
+## Chat
+
+Every room has a chat channel of the same name. `StreamClient` carries it on the
+connection it already holds:
+
+```ts
+client.on('message', (m) => append(m));
+client.on('messageDeleted', ({ id }) => remove(id));
+client.on('typing', ({ identity, typing }) => showTyping(identity, typing));
+client.on('chatMuted', ({ identity, muted }) => lockComposer(identity, muted));
+
+await client.sendMessage('hello everyone');
+await client.sendMessage('psst', { to: 'user-42' });                       // direct: only the two of you see it
+await client.sendMessage('', { type: 'reaction', metadata: { emoji: 'heart' }, ephemeral: true });   // not stored
+
+const older = await client.getMessages({ limit: 50, before: oldest.id }); // page backwards
+await client.setTyping(true);                                              // safe on every keystroke
+const { members, muted } = await client.getChatState();
+```
+
+Your own message comes back on `message` like everyone else's. Pass
+`clientMsgId` to match it to one you rendered optimistically.
+
+**`text` is delivered exactly as it was sent.** Put it in the page with
+`textContent`, or let your framework escape it. Never with `innerHTML`.
+
+The host and moderators can also do this (a co-host is refused with `forbidden`):
+
+```ts
+await client.deleteMessage(messageId);     // anyone's; everyone else, only their own
+await client.muteChat('user-42');          // survives that user reconnecting
+await client.muteChat('user-42', false);
+```
+
+A muted sender is refused with the code `chat-muted`; a client sending too fast
+with `rate-limited`. Show both to the user rather than retrying.
+
+### Chat without media
+
+An audience watching a broadcast has no reason to join a room. `ChatClient`
+opens a connection that carries chat and nothing else, into the same
+conversation:
+
+```ts
+import { ChatClient } from '@voltkit-rtc/client';
+
+// { token, wsUrl } from your backend: createChatToken()
+const chat = new ChatClient(wsUrl, token);
+chat.on('message', append);
+chat.on('closed', (reason) => showEnded(reason));
+
+const joined = await chat.connect();       // joined.messages: recent history, oldest first
+await chat.sendMessage('first!');
+// ...
+chat.close();
+```
+
+It has the same methods and events as the chat half of `StreamClient`.
+
+## Broadcast
+
+A broadcast is one publisher and an audience of any size, served as LL-HLS
+through a CDN. Use it when the audience watches and does not talk back; use a
+room when they do.
+
+```ts
+import { BroadcastPublisher } from '@voltkit-rtc/client';
+
+// publish.whipUrl from your backend: createStream()
+const publisher = new BroadcastPublisher(whipUrl);
+publisher.on('state', (s) => setState(s));         // connecting, live, interrupted, failed, stopped
+publisher.on('warning', console.warn);
+
+preview.srcObject = await publisher.start();       // camera + mic; or start({ stream: yours })
+
+publisher.setMicEnabled(false);
+publisher.setCamEnabled(false);
+await publisher.stop();                            // off air, camera released
+```
+
+The `whipUrl` carries the publish token. Treat it like a password: fetch it when
+the user clicks "go live", and keep it out of logs and analytics.
+
+`start()` rejects with `WhipError` if the media server refuses. `isRefused`
+means the URL itself was not accepted — expired, for another stream, or the
+account is out of minutes — and a retry with the same URL is refused again.
+
+Video is offered as **H.264 only**. The media server repackages H.264 into HLS
+untouched; any other codec makes it transcode every frame. A browser with no
+H.264 encoder still publishes, and `warning` says so.
+
+To publish something other than the camera — a screen share, a canvas — pass
+your own stream: `publisher.start({ stream })`. It stays yours; `stop()` does
+not end its tracks.
+
+### Music on a broadcast
+
+A broadcast carries one audio track, so music is mixed with the microphone in
+the browser before it is sent. It still never passes through the microphone.
+
+```ts
+await publisher.setMusic(song, { volume: 0.8 });   // while live, or start({ music: song })
+publisher.setMusicVolume(0.4);
+publisher.setMusicEnabled(false);                  // music off, mic untouched
+publisher.setMicEnabled(false);                    // mic off, music keeps playing
+publisher.clearMusic();
+```
+
+Adding music to a broadcast that is already live does not interrupt it.
+
+### Watching
+
+Viewers need nothing from this package. Safari plays the `llhls` URL natively;
+everywhere else, use the `hls.js` package:
+
+```ts
+import Hls from 'hls.js';
+
+if (video.canPlayType('application/vnd.apple.mpegurl')) {
+  video.src = llhlsUrl;
+} else {
+  const hls = new Hls({ lowLatencyMode: true });
+  hls.loadSource(llhlsUrl);
+  hls.attachMedia(video);
+}
+```
+
+## Errors
+
+Server refusals reject with `RpcError` (rooms) or `ChatRpcError` (`ChatClient`),
+both carrying a machine-readable `code`: `forbidden`, `bad-params`,
+`chat-muted`, `rate-limited`, `no-message`, and so on. The full list is in the
+[API reference](https://voltkit.in/docs/api-reference).
+
+## Help
+
+Documentation: https://voltkit.in/docs. Questions and bug reports:
+contact@voltkit.in.
+
+## Licence
+
+MIT

package/dist/cjs/broadcast.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Publishing a broadcast stream.
+ *
+ * A broadcast is one publisher and an audience of any size, delivered over
+ * LL-HLS and WebRTC. Publishing is WHIP: one HTTP exchange of SDP, then media
+ * straight to the media server. Viewers need nothing from this package -- they
+ * play the stream's LL-HLS URL in any HLS player.
+ */
+import { type MusicInput, type MusicOptions } from './music.js';
+/** The media server refused, or could not be reached. */
+export declare class WhipError extends Error {
+    readonly status: number;
+    /**
+     * @param status HTTP status, or 0 when the request never got an answer.
+     */
+    constructor(status: number, message: string);
+    /**
+     * The publish URL was not accepted: its token is missing, expired, for a
+     * different stream, or the account behind it cannot go on air. The same URL
+     * will be refused again -- get a new one from your backend.
+     */
+    get isRefused(): boolean;
+}
+export type BroadcastState = 'idle' | 'connecting'
+/** Media is flowing to the media server. */
+ | 'live'
+/** The connection dropped. WebRTC may recover it; if it reaches `failed`, start again. */
+ | 'interrupted' | 'failed' | 'stopped';
+export interface BroadcastEvents {
+    state: (state: BroadcastState) => void;
+    /**
+     * Publishing worked, but something that affects cost or quality did not
+     * apply -- most importantly, H.264 was not available in this browser.
+     */
+    warning: (message: string) => void;
+}
+export interface BroadcastStartOptions {
+    /** Media you already hold. It stays yours: `stop()` will not end its tracks. */
+    stream?: MediaStream;
+    /** Used to acquire camera and microphone when `stream` is not given. */
+    constraints?: MediaStreamConstraints;
+    /** Music playing inside the page, to go on air from the first second. See `setMusic`. */
+    music?: MusicInput;
+    musicOptions?: MusicOptions;
+}
+/**
+ * Send an SDP offer to a WHIP endpoint and return the answer, plus the session
+ * resource the server names for ending it.
+ */
+export declare function whipOffer(whipUrl: string, offerSdp: string, timeoutMs?: number): Promise<{
+    answerSdp: string;
+    resource: string | null;
+}>;
+/**
+ * Tell the server the session is over. Best effort: the media server also
+ * notices the connection going away, so a failure here is not an error.
+ */
+export declare function whipEnd(resource: string): Promise<void>;
+/**
+ * Publishes camera and microphone to one broadcast stream.
+ *
+ * ```ts
+ * const publisher = new BroadcastPublisher(stream.publish.whipUrl);
+ * publisher.on('state', (s) => setState(s));
+ * const media = await publisher.start();
+ * video.srcObject = media;
+ * // ...
+ * await publisher.stop();
+ * ```
+ *
+ * The `whipUrl` comes from your backend (`POST /v1/streams`) and already
+ * carries the publish token. Treat it like a password.
+ */
+export declare class BroadcastPublisher {
+    private readonly whipUrl;
+    private pc;
+    private media;
+    private ownsMedia;
+    private resource;
+    private audioSender;
+    private micTrack;
+    /** Present only while music is in use: the broadcast carries one audio track, so the two are mixed. */
+    private mixer;
+    private micOn;
+    private current;
+    private readonly listeners;
+    constructor(whipUrl: string);
+    get state(): BroadcastState;
+    /** What is being published, for a local preview. */
+    get localStream(): MediaStream | null;
+    on<K extends keyof BroadcastEvents>(event: K, fn: BroadcastEvents[K]): () => void;
+    private emit;
+    private set;
+    /** Go on air. Resolves once the media server has accepted the stream. */
+    start(options?: BroadcastStartOptions): Promise<MediaStream>;
+    /**
+     * Put H.264 first, and offer nothing else for video.
+     *
+     * The media server repackages H.264 into HLS untouched. Any other codec
+     * makes it decode and re-encode every frame, which is the entire cost of a
+     * stream -- so a publisher that negotiates VP8 works, and quietly costs many
+     * times more.
+     */
+    private preferH264;
+    /** Mute or unmute the microphone without leaving the air. Music keeps playing. */
+    setMicEnabled(enabled: boolean): void;
+    /**
+     * Put music from inside the page on air, mixed with the microphone.
+     *
+     * A broadcast carries a single audio track, so the two are mixed here, in
+     * the browser, before they are sent. The music never passes through the
+     * microphone, so the audience hears it clean, and each has its own switch:
+     * `setMusicEnabled` and `setMicEnabled`.
+     */
+    setMusic(input: MusicInput, options?: MusicOptions): Promise<void>;
+    /** Switch the music off or on for the audience. The microphone is untouched. */
+    setMusicEnabled(enabled: boolean): void;
+    /** 0 to 1, for the audience. */
+    setMusicVolume(volume: number): void;
+    /** Take the music off air. The microphone carries on. */
+    clearMusic(): void;
+    get musicEnabled(): boolean;
+    get micEnabled(): boolean;
+    /** Turn the camera on or off without leaving the air. */
+    setCamEnabled(enabled: boolean): void;
+    /** Go off air and release the camera and microphone. Idempotent. */
+    stop(): Promise<void>;
+    private teardown;
+}
+//# sourceMappingURL=broadcast.d.ts.map

package/dist/cjs/broadcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../src/broadcast.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAc,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE5E,yDAAyD;AACzD,qBAAa,SAAU,SAAQ,KAAK;IAItB,QAAQ,CAAC,MAAM,EAAE,MAAM;IAHnC;;OAEG;gBACkB,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAKpD;;;;OAIG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF;AAED,MAAM,MAAM,cAAc,GACtB,MAAM,GACN,YAAY;AACd,4CAA4C;GAC1C,MAAM;AACR,0FAA0F;GACxF,aAAa,GACb,QAAQ,GACR,SAAS,CAAC;AAEd,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IACvC;;;OAGG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,wEAAwE;IACxE,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,yFAAyF;IACzF,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAUD;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,SAAkB,GAC1B,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAwBzD;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO7D;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAkB;IAajB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZpC,OAAO,CAAC,EAAE,CAAkC;IAC5C,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,QAAQ,CAAiC;IACjD,uGAAuG;IACvG,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;gBAEhC,OAAO,EAAE,MAAM;IAE5C,IAAI,KAAK,IAAI,cAAc,CAE1B;IAED,oDAAoD;IACpD,IAAI,WAAW,IAAI,WAAW,GAAG,IAAI,CAEpC;IAED,EAAE,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAUjF,OAAO,CAAC,IAAI;IAUZ,OAAO,CAAC,GAAG;IAMX,yEAAyE;IACnE,KAAK,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,WAAW,CAAC;IAmDtE;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAelB,kFAAkF;IAClF,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMrC;;;;;;;OAOG;IACG,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxE,gFAAgF;IAChF,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIvC,gCAAgC;IAChC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIpC,yDAAyD;IACzD,UAAU,IAAI,IAAI;IAIlB,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,yDAAyD;IACzD,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIrC,oEAAoE;IAC9D,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,OAAO,CAAC,QAAQ;CAajB"}