@voltkit-rtc/react-native 0.0.0-stage → 0.1.1

package/lib/typescript/commonjs/platform/devices.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Cameras, microphones and audio outputs.
+ *
+ * Cameras come from react-native-webrtc (ids "0", "1", ... with a facing), named as the Android SDK names them ("Front
+ * camera", "Back camera 2"). On Android the audio devices come from this package's audio router (speaker, earpiece,
+ * wired and USB headsets, Bluetooth, each with its `type`), which also routes sound and picks the microphone natively;
+ * without the native module, and on iOS, from react-native-webrtc's list.
+ *
+ * A camera is switched on its own track (react-native-webrtc's applyConstraints with the deviceId): the same track and
+ * producer, so nothing can fail half-way. react-native-webrtc falls back to the facing mode, without an error, for an
+ * id it does not know, so the id is checked against the list first (`bad-params`) and the camera it ended up on is
+ * checked after (`camera-failed`); the old camera keeps capturing either way.
+ */
+import { type DeviceKind, type MediaDevice } from '@voltkit-rtc/client';
+import type { Spec } from '../specs/NativeVoltkitRtc';
+/** The cameras, front ones first, labelled as the Android SDK labels them. */
+export declare function listCameras(): Promise<MediaDevice[]>;
+/** Every device, or those of one kind (ClientPlatform.enumerateDevices). */
+export declare function enumerateDevices(module: Spec | null, kind?: DeviceKind): Promise<MediaDevice[]>;
+/** Hear audio devices come and go (Android's router); cameras cannot be watched. */
+export declare function onDeviceChange(module: Spec | null, listener: () => void): (() => void) | null;
+/**
+ * Route sound to an output, or record from a microphone, natively (ClientPlatform.routeAudio). Outputs: true when
+ * routed, false when it cannot be chosen (the client then rejects with `bad-params`). Microphones: true when the audio
+ * device module records from it now; `bad-params` for one the router does not list; false (the client captures it)
+ * where the module cannot choose.
+ */
+export declare function routeAudio(module: Spec, kind: 'audioinput' | 'audiooutput', deviceId: string): Promise<boolean>;
+/** react-native-webrtc's camera track, as far as switching needs it. */
+interface CameraTrack {
+    readonly kind: string;
+    getSettings(): {
+        deviceId?: unknown;
+        facingMode?: unknown;
+    };
+    getConstraints(): Record<string, unknown>;
+    applyConstraints(constraints: Record<string, unknown>): Promise<void>;
+}
+/** Turn the camera behind `track` to `deviceId`, on the same track (ClientPlatform.switchCameraInPlace). */
+export declare function switchCameraInPlace(track: CameraTrack, deviceId: string): Promise<void>;
+export {};
+//# sourceMappingURL=devices.d.ts.map

package/lib/typescript/commonjs/platform/devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../../../../src/platform/devices.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAA+B,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACrG,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AA4BtD,8EAA8E;AAC9E,wBAAsB,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAa1D;AAyBD,4EAA4E;AAC5E,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CASrG;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAG7F;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAarH;AAED,wEAAwE;AACxE,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,WAAW,IAAI;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5D,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,gBAAgB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAED,4GAA4G;AAC5G,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB7F"}

package/lib/typescript/commonjs/platform/index.d.ts

@@ -0,0 +1,6 @@
+import type { ClientPlatform } from '@voltkit-rtc/client';
+/** The React Native platform for this app (Android, or the iOS preview). The same object every time. */
+export declare function reactNativePlatform(): ClientPlatform;
+export { streamBook } from './streams';
+export type { StreamBook, ViewHandle } from './streams';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAM1D,wGAAwG;AACxG,wBAAgB,mBAAmB,IAAI,cAAc,CAKpD;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/lib/typescript/commonjs/platform/ios.d.ts

@@ -0,0 +1,4 @@
+import type { ClientPlatform } from '@voltkit-rtc/client';
+import { type AppStreamHook } from './common';
+export declare function iosPlatform(): ClientPlatform & AppStreamHook;
+//# sourceMappingURL=ios.d.ts.map

package/lib/typescript/commonjs/platform/ios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ios.d.ts","sourceRoot":"","sources":["../../../../src/platform/ios.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAiD,KAAK,aAAa,EAAuC,MAAM,UAAU,CAAC;AAMlI,wBAAgB,WAAW,IAAI,cAAc,GAAG,aAAa,CAgC5D"}

package/lib/typescript/commonjs/platform/streams.d.ts

@@ -0,0 +1,82 @@
+/** What this module needs of a track: react-native-webrtc's MediaStreamTrack, or a test's stand-in. */
+export interface TrackLike {
+    readonly id: string;
+    readonly kind: string;
+    readonly remote?: boolean;
+    readonly readyState: string;
+    enabled: boolean;
+    stop(): void;
+    release?(): void;
+}
+/** What this module needs of a stream: react-native-webrtc's MediaStream. */
+export interface StreamLike {
+    getTracks(): TrackLike[];
+    removeTrack(track: TrackLike): void;
+    release(releaseTracks?: boolean): void;
+    toURL(): string;
+}
+/**
+ * Why a stream is kept: a capture (getUserMedia, getDisplayMedia), the client's own (createStream), a view, or the
+ * app's own that the client publishes (adoptAppStream: tracks taken out of it, never released here).
+ */
+export type StreamRole = 'capture' | 'client' | 'view' | 'app';
+/** One view's hold on a track's wrapper stream. */
+export interface ViewHandle {
+    /** The wrapper's URL, for RTCView's streamURL. */
+    readonly url: string;
+    /** Called when the wrapper goes before this view lets go of it (the track was stopped or detached). */
+    onEnd(listener: () => void): () => void;
+    /** This view is done; the wrapper is released when the last view of the track lets go. */
+    release(): void;
+}
+export declare class StreamBook {
+    private readonly makeStream;
+    private readonly live;
+    private readonly entries;
+    private readonly views;
+    /** Local tracks this package disposed (released). */
+    private readonly disposed;
+    /** Remote tracks whose connection is closing: no new view, their wrappers already released. */
+    private readonly detached;
+    private readonly stopped;
+    private readonly screens;
+    /** Streams left unreleased because releasing them would have crashed the app. */
+    leaked: number;
+    /** Called after a screen track is stopped and released (react-native-webrtc's MediaProjectionService then stops). */
+    onScreenStopped: (() => void) | null;
+    constructor(makeStream: (tracks: TrackLike[]) => StreamLike);
+    /** Keep `stream`, one the platform made (or the app's, `app`), to let go of in the right order. */
+    adopt(stream: StreamLike, role: StreamRole): void;
+    /** A stream of these tracks for the client's own use (ClientPlatform.createStream). */
+    create(tracks: TrackLike[]): StreamLike;
+    /** The tracks of `stream` are a screen capture's. */
+    markScreen(stream: StreamLike): void;
+    /** Release `stream` without its tracks (ClientPlatform.releaseStream). Again does nothing. */
+    release(stream: StreamLike): void;
+    /**
+     * Stop and release `track` (ClientPlatform.stopTrack): its view wrappers are released and it leaves every stream
+     * kept here first (made here, or the app's adopted), while the native track still exists. Again does nothing. A
+     * remote track is only let go of: its connection owns it.
+     */
+    stop(track: TrackLike): void;
+    /**
+     * The client is about to close what receives these remote tracks (ClientPlatform.detachTracks): release their
+     * wrappers now, while their peer connection still exists, and make no new ones.
+     */
+    detach(tracks: readonly TrackLike[]): void;
+    /** A view of `track` (VideoTrack), or null when it cannot be shown: ended, stopped or detached. */
+    view(track: TrackLike): ViewHandle | null;
+    /** How many streams made here are not released yet, how many tracks have views, and how many were left unreleased. */
+    stats(): {
+        live: number;
+        views: number;
+        leaked: number;
+    };
+    /** A track the native side may no longer have: disposed here, or remote and ended (its connection closed). */
+    private unsafe;
+    private dropViews;
+    private releaseEntry;
+}
+/** The process's book of streams (one for every client and view). */
+export declare function streamBook(): StreamBook;
+//# sourceMappingURL=streams.d.ts.map

package/lib/typescript/commonjs/platform/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../../../src/platform/streams.ts"],"names":[],"mappings":"AA6BA,uGAAuG;AACvG,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,IAAI,IAAI,CAAC;IACb,OAAO,CAAC,IAAI,IAAI,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,WAAW,UAAU;IACzB,SAAS,IAAI,SAAS,EAAE,CAAC;IACzB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACpC,OAAO,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,KAAK,IAAI,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAc/D,mDAAmD;AACnD,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,uGAAuG;IACvG,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IACxC,0FAA0F;IAC1F,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,qBAAa,UAAU;IAeT,OAAO,CAAC,QAAQ,CAAC,UAAU;IAdvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,+FAA+F;IAC/F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,iFAAiF;IACjF,MAAM,SAAK;IACX,qHAAqH;IACrH,eAAe,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAQ;gBAEf,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,UAAU;IAE5E,mGAAmG;IACnG,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI;IAYjD,uFAAuF;IACvF,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,UAAU;IAMvC,qDAAqD;IACrD,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAIpC,8FAA8F;IAC9F,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAUjC;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAyC5B;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI;IAO1C,mGAAmG;IACnG,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI;IAuCzC,sHAAsH;IACtH,KAAK,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAIxD,8GAA8G;IAC9G,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,YAAY;CAoBrB;AAID,qEAAqE;AACrE,wBAAgB,UAAU,IAAI,UAAU,CASvC"}

package/lib/typescript/commonjs/platform/timers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The timers the client's own work runs on (reconnect backoff, socket liveness, request deadlines, sampling).
+ *
+ * React Native's JavaScript timers run on Choreographer frames, which stop when the app leaves the foreground, when
+ * the screen goes off even with the app in front, and while a permission dialog is open (Phase 0 S5): a call whose
+ * timers stop cannot notice a dead socket or reconnect. On Android they wait natively instead (the module's
+ * timerStart/timerStop on a thread of their own) and fire back through its onTimer event, which reaches JavaScript
+ * whether frames run or not. Without the native module (iOS, Expo Go) they are JavaScript's own.
+ */
+import type { PlatformTimers } from '@voltkit-rtc/client';
+import type { Spec } from '../specs/NativeVoltkitRtc';
+/** JavaScript's own timers, looked up at each call (a test's fake clock replaces them, and is used). */
+export declare const jsTimers: PlatformTimers;
+/**
+ * Timers that wait natively. Ids are this side's and never reused, so a fire already on its way for a timer stopped
+ * since is recognised and ignored. One onTimer subscription for the whole process.
+ */
+export declare function nativeTimers(module: Spec): PlatformTimers;
+//# sourceMappingURL=timers.d.ts.map

package/lib/typescript/commonjs/platform/timers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timers.d.ts","sourceRoot":"","sources":["../../../../src/platform/timers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAItD,wGAAwG;AACxG,eAAO,MAAM,QAAQ,EAAE,cAKrB,CAAC;AAOH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,IAAI,GAAG,cAAc,CAwCzD"}

package/lib/typescript/commonjs/platform/visibility.d.ts

@@ -0,0 +1,11 @@
+import type { Spec } from '../specs/NativeVoltkitRtc';
+export interface Visibility {
+    visible(): boolean;
+    /** Hear every change; returns the function that stops. */
+    subscribe(listener: (visible: boolean) => void): () => void;
+}
+/** From the process lifecycle (Android). */
+export declare function nativeVisibility(module: Spec): Visibility;
+/** From AppState: `active` and `inactive` are visible, `background` is not. */
+export declare function appStateVisibility(): Visibility;
+//# sourceMappingURL=visibility.d.ts.map

package/lib/typescript/commonjs/platform/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../../src/platform/visibility.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAItD,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,OAAO,CAAC;IACnB,0DAA0D;IAC1D,SAAS,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7D;AAID,4CAA4C;AAC5C,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,IAAI,GAAG,UAAU,CAYzD;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,UAAU,CAkB/C"}

package/lib/typescript/commonjs/preflight.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The pre-call check on React Native: @voltkit-rtc/client's preflight with this package's platform. It joins the room
+ * the token names, publishes for a few seconds, measures and leaves, and never rejects: offline, a refused permission,
+ * a bad token or a missing native module all give a report whose steps say what failed.
+ *
+ * React Native cannot make a test tone or picture. Without `options.media` the check publishes the microphone, which
+ * it captures itself once joined (so nothing opens the microphone for a join that fails) and releases at the end. It
+ * never asks for the permission: where it is not granted, the join is still tested and the media step says why.
+ * Android shows its microphone indicator for those seconds.
+ */
+import { type PreflightOptions, type PreflightReport } from '@voltkit-rtc/client';
+import { type BackgroundOptions } from './create-client';
+export interface ReactNativePreflightOptions extends PreflightOptions {
+    /** The test client's background pause (as createClient's). */
+    background?: BackgroundOptions;
+}
+/** Test the connection and the media path before a call. Never rejects. */
+export declare function preflight(wsUrl: string, token: string, options?: ReactNativePreflightOptions): Promise<PreflightReport>;
+//# sourceMappingURL=preflight.d.ts.map

package/lib/typescript/commonjs/preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.d.ts","sourceRoot":"","sources":["../../../src/preflight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAgB,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGhG,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEnF,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACnE,8DAA8D;IAC9D,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AA4BD,2EAA2E;AAC3E,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,2BAAgC,GAAG,OAAO,CAAC,eAAe,CAAC,CAYjI"}

package/lib/typescript/commonjs/provider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * VoltkitProvider for React Native: @voltkit-rtc/react's provider (the same props, token hand-over and StrictMode
+ * behaviour, so every re-exported hook works below it) making its client with this package's platform, plus what a call
+ * needs from the device: the call audio, the call service and the background pause.
+ *
+ * In Expo Go, or an app not rebuilt after installing react-native-webrtc, no client is made: onError gets
+ * `media-unavailable` with `{ reason: 'webrtc-missing' }` (it needs a development build) and the hooks keep their
+ * defaults. Nothing throws.
+ */
+import { type ReactElement } from 'react';
+import { type VoltkitProviderProps as ReactVoltkitProviderProps } from '@voltkit-rtc/react';
+import { type BackgroundOptions } from './create-client';
+import { type AudioSessionOptions, type CallServiceText } from './native-session';
+export interface VoltkitProviderProps extends ReactVoltkitProviderProps {
+    /**
+     * The call audio (Android): held from the join to the close -- the audio mode, focus and routing -- with the
+     * loudspeaker unless `speakerphone: false` (the earpiece) or setSpeakerphoneOn chose. `false`, or `manage: false`,
+     * leaves the device's audio to the app. Default `{ speakerphone: true, manage: true }`.
+     */
+    audio?: AudioSessionOptions | false;
+    /**
+     * The background pause, read when the client is made: the camera goes off in the background and comes back with the
+     * app (default `pauseCamera: true`); the microphone keeps going (`pauseMic: false`). Your `clientOptions` win.
+     */
+    background?: BackgroundOptions;
+    /**
+     * The call service (Android): a foreground service that keeps the call's network and microphone alive in the
+     * background and with the screen off. Started on the join when the app's manifest declares it (the Expo plugin's
+     * callService, default on), with this notification; `false` never starts it. Default true.
+     */
+    callService?: boolean | CallServiceText;
+}
+/** One StreamClient for the components below, with the device's audio, the call service and the background pause. */
+export declare function VoltkitProvider({ audio, background, callService, clientOptions, client, wsUrl, token, onError, children, ...rest }: VoltkitProviderProps): ReactElement;
+//# sourceMappingURL=provider.d.ts.map

