@adeeliore/p2p-core 0.1.0

package/API_REFERENCE.md

@@ -0,0 +1,164 @@
+# API Reference
+
+## Install
+
+```bash
+npm install @adeeliore/p2p-core react-native-webrtc
+```
+
+## 1. Create A Session
+
+```ts
+import { createP2PSession } from '@adeeliore/p2p-core';
+
+const session = createP2PSession({
+  signalBaseUrl: 'wss://example.com',
+  sessionId: 'ROOM-1234',
+  clientId: 'teacher',
+  accessToken: 'shared-secret',
+  autoCreateOffers: true,
+});
+```
+
+### `createP2PSession(options)`
+
+Creates the main runtime object used by the application.
+
+Important options:
+
+- `signalBaseUrl`: base URL for the built-in WebSocket signaling provider.
+- `signalingProvider`: custom provider when the built-in WebSocket transport is not used.
+- `sessionId`: logical room id.
+- `clientId`: optional desired client id.
+- `accessToken`: shared token sent to signaling.
+- `autoCreateOffers`: whether offers should be created automatically.
+- `offerDelayMs`: delay before automatic offer creation.
+- `rtcConfig`: custom ICE server config.
+- `heartbeat`: heartbeat timing overrides.
+- `reconnect`: reconnect timing overrides.
+
+## 2. Connect And Disconnect
+
+```ts
+session.connect();
+session.disconnect();
+```
+
+### Runtime methods
+
+- `connect()`: opens signaling transport and starts the runtime.
+- `disconnect(code?, reason?)`: closes signaling and all peers.
+- `isConnected()`: returns current signaling connectivity state.
+- `getState()`: returns current session snapshot.
+- `getLocalPeerId()`: returns the resolved local peer id.
+- `getPeerIds()`: returns current remote peer ids.
+
+## 3. Listen To Events
+
+```ts
+session.on('welcome', ({ clientId, peers }) => {
+  console.log(clientId, peers);
+});
+
+session.on('peerDataOpen', ({ peerId, joinKind }) => {
+  console.log('ready', peerId, joinKind);
+});
+
+session.on('peerMessage', ({ peerId, message }) => {
+  console.log(peerId, JSON.parse(message));
+});
+```
+
+### Event names
+
+- `signalingOpen`
+- `signalingClose`
+- `signalingError`
+- `protocolError`
+- `serverError`
+
+Error-bearing events such as `signalingError`, `transportError` and `protocolError`
+carry stable error codes so app code can react without parsing free-form strings.
+- `welcome`
+- `peerJoined`
+- `peerLeft`
+- `peerDataOpen`
+- `peerDataClose`
+- `peerMessage`
+- `iceStateChange`
+- `transportError`
+- `pong`
+
+## 4. Send P2P Messages
+
+```ts
+session.sendTo('peer-a', JSON.stringify({
+  type: 'presence',
+  payload: { state: 'ready' },
+}));
+
+session.broadcast(JSON.stringify({
+  type: 'cursor',
+  payload: { x: 12, y: 44 },
+}));
+```
+
+### Messaging methods
+
+- `sendTo(peerId, message)`: sends one raw string to a peer.
+- `broadcast(message, peerIds?)`: sends one raw string to all peers or a subset.
+- `createOffer(peerId)`: explicitly creates an offer for a peer.
+- `sendPing()`: sends signaling-level ping through the provider.
+
+## 5. Add Sync Domains
+
+```ts
+import { createP2PSyncEngine } from '@adeeliore/p2p-core';
+
+const sync = createP2PSyncEngine(session);
+
+sync.registerDomain({
+  domain: 'poll',
+  strategy: 'snapshot-and-live',
+  getSnapshot: () => pollStore.exportSnapshot(),
+  applySnapshot: (snapshot) => pollStore.importSnapshot(snapshot),
+  applyEvent: (event) => pollStore.applyRemoteEvent(event),
+});
+```
+
+### `createP2PSyncEngine(session)`
+
+Creates a sync engine on top of an existing `P2PSession`.
+
+### Sync engine methods
+
+- `registerDomain(registration)`: registers one domain and returns an unsubscribe function.
+- `sendEvent(domain, payload, options?)`: sends a domain event.
+- `requestSnapshot(domain, targetPeerId)`: requests state from a peer.
+- `destroy()`: removes listeners and clears internal registrations.
+
+### Sync strategies
+
+- `events`: only live events, no snapshots.
+- `pull-on-connect`: ask existing peers for snapshot after connect.
+- `push-to-new-peer`: push snapshot to newly joined peers.
+- `snapshot-and-live`: combine snapshots with live event stream.
+
+## 6. Use A Custom Signaling Provider
+
+```ts
+const session = createP2PSession({
+  sessionId: 'ROOM-1234',
+  signalingProvider: myProvider,
+});
+```
+
+Provider contract methods:
+
+- `connect(options, handlers)`
+- `disconnect(code?, reason?)`
+- `sendPing()`
+- `sendRelay(type, to, payload)`
+- `isConnected()`
+
+`@adeeliore/p2p-lan-signaling` implements this contract for LAN/offline sessions.

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+Initial package extraction from DrawingApp.
+
+Included in this release:
+
+- signaling client
+- WebRTC peer manager
+- high-level `P2PSession` runtime
+- TypeScript public API
+- package-level docs and example

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright (C) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+# `@adeeliore/p2p-core`
+
+Reusable P2P session runtime for React Native collaborative apps.
+
+This package gives you a focused application runtime for:
+
+- signaling connection management;
+- WebRTC peer lifecycle;
+- DataChannel messaging;
+- reconnect and heartbeat behavior;
+- domain-level synchronization through a sync engine.
+
+It does not own your product protocol or state model. You keep control over:
+
+- payload format;
+- board, poll, chat or document state;
+- snapshot strategy;
+- QR or room-discovery flows;
+- UI and platform-specific setup.
+
+## Installation
+
+```bash
+npm install @adeeliore/p2p-core react-native-webrtc
+```
+
+## Primary Use Case
+
+Use `@adeeliore/p2p-core` when your app needs:
+
+- a room/session abstraction above WebRTC;
+- signaling over WebSocket or a custom provider;
+- peer events exposed as a clean API;
+- a reusable sync mechanism for multiple app domains.
+
+## Quick Start
+
+```ts
+import { createP2PSession } from '@adeeliore/p2p-core';
+
+const session = createP2PSession({
+  signalBaseUrl: 'wss://example.com',
+  sessionId: 'ROOM-1234',
+  clientId: 'teacher',
+  accessToken: 'shared-secret',
+  autoCreateOffers: true,
+});
+
+session.on('welcome', ({ clientId, peers }) => {
+  console.log('local peer', clientId);
+  console.log('existing peers', peers);
+});
+
+session.on('peerDataOpen', ({ peerId }) => {
+  console.log('ready for P2P messages', peerId);
+});
+
+session.on('peerMessage', ({ peerId, message }) => {
+  console.log('message from', peerId, JSON.parse(message));
+});
+
+session.connect();
+```
+
+## Sending App Messages
+
+`p2p-core` transports strings. Most apps serialize JSON and keep protocol ownership in application code.
+
+```ts
+session.broadcast(JSON.stringify({
+  type: 'cursor',
+  payload: { x: 120, y: 48 },
+}));
+
+session.sendTo('peer-a', JSON.stringify({
+  type: 'presence',
+  payload: { state: 'ready' },
+}));
+```
+
+## Using The Sync Engine
+
+The sync engine is the package-level mechanism for domain synchronization.
+
+```ts
+import { createP2PSession, createP2PSyncEngine } from '@adeeliore/p2p-core';
+
+const session = createP2PSession({
+  signalBaseUrl: 'wss://example.com',
+  sessionId: 'ROOM-1234',
+});
+
+const sync = createP2PSyncEngine(session);
+
+sync.registerDomain({
+  domain: 'board',
+  strategy: 'snapshot-and-live',
+  getSnapshot: () => boardStore.exportSnapshot(),
+  applySnapshot: (snapshot) => boardStore.importSnapshot(snapshot),
+  applyEvent: (event) => boardStore.applyRemoteEvent(event),
+});
+
+session.connect();
+
+sync.sendEvent('board', {
+  type: 'drawPath',
+  payload: { points: [10, 12, 15, 20] },
+});
+```
+
+Built-in strategies:
+
+- `events`
+- `pull-on-connect`
+- `push-to-new-peer`
+- `snapshot-and-live`
+
+## Using A Custom Signaling Provider
+
+If you do not want the built-in WebSocket provider, pass your own `signalingProvider`.
+
+```ts
+import { createP2PSession } from '@adeeliore/p2p-core';
+
+const session = createP2PSession({
+  sessionId: 'ROOM-1234',
+  signalingProvider: myCustomProvider,
+});
+```
+
+This is how `@adeeliore/p2p-lan-signaling` plugs into the same runtime.
+
+## Consumer API
+
+Most consumers only need:
+
+- `createP2PSession`
+- `createP2PSyncEngine`
+- `session.connect()`
+- `session.disconnect()`
+- `session.on(...)`
+- `session.sendTo(...)`
+- `session.broadcast(...)`
+
+## Error Model
+
+Runtime error payloads include stable error codes.
+
+Examples:
+
+- `ERR_SIGNALING_CONFIGURATION_REQUIRED`
+- `ERR_SIGNALING_PROVIDER_ERROR`
+- `ERR_SIGNALING_CONNECT_FAILED`
+- `ERR_SIGNALING_NOT_CONNECTED`
+- `ERR_PEER_MANAGER_UNAVAILABLE`
+- `ERR_TRANSPORT_SEND_FAILED`
+- `ERR_RELAY_SEND_FAILED`
+- `ERR_PROTOCOL_INVALID_MESSAGE`
+
+## Documentation
+
+- usage-oriented API reference: [API_REFERENCE.md](/Users/whoami/diplom-p2p/DrawingApp/packages/p2p-core/API_REFERENCE.md)
+- changelog: [CHANGELOG.md](/Users/whoami/diplom-p2p/DrawingApp/packages/p2p-core/CHANGELOG.md)
+- example: [examples/basic-session.ts](/Users/whoami/diplom-p2p/DrawingApp/packages/p2p-core/examples/basic-session.ts)

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+export declare const P2P_CORE_ERROR_CODE: {
+    readonly SIGNALING_CONFIGURATION_REQUIRED: "ERR_SIGNALING_CONFIGURATION_REQUIRED";
+    readonly SIGNALING_PROVIDER_ERROR: "ERR_SIGNALING_PROVIDER_ERROR";
+    readonly SIGNALING_CONNECT_FAILED: "ERR_SIGNALING_CONNECT_FAILED";
+    readonly SIGNALING_NOT_CONNECTED: "ERR_SIGNALING_NOT_CONNECTED";
+    readonly PEER_MANAGER_UNAVAILABLE: "ERR_PEER_MANAGER_UNAVAILABLE";
+    readonly TRANSPORT_SEND_FAILED: "ERR_TRANSPORT_SEND_FAILED";
+    readonly RELAY_SEND_FAILED: "ERR_RELAY_SEND_FAILED";
+    readonly PROTOCOL_INVALID_MESSAGE: "ERR_PROTOCOL_INVALID_MESSAGE";
+};
+export type P2PCoreErrorCode = typeof P2P_CORE_ERROR_CODE[keyof typeof P2P_CORE_ERROR_CODE];
+export interface P2PCoreErrorPayload {
+    code: P2PCoreErrorCode;
+    message: string;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;;;;;;;;;CAStB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GACxB,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACnB"}

package/dist/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.P2P_CORE_ERROR_CODE = void 0;
+exports.P2P_CORE_ERROR_CODE = {
+    SIGNALING_CONFIGURATION_REQUIRED: 'ERR_SIGNALING_CONFIGURATION_REQUIRED',
+    SIGNALING_PROVIDER_ERROR: 'ERR_SIGNALING_PROVIDER_ERROR',
+    SIGNALING_CONNECT_FAILED: 'ERR_SIGNALING_CONNECT_FAILED',
+    SIGNALING_NOT_CONNECTED: 'ERR_SIGNALING_NOT_CONNECTED',
+    PEER_MANAGER_UNAVAILABLE: 'ERR_PEER_MANAGER_UNAVAILABLE',
+    TRANSPORT_SEND_FAILED: 'ERR_TRANSPORT_SEND_FAILED',
+    RELAY_SEND_FAILED: 'ERR_RELAY_SEND_FAILED',
+    PROTOCOL_INVALID_MESSAGE: 'ERR_PROTOCOL_INVALID_MESSAGE',
+};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { P2P_CORE_ERROR_CODE, } from './errors';
+export type { P2PCoreErrorCode, P2PCoreErrorPayload, } from './errors';
+export { WEBRTC_CONFIG_DIAGNOSTICS } from './rtc/constants';
+export { createWebRtcPeerManager, isWebRtcRuntimeAvailable } from './rtc/runtime';
+export type { IceConnectionState, WebRtcConfiguration, WebRtcHeartbeatConfig, WebRtcReconnectConfig, } from './rtc/types';
+export { createP2PSession } from './session/P2PSession';
+export type { P2PSession, P2PSessionErrorEvent, P2PSessionEventMap, P2PSessionIceStateChangeEvent, P2PSessionOptions, P2PSessionPeerDataOpenEvent, P2PSessionPeerEvent, P2PSessionPeerMessageEvent, P2PSessionProtocolErrorEvent, P2PSessionServerErrorEvent, P2PSessionSignalingCloseEvent, P2PSessionState, P2PSessionStatus, P2PSessionTransportErrorEvent, P2PSessionWelcomeEvent, PeerJoinKind, } from './session/types';
+export { createWebSocketSignalingProvider, WebSocketSignalingProvider, } from './signaling/provider';
+export type { SignalingProvider, SignalingProviderCloseEvent, SignalingProviderConnectOptions, SignalingProviderErrorEvent, SignalingProviderHandlers, SignalingProviderStatus, WebSocketSignalingProviderOptions, } from './signaling/provider';
+export { createP2PSyncEngine } from './sync/engine';
+export { DEFAULT_SYNC_STRATEGY, SYNC_NAMESPACE, SYNC_STRATEGY, SYNC_VERSION, } from './sync/constants';
+export type { P2PSyncEngine, SyncDomainRegistration, SyncEnvelope, SyncEventContext, SyncEventSendOptions, SyncSnapshotContext, SyncStrategy, } from './sync/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,mBAAmB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EACR,gBAAgB,EAChB,mBAAmB,GACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAClF,YAAY,EACR,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,GACxB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,YAAY,EACR,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,6BAA6B,EAC7B,iBAAiB,EACjB,2BAA2B,EAC3B,mBAAmB,EACnB,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,6BAA6B,EAC7B,eAAe,EACf,gBAAgB,EAChB,6BAA6B,EAC7B,sBAAsB,EACtB,YAAY,GACf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACH,gCAAgC,EAChC,0BAA0B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACR,iBAAiB,EACjB,2BAA2B,EAC3B,+BAA+B,EAC/B,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,iCAAiC,GACpC,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACH,qBAAqB,EACrB,cAAc,EACd,aAAa,EACb,YAAY,GACf,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACR,aAAa,EACb,sBAAsB,EACtB,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,GACf,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNC_VERSION = exports.SYNC_STRATEGY = exports.SYNC_NAMESPACE = exports.DEFAULT_SYNC_STRATEGY = exports.createP2PSyncEngine = exports.WebSocketSignalingProvider = exports.createWebSocketSignalingProvider = exports.createP2PSession = exports.isWebRtcRuntimeAvailable = exports.createWebRtcPeerManager = exports.WEBRTC_CONFIG_DIAGNOSTICS = exports.P2P_CORE_ERROR_CODE = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "P2P_CORE_ERROR_CODE", { enumerable: true, get: function () { return errors_1.P2P_CORE_ERROR_CODE; } });
+var constants_1 = require("./rtc/constants");
+Object.defineProperty(exports, "WEBRTC_CONFIG_DIAGNOSTICS", { enumerable: true, get: function () { return constants_1.WEBRTC_CONFIG_DIAGNOSTICS; } });
+var runtime_1 = require("./rtc/runtime");
+Object.defineProperty(exports, "createWebRtcPeerManager", { enumerable: true, get: function () { return runtime_1.createWebRtcPeerManager; } });
+Object.defineProperty(exports, "isWebRtcRuntimeAvailable", { enumerable: true, get: function () { return runtime_1.isWebRtcRuntimeAvailable; } });
+var P2PSession_1 = require("./session/P2PSession");
+Object.defineProperty(exports, "createP2PSession", { enumerable: true, get: function () { return P2PSession_1.createP2PSession; } });
+var provider_1 = require("./signaling/provider");
+Object.defineProperty(exports, "createWebSocketSignalingProvider", { enumerable: true, get: function () { return provider_1.createWebSocketSignalingProvider; } });
+Object.defineProperty(exports, "WebSocketSignalingProvider", { enumerable: true, get: function () { return provider_1.WebSocketSignalingProvider; } });
+var engine_1 = require("./sync/engine");
+Object.defineProperty(exports, "createP2PSyncEngine", { enumerable: true, get: function () { return engine_1.createP2PSyncEngine; } });
+var constants_2 = require("./sync/constants");
+Object.defineProperty(exports, "DEFAULT_SYNC_STRATEGY", { enumerable: true, get: function () { return constants_2.DEFAULT_SYNC_STRATEGY; } });
+Object.defineProperty(exports, "SYNC_NAMESPACE", { enumerable: true, get: function () { return constants_2.SYNC_NAMESPACE; } });
+Object.defineProperty(exports, "SYNC_STRATEGY", { enumerable: true, get: function () { return constants_2.SYNC_STRATEGY; } });
+Object.defineProperty(exports, "SYNC_VERSION", { enumerable: true, get: function () { return constants_2.SYNC_VERSION; } });

package/dist/rtc/PeerConnectionManager.d.ts

@@ -0,0 +1,34 @@
+import { WebRtcConfiguration, WebRtcEvents, WebRtcHeartbeatConfig, WebRtcReconnectConfig, WebRtcPeerManager, WebRtcSignalEmitter } from './types';
+interface PeerConnectionManagerOptions {
+    signalEmitter: WebRtcSignalEmitter;
+    events?: WebRtcEvents;
+    rtcConfig?: WebRtcConfiguration;
+    heartbeat?: WebRtcHeartbeatConfig;
+    reconnect?: WebRtcReconnectConfig;
+}
+export declare class PeerConnectionManager implements WebRtcPeerManager {
+    private readonly signalEmitter;
+    private readonly events;
+    private readonly rtcConfig;
+    private readonly peers;
+    private readonly heartbeatConfig;
+    private readonly reconnectConfig;
+    constructor(options: PeerConnectionManagerOptions);
+    createOffer(peerId: string): Promise<void>;
+    handleRemoteOffer(peerId: string, payload: unknown): Promise<void>;
+    handleRemoteAnswer(peerId: string, payload: unknown): Promise<void>;
+    handleRemoteIce(peerId: string, payload: unknown): Promise<void>;
+    sendData(peerId: string, message: string): void;
+    closePeer(peerId: string): void;
+    closeAll(): void;
+    private getOrCreatePeerContext;
+    private attachDataChannel;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private handleIceStateChange;
+    private scheduleReconnect;
+    private stopReconnect;
+    private handleHeartbeatMessage;
+}
+export {};
+//# sourceMappingURL=PeerConnectionManager.d.ts.map

package/dist/rtc/PeerConnectionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeerConnectionManager.d.ts","sourceRoot":"","sources":["../../src/rtc/PeerConnectionManager.ts"],"names":[],"mappings":"AAIA,OAAO,EAGH,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACtB,MAAM,SAAS,CAAC;AA2BjB,UAAU,4BAA4B;IAClC,aAAa,EAAE,mBAAmB,CAAC;IACnC,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC,SAAS,CAAC,EAAE,qBAAqB,CAAC;CACrC;AAED,qBAAa,qBAAsB,YAAW,iBAAiB;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;IAClE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;gBAEtD,OAAO,EAAE,4BAA4B;IAQ3C,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB1C,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAelE,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnE,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAa/C,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAgB/B,QAAQ,IAAI,IAAI;IAKhB,OAAO,CAAC,sBAAsB;IAiD9B,OAAO,CAAC,iBAAiB;IA0BzB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,sBAAsB;CAgBjC"}