@xtr-dev/rondevu-client 0.18.10 → 0.21.1

package/dist/{answerer-connection.js → connections/answerer.js}

@@ -1,16 +1,17 @@
 /**
  * Answerer-side WebRTC connection with answer creation and offer processing
  */
-import { RondevuConnection } from './connection.js';
-import { ConnectionState } from './connection-events.js';
+import { RondevuConnection } from './base.js';
+import { ConnectionState } from './events.js';
 /**
  * Answerer connection - processes offers and creates answers
  */
 export class AnswererConnection extends RondevuConnection {
     constructor(options) {
-        super(options.rtcConfig, options.config);
+        super(options.rtcConfig, options.config, options.webrtcAdapter);
         this.api = options.api;
-        this.serviceFqn = options.serviceFqn;
+        this.ownerUsername = options.ownerUsername;
+        this.tags = options.tags;
         this.offerId = options.offerId;
         this.offerSdp = options.offerSdp;
     }
@@ -25,7 +26,7 @@ export class AnswererConnection extends RondevuConnection {
             throw new Error('Peer connection not created');
         // Setup ondatachannel handler BEFORE setting remote description
         // This is critical to avoid race conditions
-        this.pc.ondatachannel = (event) => {
+        this.pc.ondatachannel = event => {
             this.debug('Received data channel');
             this.dc = event.channel;
             this.setupDataChannelHandlers(this.dc);
@@ -43,7 +44,9 @@ export class AnswererConnection extends RondevuConnection {
         await this.pc.setLocalDescription(answer);
         this.debug('Answer created, sending to server');
         // Send answer to server
-        await this.api.answerOffer(this.serviceFqn, this.offerId, answer.sdp);
+        await this.api.answerOffer(this.offerId, answer.sdp);
+        // Note: ICE candidate polling is handled by PollingManager
+        // Candidates are received via handleRemoteIceCandidates()
         this.debug('Answer sent successfully');
     }
     /**
@@ -54,56 +57,41 @@ export class AnswererConnection extends RondevuConnection {
         // For answerer, we add ICE candidates to the offer
         // The server will make them available for the offerer to poll
         this.api
-            .addOfferIceCandidates(this.serviceFqn, this.offerId, [
+            .addOfferIceCandidates(this.offerId, [
             {
                 candidate: candidate.candidate,
                 sdpMLineIndex: candidate.sdpMLineIndex,
                 sdpMid: candidate.sdpMid,
             },
         ])
-            .catch((error) => {
+            .catch(error => {
             this.debug('Failed to send ICE candidate:', error);
         });
     }
     /**
-     * Poll for remote ICE candidates (from offerer)
+     * Get the API instance
      */
-    pollIceCandidates() {
-        this.api
-            .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastIcePollTime)
-            .then((result) => {
-            if (result.candidates.length > 0) {
-                this.debug(`Received ${result.candidates.length} remote ICE candidates`);
-                for (const iceCandidate of result.candidates) {
-                    // Only process ICE candidates from the offerer
-                    if (iceCandidate.role === 'offerer' && iceCandidate.candidate && this.pc) {
-                        const candidate = iceCandidate.candidate;
-                        this.pc
-                            .addIceCandidate(new RTCIceCandidate(candidate))
-                            .then(() => {
-                            this.emit('ice:candidate:remote', new RTCIceCandidate(candidate));
-                        })
-                            .catch((error) => {
-                            this.debug('Failed to add ICE candidate:', error);
-                        });
-                    }
-                    // Update last poll time
-                    if (iceCandidate.createdAt > this.lastIcePollTime) {
-                        this.lastIcePollTime = iceCandidate.createdAt;
-                    }
-                }
-            }
-        })
-            .catch((error) => {
-            this.debug('Failed to poll ICE candidates:', error);
-        });
+    getApi() {
+        return this.api;
+    }
+    /**
+     * Get the owner username
+     */
+    getOwnerUsername() {
+        return this.ownerUsername;
+    }
+    /**
+     * Answerers accept ICE candidates from offerers only
+     */
+    getIceCandidateRole() {
+        return 'offerer';
     }
     /**
-     * Attempt to reconnect
+     * Attempt to reconnect to the same user
      */
     attemptReconnect() {
-        this.debug('Attempting to reconnect');
-        // For answerer, we need to fetch a new offer and create a new answer
+        this.debug(`Attempting to reconnect to ${this.ownerUsername}`);
+        // For answerer, we need to fetch a new offer from the same user
         // Clean up old connection
         if (this.pc) {
             this.pc.close();
@@ -113,24 +101,31 @@ export class AnswererConnection extends RondevuConnection {
             this.dc.close();
             this.dc = null;
         }
-        // Fetch new offer from service
+        // Discover new offer using tags (use paginated mode to get array)
         this.api
-            .getService(this.serviceFqn)
-            .then((service) => {
-            if (!service || !service.offers || service.offers.length === 0) {
+            .discover({ tags: this.tags, limit: 100 })
+            .then(result => {
+            const response = result;
+            if (!response || !response.offers || response.offers.length === 0) {
                 throw new Error('No offers available for reconnection');
             }
-            // Pick a random offer
-            const offer = service.offers[Math.floor(Math.random() * service.offers.length)];
+            // Filter for offers from the same user
+            const userOffers = response.offers.filter(o => o.username === this.ownerUsername);
+            if (userOffers.length === 0) {
+                throw new Error(`No offers available from ${this.ownerUsername}`);
+            }
+            // Pick a random offer from the same user
+            const offer = userOffers[Math.floor(Math.random() * userOffers.length)];
             this.offerId = offer.offerId;
             this.offerSdp = offer.sdp;
+            this.debug(`Found new offer ${offer.offerId} from ${this.ownerUsername}`);
             // Reinitialize with new offer
             return this.initialize();
         })
             .then(() => {
             this.emit('reconnect:success');
         })
-            .catch((error) => {
+            .catch(error => {
             this.debug('Reconnection failed:', error);
             this.emit('reconnect:failed', error);
             this.scheduleReconnect();
@@ -142,4 +137,31 @@ export class AnswererConnection extends RondevuConnection {
     getOfferId() {
         return this.offerId;
     }
+    /**
+     * Handle remote ICE candidates received from polling
+     * Called by Rondevu when poll:ice event is received
+     */
+    handleRemoteIceCandidates(candidates) {
+        if (!this.pc) {
+            this.debug('Cannot add ICE candidates: peer connection not initialized');
+            return;
+        }
+        for (const iceCandidate of candidates) {
+            // Answerer only accepts offerer's candidates
+            if (iceCandidate.role !== 'offerer') {
+                continue;
+            }
+            if (iceCandidate.candidate) {
+                const rtcCandidate = this.webrtcAdapter.createIceCandidate(iceCandidate.candidate);
+                this.pc
+                    .addIceCandidate(rtcCandidate)
+                    .then(() => {
+                    this.emit('ice:candidate:remote', rtcCandidate);
+                })
+                    .catch(error => {
+                    this.debug('Failed to add ICE candidate:', error);
+                });
+            }
+        }
+    }
 }

package/dist/{connection.d.ts → connections/base.d.ts}

@@ -2,10 +2,11 @@
  * Base connection class with state machine, reconnection, and message buffering
  */
 import { EventEmitter } from 'eventemitter3';
-import { ConnectionConfig } from './connection-config.js';
-import { ConnectionState, ConnectionEventMap } from './connection-events.js';
-import { ExponentialBackoff } from './exponential-backoff.js';
-import { MessageBuffer } from './message-buffer.js';
+import { ConnectionConfig } from './config.js';
+import { ConnectionState, ConnectionEventMap } from './events.js';
+import { ExponentialBackoff } from '../utils/exponential-backoff.js';
+import { MessageBuffer } from '../utils/message-buffer.js';
+import { WebRTCAdapter } from '../webrtc/adapter.js';
 /**
  * Abstract base class for WebRTC connections with durability features
  */
@@ -15,6 +16,7 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
     protected dc: RTCDataChannel | null;
     protected state: ConnectionState;
     protected config: ConnectionConfig;
+    protected webrtcAdapter: WebRTCAdapter;
     protected messageBuffer: MessageBuffer | null;
     protected backoff: ExponentialBackoff | null;
     protected reconnectTimeout: ReturnType<typeof setTimeout> | null;
@@ -25,7 +27,7 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
     protected lastIcePollTime: number;
     protected answerProcessed: boolean;
     protected answerSdpFingerprint: string | null;
-    constructor(rtcConfig?: RTCConfiguration | undefined, userConfig?: Partial<ConnectionConfig>);
+    constructor(rtcConfig?: RTCConfiguration | undefined, userConfig?: Partial<ConnectionConfig>, webrtcAdapter?: WebRTCAdapter);
     /**
      * Transition to a new state and emit events
      */
@@ -82,6 +84,28 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
      * Stop ICE candidate polling
      */
     protected stopIcePolling(): void;
+    /**
+     * Get the API instance - subclasses must provide
+     */
+    protected abstract getApi(): any;
+    /**
+     * Get the owner username - subclasses must provide
+     */
+    protected abstract getOwnerUsername(): string;
+    /**
+     * Get the offer ID - subclasses must provide
+     */
+    protected abstract getOfferId(): string;
+    /**
+     * Get the ICE candidate role this connection should accept.
+     * Returns null for no filtering (offerer), or specific role (answerer accepts 'offerer').
+     */
+    protected abstract getIceCandidateRole(): 'offerer' | null;
+    /**
+     * Poll for remote ICE candidates (consolidated implementation)
+     * Subclasses implement getIceCandidateRole() to specify filtering
+     */
+    protected pollIceCandidates(): void;
     /**
      * Start connection timeout
      */
@@ -141,8 +165,7 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
     /**
      * Debug logging helper
      */
-    protected debug(...args: any[]): void;
+    protected debug(...args: unknown[]): void;
     protected abstract onLocalIceCandidate(candidate: RTCIceCandidate): void;
-    protected abstract pollIceCandidates(): void;
     protected abstract attemptReconnect(): void;
 }

package/dist/{connection.js → connections/base.js}

@@ -2,15 +2,16 @@
  * Base connection class with state machine, reconnection, and message buffering
  */
 import { EventEmitter } from 'eventemitter3';
-import { mergeConnectionConfig } from './connection-config.js';
-import { ConnectionState, } from './connection-events.js';
-import { ExponentialBackoff } from './exponential-backoff.js';
-import { MessageBuffer } from './message-buffer.js';
+import { mergeConnectionConfig } from './config.js';
+import { ConnectionState, } from './events.js';
+import { ExponentialBackoff } from '../utils/exponential-backoff.js';
+import { MessageBuffer } from '../utils/message-buffer.js';
+import { BrowserWebRTCAdapter } from '../webrtc/browser.js';
 /**
  * Abstract base class for WebRTC connections with durability features
  */
 export class RondevuConnection extends EventEmitter {
-    constructor(rtcConfig, userConfig) {
+    constructor(rtcConfig, userConfig, webrtcAdapter) {
         super();
         this.rtcConfig = rtcConfig;
         this.pc = null;
@@ -32,6 +33,7 @@ export class RondevuConnection extends EventEmitter {
         this.answerProcessed = false;
         this.answerSdpFingerprint = null;
         this.config = mergeConnectionConfig(userConfig);
+        this.webrtcAdapter = webrtcAdapter || new BrowserWebRTCAdapter();
         // Initialize message buffer if enabled
         if (this.config.bufferEnabled) {
             this.messageBuffer = new MessageBuffer({
@@ -81,9 +83,9 @@ export class RondevuConnection extends EventEmitter {
      * Create and configure RTCPeerConnection
      */
     createPeerConnection() {
-        this.pc = new RTCPeerConnection(this.rtcConfig);
+        this.pc = this.webrtcAdapter.createPeerConnection(this.rtcConfig);
         // Setup event handlers BEFORE any signaling
-        this.pc.onicecandidate = (event) => this.handleIceCandidate(event);
+        this.pc.onicecandidate = event => this.handleIceCandidate(event);
         this.pc.oniceconnectionstatechange = () => this.handleIceConnectionStateChange();
         this.pc.onconnectionstatechange = () => this.handleConnectionStateChange();
         this.pc.onicegatheringstatechange = () => this.handleIceGatheringStateChange();
@@ -95,8 +97,8 @@ export class RondevuConnection extends EventEmitter {
     setupDataChannelHandlers(dc) {
         dc.onopen = () => this.handleDataChannelOpen();
         dc.onclose = () => this.handleDataChannelClose();
-        dc.onerror = (error) => this.handleDataChannelError(error);
-        dc.onmessage = (event) => this.handleMessage(event);
+        dc.onerror = error => this.handleDataChannelError(error);
+        dc.onmessage = event => this.handleMessage(event);
     }
     /**
      * Handle local ICE candidate generation
@@ -121,7 +123,8 @@ export class RondevuConnection extends EventEmitter {
                 if (this.state === ConnectionState.SIGNALING) {
                     this.transitionTo(ConnectionState.CHECKING, 'ICE checking started');
                 }
-                this.startIcePolling();
+                // Note: ICE candidate polling is handled by PollingManager
+                // Candidates are received via handleRemoteIceCandidates()
                 break;
             case 'connected':
             case 'completed':
@@ -191,7 +194,9 @@ export class RondevuConnection extends EventEmitter {
         this.debug('Data channel opened');
         this.emit('datachannel:open');
         // Only transition to CONNECTED if ICE is also connected
-        if (this.pc && (this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed')) {
+        if (this.pc &&
+            (this.pc.iceConnectionState === 'connected' ||
+                this.pc.iceConnectionState === 'completed')) {
             this.transitionTo(ConnectionState.CONNECTED, 'Data channel opened and ICE connected');
             this.onConnected();
         }
@@ -256,9 +261,14 @@ export class RondevuConnection extends EventEmitter {
             return;
         this.debug('Starting ICE polling');
         this.emit('ice:polling:started');
-        this.lastIcePollTime = Date.now();
+        // Use 0 instead of Date.now() to get ALL existing candidates on first poll
+        // Remote candidates may have been created before this peer's ICE checking started
+        this.lastIcePollTime = 0;
+        const pollingStartTime = Date.now();
+        // Immediately poll for existing candidates
+        this.pollIceCandidates();
         this.icePollingInterval = setInterval(() => {
-            const elapsed = Date.now() - this.lastIcePollTime;
+            const elapsed = Date.now() - pollingStartTime;
             if (elapsed > this.config.icePollingTimeout) {
                 this.debug('ICE polling timeout');
                 this.stopIcePolling();
@@ -278,6 +288,46 @@ export class RondevuConnection extends EventEmitter {
         this.icePollingInterval = null;
         this.emit('ice:polling:stopped');
     }
+    /**
+     * Poll for remote ICE candidates (consolidated implementation)
+     * Subclasses implement getIceCandidateRole() to specify filtering
+     */
+    pollIceCandidates() {
+        const acceptRole = this.getIceCandidateRole();
+        const api = this.getApi();
+        const offerId = this.getOfferId();
+        api.getOfferIceCandidates(offerId, this.lastIcePollTime)
+            .then((result) => {
+            if (result.candidates.length > 0) {
+                this.debug(`Received ${result.candidates.length} remote ICE candidates`);
+                for (const iceCandidate of result.candidates) {
+                    // Filter by role if specified (answerer only filters for 'offerer')
+                    if (acceptRole !== null && iceCandidate.role !== acceptRole) {
+                        continue;
+                    }
+                    if (iceCandidate.candidate && this.pc) {
+                        const candidate = iceCandidate.candidate;
+                        const rtcCandidate = this.webrtcAdapter.createIceCandidate(candidate);
+                        this.pc
+                            .addIceCandidate(rtcCandidate)
+                            .then(() => {
+                            this.emit('ice:candidate:remote', rtcCandidate);
+                        })
+                            .catch(error => {
+                            this.debug('Failed to add ICE candidate:', error);
+                        });
+                    }
+                    // Update last poll time
+                    if (iceCandidate.createdAt > this.lastIcePollTime) {
+                        this.lastIcePollTime = iceCandidate.createdAt;
+                    }
+                }
+            }
+        })
+            .catch((error) => {
+            this.debug('Failed to poll ICE candidates:', error);
+        });
+    }
     /**
      * Start connection timeout
      */
@@ -329,7 +379,8 @@ export class RondevuConnection extends EventEmitter {
         if (!this.config.reconnectEnabled || !this.backoff)
             return;
         // Check if we've exceeded max attempts
-        if (this.config.maxReconnectAttempts > 0 && this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+        if (this.config.maxReconnectAttempts > 0 &&
+            this.reconnectAttempts >= this.config.maxReconnectAttempts) {
             this.debug('Max reconnection attempts reached');
             this.emit('reconnect:exhausted', this.reconnectAttempts);
             return;

package/dist/connections/config.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Connection configuration interfaces and defaults
+ */
+/**
+ * Simplified connection options for public API.
+ * Advanced options use sensible defaults.
+ */
+export interface ConnectionOptions {
+    /** Maximum time to wait for connection (ms). Default: 30000 */
+    timeout?: number;
+    /** Enable automatic reconnection on failures. Default: true */
+    reconnect?: boolean;
+    /** Maximum reconnection attempts (0 = infinite). Default: 5 */
+    maxReconnects?: number;
+    /** Buffer messages during disconnections. Default: true */
+    bufferMessages?: boolean;
+    /** Enable debug logging. Default: false */
+    debug?: boolean;
+}
+/**
+ * Full internal configuration with all options.
+ * Use ConnectionOptions for public API.
+ * @internal
+ */
+export interface ConnectionConfig {
+    connectionTimeout: number;
+    iceGatheringTimeout: number;
+    reconnectEnabled: boolean;
+    maxReconnectAttempts: number;
+    reconnectBackoffBase: number;
+    reconnectBackoffMax: number;
+    reconnectJitter: number;
+    bufferEnabled: boolean;
+    maxBufferSize: number;
+    maxBufferAge: number;
+    preserveBufferOnClose: boolean;
+    icePollingInterval: number;
+    icePollingTimeout: number;
+    debug: boolean;
+}
+export declare const DEFAULT_CONNECTION_CONFIG: ConnectionConfig;
+/**
+ * Merge user config with defaults.
+ * @internal
+ */
+export declare function mergeConnectionConfig(userConfig?: Partial<ConnectionConfig>): ConnectionConfig;
+/**
+ * Convert simplified ConnectionOptions to full ConnectionConfig.
+ * Maps user-friendly names to internal config.
+ */
+export declare function toConnectionConfig(options?: ConnectionOptions): ConnectionConfig;

package/dist/{connection-config.js → connections/config.js}

@@ -22,9 +22,29 @@ export const DEFAULT_CONNECTION_CONFIG = {
     // Debug
     debug: false,
 };
+/**
+ * Merge user config with defaults.
+ * @internal
+ */
 export function mergeConnectionConfig(userConfig) {
     return {
         ...DEFAULT_CONNECTION_CONFIG,
         ...userConfig,
     };
 }
+/**
+ * Convert simplified ConnectionOptions to full ConnectionConfig.
+ * Maps user-friendly names to internal config.
+ */
+export function toConnectionConfig(options) {
+    if (!options)
+        return DEFAULT_CONNECTION_CONFIG;
+    return {
+        ...DEFAULT_CONNECTION_CONFIG,
+        ...(options.timeout !== undefined && { connectionTimeout: options.timeout }),
+        ...(options.reconnect !== undefined && { reconnectEnabled: options.reconnect }),
+        ...(options.maxReconnects !== undefined && { maxReconnectAttempts: options.maxReconnects }),
+        ...(options.bufferMessages !== undefined && { bufferEnabled: options.bufferMessages }),
+        ...(options.debug !== undefined && { debug: options.debug }),
+    };
+}

package/dist/{connection-events.d.ts → connections/events.d.ts}

@@ -35,17 +35,17 @@ export interface StateChangeInfo {
  */
 export interface ConnectionEventMap {
     'state:changed': [StateChangeInfo];
-    'connecting': [];
-    'connected': [];
-    'disconnected': [reason?: string];
-    'failed': [error: Error];
-    'closed': [reason?: string];
+    connecting: [];
+    connected: [];
+    disconnected: [reason?: string];
+    failed: [error: Error];
+    closed: [reason?: string];
     'reconnect:scheduled': [ReconnectInfo];
     'reconnect:attempting': [attempt: number];
     'reconnect:success': [];
     'reconnect:failed': [error: Error];
     'reconnect:exhausted': [attempts: number];
-    'message': [data: string | ArrayBuffer | Blob];
+    message: [data: string | ArrayBuffer | Blob];
     'message:sent': [data: string | ArrayBuffer | Blob, buffered: boolean];
     'message:buffered': [data: string | ArrayBuffer | Blob];
     'message:replayed': [message: BufferedMessage];

package/dist/connections/offerer.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Offerer-side WebRTC connection with offer creation and answer processing
+ */
+import { RondevuConnection } from './base.js';
+import { RondevuAPI, IceCandidate } from '../api/client.js';
+import { ConnectionConfig } from './config.js';
+import { WebRTCAdapter } from '../webrtc/adapter.js';
+export interface OffererOptions {
+    api: RondevuAPI;
+    ownerUsername: string;
+    offerId: string;
+    pc: RTCPeerConnection;
+    dc?: RTCDataChannel;
+    webrtcAdapter?: WebRTCAdapter;
+    config?: Partial<ConnectionConfig>;
+}
+/**
+ * Offerer connection - manages already-created offers and waits for answers
+ */
+export declare class OffererConnection extends RondevuConnection {
+    private api;
+    private ownerUsername;
+    private offerId;
+    private _peerUsername;
+    private rotationLock;
+    private rotating;
+    private rotationAttempts;
+    private static readonly MAX_ROTATION_ATTEMPTS;
+    private pendingIceCandidates;
+    constructor(options: OffererOptions);
+    /**
+     * Initialize the connection - setup handlers for already-created offer
+     */
+    initialize(): Promise<void>;
+    /**
+     * Process an answer from the answerer
+     */
+    processAnswer(sdp: string, answererId: string): Promise<void>;
+    /**
+     * Rebind this connection to a new offer (when previous offer failed)
+     * Keeps the same connection object alive but with new underlying WebRTC
+     */
+    rebindToOffer(newOfferId: string, newPc: RTCPeerConnection, newDc?: RTCDataChannel): Promise<void>;
+    /**
+     * Check if connection is currently rotating
+     */
+    isRotating(): boolean;
+    /**
+     * Override onConnected to reset rotation attempts
+     */
+    protected onConnected(): void;
+    /**
+     * Generate a hash fingerprint of SDP for deduplication
+     */
+    private hashSdp;
+    /**
+     * Handle local ICE candidate generation
+     */
+    protected onLocalIceCandidate(candidate: RTCIceCandidate): void;
+    /**
+     * Get the API instance
+     */
+    protected getApi(): any;
+    /**
+     * Get the owner username
+     */
+    protected getOwnerUsername(): string;
+    /**
+     * Offerers accept all ICE candidates (no filtering)
+     */
+    protected getIceCandidateRole(): 'offerer' | null;
+    /**
+     * Attempt to reconnect (required by abstract base class)
+     *
+     * For OffererConnection, traditional reconnection is NOT used.
+     * Instead, the OfferPool handles failures via offer rotation:
+     *
+     * 1. When this connection fails, the 'failed' event is emitted
+     * 2. OfferPool detects the failure and calls createNewOfferForRotation()
+     * 3. The new offer is published to the server
+     * 4. This connection is rebound via rebindToOffer()
+     *
+     * This approach ensures the answerer always gets a fresh offer
+     * rather than trying to reconnect to a stale one.
+     *
+     * @see OfferPool.createNewOfferForRotation() - creates replacement offer
+     * @see OffererConnection.rebindToOffer() - rebinds connection to new offer
+     */
+    protected attemptReconnect(): void;
+    /**
+     * Get the offer ID
+     */
+    getOfferId(): string;
+    /**
+     * Get the peer username (who answered this offer)
+     * Returns null if no answer has been processed yet
+     */
+    get peerUsername(): string | null;
+    /**
+     * Handle remote ICE candidates received from polling
+     * Called by OfferPool when poll:ice event is received
+     */
+    handleRemoteIceCandidates(candidates: IceCandidate[]): void;
+    /**
+     * Apply ICE candidates to the peer connection
+     */
+    private applyIceCandidates;
+}