package/lib/typescript/commonjs/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/provider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAEtE,OAAO,EAA2C,KAAK,oBAAoB,IAAI,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAIrI,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,EAAiB,KAAK,mBAAmB,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEjG,MAAM,WAAW,oBAAqB,SAAQ,yBAAyB;IACrE;;;;OAIG;IACH,KAAK,CAAC,EAAE,mBAAmB,GAAG,KAAK,CAAC;IACpC;;;OAGG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,eAAe,CAAC;CACzC;AAED,qHAAqH;AACrH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,UAAU,EACV,WAAW,EACX,aAAa,EACb,MAAM,EACN,KAAK,EACL,KAAK,EACL,OAAO,EACP,QAAQ,EACR,GAAG,IAAI,EACR,EAAE,oBAAoB,GAAG,YAAY,CAqCrC"}

package/lib/typescript/commonjs/specs/NativeVoltkitRtc.d.ts

@@ -0,0 +1,157 @@
+/**
+ * The native side of @voltkit-rtc/react-native on Android, as one codegen TurboModule (plan §5.1): audio routing
+ * (ported from the Android SDK's AudioRouter), the call service, native timers, app visibility from the process
+ * lifecycle, the network, and stopping react-native-webrtc's screen-share service. iOS has no native module in 0.1.0.
+ *
+ * Read it through src/native.ts, never directly: this module is null in Expo Go, on iOS and wherever the app was not
+ * rebuilt after installing the package, and native.ts turns that into a typed error.
+ *
+ * Strings that hold one of a few values are typed `string` here, as codegen needs; the values are listed beside each.
+ */
+import type { CodegenTypes, TurboModule } from 'react-native';
+/** An audio input or output, as the Android SDK lists it (`MediaDevice`). */
+export type AudioDevice = {
+    /** Stable while connected: `speaker`, `earpiece`, `wired`, `bluetooth:12`, `usb:7`, `mic`, `wired-mic`, ... */
+    deviceId: string;
+    /** `audioinput` | `audiooutput`. */
+    kind: string;
+    /** A name to show: "Speaker", "Phone", "Pixel Buds". */
+    label: string;
+    /** `speaker` | `earpiece` | `wiredHeadset` | `bluetooth` | `usb` | `builtinMic` | `other`. */
+    type: string;
+    /** A headset's microphone and earphones share one. */
+    groupId: string;
+};
+/** Devices came or went while a client held the audio (a headset plugged in, Bluetooth connected). */
+export type AudioDevicesChangedEvent = {
+    devices: AudioDevice[];
+    added: AudioDevice[];
+    removed: AudioDevice[];
+};
+/** Where call audio plays now; null once the last client let the audio go. */
+export type AudioOutputChangedEvent = {
+    device: AudioDevice | null;
+};
+/** Audio focus, while a client holds the audio: `gain` | `loss` | `lossTransient` | `lossTransientCanDuck`. */
+export type AudioFocusChangedEvent = {
+    focus: string;
+};
+/** The audio device module could not open or keep the microphone. */
+export type MicrophoneErrorEvent = {
+    message: string;
+};
+/** The app went to the foreground (any activity started) or the background, from ProcessLifecycleOwner. */
+export type AppVisibilityChangedEvent = {
+    visible: boolean;
+};
+/** The network came back (`handover` false) or the default network changed, say Wi-Fi to mobile data (true). */
+export type NetworkAvailableEvent = {
+    handover: boolean;
+};
+/** What the call service shows and the call it runs for: its foreground service types are worked out from these. */
+export type CallServiceOptions = {
+    /** The notification's title and text, and the label of its Leave action. */
+    title: string;
+    text: string;
+    leaveLabel: string;
+    /** The provider's `background.pauseCamera`: true never asks for the camera type. */
+    pauseCamera: boolean;
+    /** What the call publishes now. */
+    micPublished: boolean;
+    cameraPublished: boolean;
+    /** A screen share is live: on Android 14 and later the `mediaProjection` type is asked for only while it is. */
+    sharing: boolean;
+};
+/** The call service: whether the app declares it, and whether it runs, with which foreground service types. */
+export type CallServiceStatus = {
+    declared: boolean;
+    running: boolean;
+    /** `microphone`, `mediaPlayback`, `camera`, `mediaProjection`: what it runs with now (empty when stopped). */
+    types: string[];
+};
+/** `started` | `updated` | `stopped` | `leave` (the notification's action) | `taskRemoved` | `failed`. */
+export type CallServiceEvent = {
+    type: string;
+    /** The types it runs with after this event. */
+    types: string[];
+    /** Why it failed; empty otherwise. */
+    message: string;
+};
+export type Constants = {
+    /** `communication` | `media`, from the meta-data in.voltkit.rtc.AUDIO_MODE: fixed for the life of the process. */
+    audioMode: string;
+    /** in.voltkit.rtc.HW_AEC: the handset's own echo canceller and noise suppressor, where it has them. */
+    hardwareEchoCancellation: boolean;
+    /** in.voltkit.rtc.SCREEN_SHARE: react-native-webrtc's screen-share service is enabled. */
+    screenShareEnabled: boolean;
+    /** Whether the app's manifest declares the call service (VoltkitCallService), and its declared types. */
+    callServiceDeclared: boolean;
+    callServiceTypes: string[];
+    /** android.os.Build.VERSION.SDK_INT. */
+    sdkInt: number;
+    /** The version of this package the native code was built from: a mismatch with the JavaScript means a stale build. */
+    nativeVersion: string;
+    /**
+     * Whether react-native-webrtc uses the audio device module the init provider made, so audioMode and
+     * hardwareEchoCancellation apply. False when the app set its own in MainApplication (selectAudioInput still works
+     * when that one is a JavaAudioDeviceModule) or the provider did not run.
+     */
+    audioDeviceModule: boolean;
+};
+export interface Spec extends TurboModule {
+    getConstants(): Constants;
+    /**
+     * A client connected and manages audio: set up the call audio (mode, focus, routing) while any client holds it.
+     * Resolves with the holder to release. `speakerphone` sets the speaker-or-earpiece preference; null keeps the
+     * one setSpeakerphoneOn set.
+     */
+    audioAcquire(speakerphone: boolean | null): Promise<number>;
+    /** That client left; the last holder out puts the device's audio back as it found it. Unknown holders are ignored. */
+    audioRelease(holder: number): void;
+    /** The loudspeaker (true) or the earpiece (false) when no headset is connected; a headset still wins. Kept until changed. */
+    setSpeakerphoneOn(on: boolean): void;
+    /** The audio inputs and outputs now. */
+    listAudioDevices(): Promise<AudioDevice[]>;
+    /** Play call audio on this output while it stays connected. False when there is no such output, or in media mode. */
+    selectAudioOutput(deviceId: string): Promise<boolean>;
+    /**
+     * Record from this microphone (null: the default). False when there is no such input, or react-native-webrtc's audio
+     * device module is not a JavaAudioDeviceModule.
+     */
+    selectAudioInput(deviceId: string | null): Promise<boolean>;
+    /** Where call audio plays now, while a client holds the audio. */
+    currentAudioOutput(): Promise<AudioDevice | null>;
+    /** Whether an activity of the app is started now (ProcessLifecycleOwner; AppState says background under dialogs). */
+    isAppVisible(): boolean;
+    /**
+     * Start the call service: a foreground service that keeps the call's network, microphone and timers alive in the
+     * background. Start it while the app is visible (Android's while-in-use rules). Rejects when the app does not
+     * declare it, a permission it needs is missing, or Android refuses it.
+     */
+    startCallService(options: CallServiceOptions): Promise<CallServiceStatus>;
+    /** New text, or new types (a camera published, a share started or ended). Widen the types only while visible. */
+    updateCallService(options: CallServiceOptions): Promise<CallServiceStatus>;
+    /** Stop it (the call ended). Resolves when stopped; stopping one that is not running does nothing. */
+    stopCallService(): Promise<CallServiceStatus>;
+    getCallServiceStatus(): CallServiceStatus;
+    /** Stop react-native-webrtc's MediaProjectionService once a share ended. True when one was running. */
+    stopScreenShareService(): Promise<boolean>;
+    /**
+     * Fire onTimer(id) after `ms`, and every `ms` after that when `repeat`. A new start with a live id replaces it. Ids
+     * come from the caller and are never reused: a fire may already be on its way when the timer is stopped, so a fire
+     * for an id the caller no longer has is to be ignored.
+     */
+    timerStart(id: number, ms: number, repeat: boolean): void;
+    timerStop(id: number): void;
+    readonly onAudioDevicesChanged: CodegenTypes.EventEmitter<AudioDevicesChangedEvent>;
+    readonly onAudioOutputChanged: CodegenTypes.EventEmitter<AudioOutputChangedEvent>;
+    readonly onAudioFocusChanged: CodegenTypes.EventEmitter<AudioFocusChangedEvent>;
+    readonly onMicrophoneError: CodegenTypes.EventEmitter<MicrophoneErrorEvent>;
+    readonly onAppVisibilityChanged: CodegenTypes.EventEmitter<AppVisibilityChangedEvent>;
+    readonly onNetworkAvailable: CodegenTypes.EventEmitter<NetworkAvailableEvent>;
+    readonly onCallServiceEvent: CodegenTypes.EventEmitter<CallServiceEvent>;
+    readonly onTimer: CodegenTypes.EventEmitter<number>;
+}
+declare const _default: Spec | null | undefined;
+export default _default;
+//# sourceMappingURL=NativeVoltkitRtc.d.ts.map

package/lib/typescript/commonjs/specs/NativeVoltkitRtc.d.ts.map

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

package/lib/typescript/module/audio.d.ts

@@ -0,0 +1,58 @@
+import { type MediaDevice, type StreamClient } from '@voltkit-rtc/client';
+/**
+ * Play call audio on the loudspeaker (true) or the earpiece (false) when no headset is connected; a wired or Bluetooth
+ * headset still wins. Kept until changed, and applied to calls joined later. Rejects with `media-unavailable` on iOS
+ * and where the native module is missing.
+ */
+export declare function setSpeakerphoneOn(on: boolean): Promise<void>;
+/**
+ * Play call audio on this output (a deviceId from useAudioOutput().outputs) while it stays connected. Rejects with
+ * `bad-params` for an output that is not there and in the audio mode `media`, and with `media-unavailable` on iOS and
+ * where the native module is missing.
+ */
+export declare function selectAudioOutput(deviceId: string): Promise<void>;
+/**
+ * The speaker preference a newly joined call holds the audio with: the provider's (default the loudspeaker), unless
+ * the app chose with setSpeakerphoneOn, which the router keeps (null).
+ */
+export declare function speakerPreference(provider: boolean | undefined): boolean | null;
+/**
+ * One client's hold on the call audio: acquired once it is connected, released when it closes or the provider lets go
+ * of it. Released a moment late, so React's StrictMode (an effect unmounted and mounted again at once) neither
+ * releases nor acquires twice.
+ */
+declare class AudioHold {
+    private readonly onError;
+    private holder;
+    private users;
+    private pendingRelease;
+    constructor(onError: (error: Error) => void);
+    retain(): void;
+    /** One user less; the hold goes when none is left. */
+    unretain(): void;
+    acquire(speakerphone: boolean | null): void;
+    release(): void;
+}
+/** The call audio hold of `client`. */
+export declare function audioHoldOf(client: StreamClient, onError: (error: Error) => void): AudioHold;
+export interface AudioOutput {
+    /** Outputs can be chosen here: Android with the native module, in the audio mode `communication`. */
+    supported: boolean;
+    /** Where call audio can play: speaker, earpiece, wired and USB headsets, Bluetooth. Empty where not supported. */
+    outputs: MediaDevice[];
+    /** Where call audio plays now, while a call holds the audio; null otherwise. */
+    current: MediaDevice | null;
+    /** The loudspeaker is in use (or, with no call holding the audio, preferred). */
+    speakerphone: boolean;
+    /** Play call audio on this output (selectAudioOutput). */
+    select(deviceId: string): Promise<void>;
+    /** The loudspeaker (true) or the earpiece (false), when no headset is connected (setSpeakerphoneOn). */
+    setSpeakerphoneOn(on: boolean): Promise<void>;
+}
+/**
+ * Where call audio plays, and the choice of output (an Android "speaker / phone / headset" picker). Works before any
+ * call: a choice made then is kept. On iOS and without the native module `supported` is false and the calls reject.
+ */
+export declare function useAudioOutput(): AudioOutput;
+export {};
+//# sourceMappingURL=audio.d.ts.map

package/lib/typescript/module/audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/audio.ts"],"names":[],"mappings":"AAYA,OAAO,EAAY,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAOpF;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAKlE;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAavE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,IAAI,CAE/E;AAID;;;;GAIG;AACH,cAAM,SAAS;IAKD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,cAAc,CAAS;gBAEF,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;IAE5D,MAAM,IAAI,IAAI;IAKd,sDAAsD;IACtD,QAAQ,IAAI,IAAI;IAShB,OAAO,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI;IAa3C,OAAO,IAAI,IAAI;CAShB;AAID,uCAAuC;AACvC,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,SAAS,CAO5F;AAID,MAAM,WAAW,WAAW;IAC1B,qGAAqG;IACrG,SAAS,EAAE,OAAO,CAAC;IACnB,kHAAkH;IAClH,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,gFAAgF;IAChF,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,iFAAiF;IACjF,YAAY,EAAE,OAAO,CAAC;IACtB,0DAA0D;IAC1D,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,wGAAwG;IACxG,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C;AA0ED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAG5C"}

package/lib/typescript/module/components.d.ts

@@ -0,0 +1,58 @@
+/**
+ * VideoTrack and AudioTrack, React Native's versions of @voltkit-rtc/react's.
+ *
+ * VideoTrack shows a track in react-native-webrtc's RTCView, which plays a stream by URL. Its stream is a wrapper made
+ * through platform/streams.ts, one per track and shared by every view of it, released (never the track) when the last
+ * view goes -- or earlier, while the connection still exists, when the client is about to close what receives the
+ * track or stops it: releasing a wrapper after its track died kills the app (Phase 0 finding 1). The URL is set one
+ * frame after mounting, and the native view is mounted again once if no frame size arrives within 3 s
+ * (react-native-webrtc #1611, black video).
+ *
+ * AudioTrack renders nothing: React Native plays every remote audio track by itself. It sets one track's volume
+ * (react-native-webrtc's `_setVolume`, unity at 1) or mutes it here only.
+ */
+import { type ReactElement } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { MediaStreamTrackLike } from './platform/common.js';
+/** How long a view waits for its first frame before its native view is mounted again (react-native-webrtc #1611). */
+export declare const FIRST_FRAME_TIMEOUT_MS = 3000;
+export interface VideoTrackProps {
+    /**
+     * The video to show: a remote track's `track`, or your camera (`useLocalMedia().stream?.getVideoTracks()[0]`). Nothing
+     * while null. Typed by shape (`MediaStreamTrackLike`), so the app needs no DOM library for it.
+     */
+    track: MediaStreamTrackLike | null | undefined;
+    /**
+     * The remote video's `producerId`: it is then received at the size this view is shown and paused at the server while
+     * the view is not `visible` (adaptive stream). Leave it out for your own camera.
+     */
+    producerId?: string;
+    /** Flip it horizontally, as people expect to see their own front camera. */
+    mirror?: boolean;
+    /** `cover` (the default: fill the view, cropping) or `contain` (all of the picture, with bars). */
+    objectFit?: 'cover' | 'contain';
+    /** Which of two overlapping videos is on top (RTCView's zOrder): 0 for a full-screen video, 1 for a preview over it. */
+    zOrder?: number;
+    /** Whether the view can be seen now (a list scrolled past it, a hidden tab): with `producerId`, the video pauses at the server while false. */
+    visible?: boolean;
+    /** The video's size in pixels: its first frame arrived, or the size changed. */
+    onDimensionsChange?: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/** A video track in an RTCView, sized by `style`. */
+export declare function VideoTrack({ track, producerId, mirror, objectFit, zOrder, visible, onDimensionsChange, style, testID, }: VideoTrackProps): ReactElement;
+export interface AudioTrackProps {
+    /** The audio to set: a remote track's `track`. Nothing while null. Typed by shape (`MediaStreamTrackLike`). */
+    track: MediaStreamTrackLike | null | undefined;
+    /** 0 to 1, clamped (1 is the track as received). Unset leaves it as it is. This track only. */
+    volume?: number;
+    /** Silence it here only (the track is switched off while muted, and back on after). */
+    muted?: boolean;
+}
+/** One remote audio track's volume, or muted, while mounted. Renders nothing: React Native plays remote audio itself. */
+export declare function AudioTrack({ track, volume, muted }: AudioTrackProps): null;
+//# sourceMappingURL=components.d.ts.map

package/lib/typescript/module/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/components.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAA4C,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AACpF,OAAO,EAA4C,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAMxG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAmB,CAAC;AAE9D,qHAAqH;AACrH,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,KAAK,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mGAAmG;IACnG,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAChC,wHAAwH;IACxH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+IAA+I;IAC/I,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gFAAgF;IAChF,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACvE,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID,qDAAqD;AACrD,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,UAAU,EACV,MAAc,EACd,SAAmB,EACnB,MAAM,EACN,OAAc,EACd,kBAAkB,EAClB,KAAK,EACL,MAAM,GACP,EAAE,eAAe,GAAG,YAAY,CAsHhC;AAED,MAAM,WAAW,eAAe;IAC9B,+GAA+G;IAC/G,KAAK,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AASD,yHAAyH;AACzH,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAa,EAAE,EAAE,eAAe,GAAG,IAAI,CAgClF"}

package/lib/typescript/module/create-client.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A StreamClient for React Native: react-native-webrtc's mediasoup handler (ReactNative106) and this package's
+ * platform, with the background pause on for the camera. The provider makes its clients this way; an app that makes and
+ * owns its client (the provider's `client` prop, a PK battle's second client) uses createClient.
+ */
+import { StreamClient, type ClientOptions } from '@voltkit-rtc/client';
+/** What happens to the camera and microphone while the app is in the background. */
+export interface BackgroundOptions {
+    /**
+     * Switch the camera off while the app is in the background or the screen is off, and back on when it returns (only
+     * if this switched it off): viewers see the camera off rather than a frozen picture. Android stops a background
+     * app's camera anyway. Default true.
+     */
+    pauseCamera?: boolean;
+    /** The same for the microphone. Leave it off for calls, which go on talking in the background. Default false. */
+    pauseMic?: boolean;
+}
+export interface CreateClientOptions {
+    /** The background pause: camera on by default, microphone off. */
+    background?: BackgroundOptions;
+    /** StreamClient options of your own; they win over the ones set here. */
+    clientOptions?: ClientOptions;
+}
+/**
+ * The ClientOptions a React Native client is made with: `{ handlerName: 'ReactNative106', platform,
+ * pauseCameraInBackground, pauseMicInBackground, ...clientOptions }`.
+ */
+export declare function reactNativeClientOptions(options?: CreateClientOptions): ClientOptions;
+/**
+ * A StreamClient for React Native, not yet connected: call `connect()`. Throws `media-unavailable` with
+ * `{ reason: 'webrtc-missing' }` where react-native-webrtc's native module is missing (Expo Go: it needs a development
+ * build).
+ */
+export declare function createClient(wsUrl: string, token: string, options?: CreateClientOptions): StreamClient;
+//# sourceMappingURL=create-client.d.ts.map

package/lib/typescript/module/create-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-client.d.ts","sourceRoot":"","sources":["../../../src/create-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKvE,oFAAoF;AACpF,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iHAAiH;IACjH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,yEAAyE;IACzE,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,mBAAwB,GAAG,aAAa,CASzF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAG1G"}