@layercode/js-sdk 1.0.25 → 1.0.27

package/dist/layercode-js-sdk.esm.js

@@ -3477,6 +3477,8 @@ function arrayBufferToBase64(arrayBuffer) {
 }
 
 /* eslint-env browser */
+// SDK version - updated when publishing
+const SDK_VERSION = '1.0.27';
 /**
  * @class LayercodeClient
  * @classdesc Core client for Layercode audio pipeline that manages audio recording, WebSocket communication, and speech processing.
@@ -3487,6 +3489,7 @@ class LayercodeClient {
      * @param {Object} options - Configuration options
      */
     constructor(options) {
+        this.deviceId = null;
         this.options = {
             pipelineId: options.pipelineId,
             sessionId: options.sessionId || null,
@@ -3496,6 +3499,7 @@ class LayercodeClient {
             onConnect: options.onConnect || (() => { }),
             onDisconnect: options.onDisconnect || (() => { }),
             onError: options.onError || (() => { }),
+            onDeviceSwitched: options.onDeviceSwitched || (() => { }),
             onDataMessage: options.onDataMessage || (() => { }),
             onUserAmplitudeChange: options.onUserAmplitudeChange || (() => { }),
             onAgentAmplitudeChange: options.onAgentAmplitudeChange || (() => { }),
@@ -3519,198 +3523,99 @@ class LayercodeClient {
         this.pushToTalkEnabled = false;
         this.canInterrupt = false;
         this.userIsSpeaking = false;
-        this.endUserTurn = false;
         this.recorderStarted = false;
         this.readySent = false;
         this.currentTurnId = null;
         this.audioBuffer = [];
-        this.audioPauseTime = null;
+        this.vadConfig = null;
+        // this.audioPauseTime = null;
         // Bind event handlers
         this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
         this._handleDataAvailable = this._handleDataAvailable.bind(this);
-    }
-    _setupAmplitudeBasedVAD() {
-        let isSpeakingByAmplitude = false;
-        let silenceFrames = 0;
-        const AMPLITUDE_THRESHOLD = 0.01; // Adjust based on testing
-        const SILENCE_FRAMES_THRESHOLD = 30; // ~600ms at 20ms chunks
-        // Monitor amplitude changes
-        this.wavRecorder.startAmplitudeMonitoring((amplitude) => {
-            const wasSpeaking = isSpeakingByAmplitude;
-            if (amplitude > AMPLITUDE_THRESHOLD) {
-                silenceFrames = 0;
-                if (!wasSpeaking) {
-                    // Speech started - pause audio if playing and track timing for interruption calculation
-                    if (this.canInterrupt && this.wavPlayer.isPlaying) {
-                        this.audioPauseTime = Date.now();
-                        this.wavPlayer.pause();
-                    }
-                    isSpeakingByAmplitude = true;
-                    this.userIsSpeaking = true;
-                    this.options.onUserIsSpeakingChange(true);
-                    this._wsSend({
-                        type: 'vad_events',
-                        event: 'vad_start',
-                    });
-                }
-            }
-            else {
-                silenceFrames++;
-                if (wasSpeaking && silenceFrames >= SILENCE_FRAMES_THRESHOLD) {
-                    // Speech ended
-                    isSpeakingByAmplitude = false;
-                    this.userIsSpeaking = false;
-                    this.options.onUserIsSpeakingChange(false);
-                    this._wsSend({
-                        type: 'vad_events',
-                        event: 'vad_end',
-                    });
-                }
-            }
-        });
+        this._setupDeviceChangeListener();
     }
     _initializeVAD() {
-        console.log('initializing VAD', { pushToTalkEnabled: this.pushToTalkEnabled, canInterrupt: this.canInterrupt });
+        var _a;
+        console.log('initializing VAD', { pushToTalkEnabled: this.pushToTalkEnabled, canInterrupt: this.canInterrupt, vadConfig: this.vadConfig });
         // If we're in push to talk mode, we don't need to use the VAD model
         if (this.pushToTalkEnabled) {
             return;
         }
-        const timeout = setTimeout(() => {
-            console.log('silero vad model timeout');
-            console.warn('VAD model failed to load - falling back to amplitude-based detection');
+        // Check if VAD is disabled
+        if (((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) === false) {
+            console.log('VAD is disabled by backend configuration');
+            return;
+        }
+        // Build VAD configuration object, only including keys that are defined
+        const vadOptions = {
+            stream: this.wavRecorder.getStream() || undefined,
+            onSpeechStart: () => {
+                console.log('onSpeechStart: sending vad_start');
+                this.userIsSpeaking = true;
+                this.options.onUserIsSpeakingChange(true);
+                this._wsSend({
+                    type: 'vad_events',
+                    event: 'vad_start',
+                });
+            },
+            onSpeechEnd: () => {
+                console.log('onSpeechEnd: sending vad_end');
+                this.userIsSpeaking = false;
+                this.options.onUserIsSpeakingChange(false);
+                this.audioBuffer = []; // Clear buffer on speech end
+                this._wsSend({
+                    type: 'vad_events',
+                    event: 'vad_end',
+                });
+            },
+        };
+        // Apply VAD configuration from backend if available
+        if (this.vadConfig) {
+            // Only add keys that are explicitly defined (not undefined)
+            if (this.vadConfig.model !== undefined)
+                vadOptions.model = this.vadConfig.model;
+            if (this.vadConfig.positive_speech_threshold !== undefined)
+                vadOptions.positiveSpeechThreshold = this.vadConfig.positive_speech_threshold;
+            if (this.vadConfig.negative_speech_threshold !== undefined)
+                vadOptions.negativeSpeechThreshold = this.vadConfig.negative_speech_threshold;
+            if (this.vadConfig.redemption_frames !== undefined)
+                vadOptions.redemptionFrames = this.vadConfig.redemption_frames;
+            if (this.vadConfig.min_speech_frames !== undefined)
+                vadOptions.minSpeechFrames = this.vadConfig.min_speech_frames;
+            if (this.vadConfig.pre_speech_pad_frames !== undefined)
+                vadOptions.preSpeechPadFrames = this.vadConfig.pre_speech_pad_frames;
+            if (this.vadConfig.frame_samples !== undefined)
+                vadOptions.frameSamples = this.vadConfig.frame_samples;
+        }
+        else {
+            // Default values if no config from backend
+            vadOptions.model = 'v5';
+            vadOptions.positiveSpeechThreshold = 0.15;
+            vadOptions.negativeSpeechThreshold = 0.05;
+            vadOptions.redemptionFrames = 4;
+            vadOptions.minSpeechFrames = 2;
+            vadOptions.preSpeechPadFrames = 0;
+            vadOptions.frameSamples = 512; // Required for v5
+        }
+        console.log('Creating VAD with options:', vadOptions);
+        dist.MicVAD.new(vadOptions)
+            .then((vad) => {
+            this.vad = vad;
+            this.vad.start();
+            console.log('VAD started successfully');
+        })
+            .catch((error) => {
+            console.warn('Error initializing VAD:', error);
             // Send a message to server indicating VAD failure
             this._wsSend({
                 type: 'vad_events',
                 event: 'vad_model_failed',
             });
-            // In automatic mode without VAD, allow the bot to speak initially
-            this.userIsSpeaking = false;
-            this.options.onUserIsSpeakingChange(false);
-            // Set up amplitude-based fallback detection
-            this._setupAmplitudeBasedVAD();
-        }, 2000);
-        if (!this.canInterrupt) {
-            dist.MicVAD.new({
-                stream: this.wavRecorder.getStream() || undefined,
-                model: 'v5',
-                positiveSpeechThreshold: 0.7,
-                negativeSpeechThreshold: 0.55,
-                redemptionFrames: 25, // Number of frames of silence before onVADMisfire or onSpeechEnd is called. Effectively a delay before restarting.
-                minSpeechFrames: 0,
-                preSpeechPadFrames: 0,
-                onSpeechStart: () => {
-                    this.userIsSpeaking = true;
-                    this.options.onUserIsSpeakingChange(true);
-                    console.log('onSpeechStart: sending vad_start');
-                    this._wsSend({
-                        type: 'vad_events',
-                        event: 'vad_start',
-                    });
-                },
-                onSpeechEnd: () => {
-                    console.log('onSpeechEnd: sending vad_end');
-                    this.endUserTurn = true; // Set flag to indicate that the user turn has ended
-                    this.audioBuffer = []; // Clear buffer on speech end
-                    this.userIsSpeaking = false;
-                    this.options.onUserIsSpeakingChange(false);
-                    console.log('onSpeechEnd: State after update - endUserTurn:', this.endUserTurn, 'userIsSpeaking:', this.userIsSpeaking);
-                    // Send vad_end immediately instead of waiting for next audio chunk
-                    this._wsSend({
-                        type: 'vad_events',
-                        event: 'vad_end',
-                    });
-                    this.endUserTurn = false; // Reset the flag after sending vad_end
-                },
-            })
-                .then((vad) => {
-                clearTimeout(timeout);
-                this.vad = vad;
-                this.vad.start();
-                console.log('VAD started');
-            })
-                .catch((error) => {
-                console.error('Error initializing VAD:', error);
-            });
-        }
-        else {
-            dist.MicVAD.new({
-                stream: this.wavRecorder.getStream() || undefined,
-                model: 'v5',
-                // baseAssetPath: '/', // Use if bundling model locally
-                // onnxWASMBasePath: '/', // Use if bundling model locally
-                positiveSpeechThreshold: 0.7,
-                negativeSpeechThreshold: 0.55,
-                redemptionFrames: 25, // Number of frames of silence before onVADMisfire or onSpeechEnd is called. Effectively a delay before restarting.
-                minSpeechFrames: 25,
-                preSpeechPadFrames: 0,
-                onSpeechStart: () => {
-                    // Only pause agent audio if it's currently playing
-                    if (this.wavPlayer.isPlaying) {
-                        console.log('onSpeechStart: WavPlayer is playing, pausing it.');
-                        this.audioPauseTime = Date.now(); // Track when we paused
-                        this.wavPlayer.pause();
-                    }
-                    else {
-                        console.log('onSpeechStart: WavPlayer is not playing, VAD will not pause.');
-                    }
-                    console.log('onSpeechStart: sending vad_start');
-                    this._wsSend({
-                        type: 'vad_events',
-                        event: 'vad_start',
-                    });
-                    this.userIsSpeaking = true;
-                    this.options.onUserIsSpeakingChange(true);
-                    this.endUserTurn = false; // Reset endUserTurn when speech starts
-                    console.log('onSpeechStart: State after update - endUserTurn:', this.endUserTurn, 'userIsSpeaking:', this.userIsSpeaking);
-                },
-                onVADMisfire: () => {
-                    // If the speech detected was for less than minSpeechFrames, this is called instead of onSpeechEnd, and we should resume the assistant audio as it was a false interruption. We include a configurable delay so the assistant isn't too quick to start speaking again.
-                    this.userIsSpeaking = false;
-                    this.audioBuffer = []; // Clear buffer on misfire
-                    this.options.onUserIsSpeakingChange(false);
-                    // Add the missing delay before resuming to prevent race conditions
-                    setTimeout(() => {
-                        if (!this.wavPlayer.isPlaying) {
-                            console.log('onVADMisfire: Resuming after delay');
-                            this.audioPauseTime = null; // Clear pause time since we're resuming
-                            this.wavPlayer.play();
-                        }
-                        else {
-                            console.log('onVADMisfire: Not resuming - either no pause or user speaking again');
-                            this.endUserTurn = true;
-                        }
-                    }, this.options.vadResumeDelay);
-                },
-                onSpeechEnd: () => {
-                    console.log('onSpeechEnd: sending vad_end');
-                    this.endUserTurn = true; // Set flag to indicate that the user turn has ended
-                    this.audioBuffer = []; // Clear buffer on speech end
-                    this.userIsSpeaking = false;
-                    this.options.onUserIsSpeakingChange(false);
-                    console.log('onSpeechEnd: State after update - endUserTurn:', this.endUserTurn, 'userIsSpeaking:', this.userIsSpeaking);
-                    // Send vad_end immediately instead of waiting for next audio chunk
-                    this._wsSend({
-                        type: 'vad_events',
-                        event: 'vad_end',
-                    });
-                    this.endUserTurn = false; // Reset the flag after sending vad_end
-                },
-            })
-                .then((vad) => {
-                clearTimeout(timeout);
-                this.vad = vad;
-                this.vad.start();
-                console.log('VAD started');
-            })
-                .catch((error) => {
-                console.error('Error initializing VAD:', error);
-            });
-        }
+        });
     }
     /**
      * Updates the connection status and triggers the callback
      * @param {string} status - New status value
-     * @private
      */
     _setStatus(status) {
         this.status = status;
@@ -3718,7 +3623,6 @@ class LayercodeClient {
     }
     /**
      * Handles when agent audio finishes playing
-     * @private
      */
     _clientResponseAudioReplayFinished() {
         console.log('clientResponseAudioReplayFinished');
@@ -3731,17 +3635,6 @@ class LayercodeClient {
         const offsetData = await this.wavPlayer.interrupt();
         if (offsetData && this.currentTurnId) {
             let offsetMs = offsetData.currentTime * 1000;
-            // Calculate accurate offset by subtracting pause time if audio was paused for VAD
-            if (this.audioPauseTime) {
-                const pauseDurationMs = Date.now() - this.audioPauseTime;
-                const adjustedOffsetMs = Math.max(0, offsetMs - pauseDurationMs);
-                console.log(`Interruption detected: Raw offset ${offsetMs}ms, pause duration ${pauseDurationMs}ms, adjusted offset ${adjustedOffsetMs}ms for turn ${this.currentTurnId}`);
-                offsetMs = adjustedOffsetMs;
-                this.audioPauseTime = null; // Clear the pause time
-            }
-            else {
-                console.log(`Interruption detected: ${offsetMs}ms offset for turn ${this.currentTurnId} (no pause adjustment needed)`);
-            }
             // Send interruption event with accurate playback offset in milliseconds
             this._wsSend({
                 type: 'trigger.response.audio.interrupted',
@@ -3775,7 +3668,6 @@ class LayercodeClient {
     /**
      * Handles incoming WebSocket messages
      * @param {MessageEvent} event - The WebSocket message event
-     * @private
      */
     async _handleWebSocketMessage(event) {
         try {
@@ -3790,12 +3682,10 @@ class LayercodeClient {
                     console.log(message);
                     if (message.role === 'assistant') {
                         // Start tracking new assistant turn
-                        // Note: Don't reset currentTurnId here - let response.audio set it
-                        // This prevents race conditions where text arrives before audio
                         console.log('Assistant turn started, will track new turn ID from audio/text');
                     }
-                    else if (message.role === 'user' && !this.pushToTalkEnabled && this.canInterrupt) {
-                        // Interrupt any playing assistant audio if this is a turn trigged by the server (and not push to talk, which will have already called interrupt)
+                    else if (message.role === 'user' && !this.pushToTalkEnabled) {
+                        // Interrupt any playing assistant audio if this is a turn triggered by the server (and not push to talk, which will have already called interrupt)
                         console.log('interrupting assistant audio, as user turn has started and pushToTalkEnabled is false');
                         await this._clientInterruptAssistantReplay();
                     }
@@ -3817,7 +3707,6 @@ class LayercodeClient {
                         this.currentTurnId = message.turn_id;
                         console.log(`Setting current turn ID to: ${message.turn_id} from text message`);
                     }
-                    // Note: We no longer track text content in the client - the pipeline handles interruption estimation
                     break;
                 }
                 case 'response.data':
@@ -3825,7 +3714,7 @@ class LayercodeClient {
                     this.options.onDataMessage(message);
                     break;
                 default:
-                    console.error('Unknown message type received:', message);
+                    console.warn('Unknown message type received:', message);
                     break;
             }
         }
@@ -3837,15 +3726,28 @@ class LayercodeClient {
     /**
      * Handles available client browser microphone audio data and sends it over the WebSocket
      * @param {ArrayBuffer} data - The audio data buffer
-     * @private
      */
     _handleDataAvailable(data) {
+        var _a, _b, _c;
         try {
             const base64 = arrayBufferToBase64(data.mono);
-            const sendAudio = this.pushToTalkEnabled ? this.pushToTalkActive : this.userIsSpeaking;
+            // Determine if we should gate audio based on VAD configuration
+            const shouldGateAudio = ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.gate_audio) !== false; // Default to true if not specified
+            const bufferFrames = (_c = (_b = this.vadConfig) === null || _b === void 0 ? void 0 : _b.buffer_frames) !== null && _c !== void 0 ? _c : 10; // Default to 10 if not specified
+            let sendAudio;
+            if (this.pushToTalkEnabled) {
+                sendAudio = this.pushToTalkActive;
+            }
+            else if (shouldGateAudio) {
+                sendAudio = this.userIsSpeaking;
+            }
+            else {
+                // If gate_audio is false, always send audio
+                sendAudio = true;
+            }
             if (sendAudio) {
-                // If we have buffered audio, send it first
-                if (this.audioBuffer.length > 0) {
+                // If we have buffered audio and we're gating, send it first
+                if (shouldGateAudio && this.audioBuffer.length > 0) {
                     console.log(`Sending ${this.audioBuffer.length} buffered audio chunks`);
                     for (const bufferedAudio of this.audioBuffer) {
                         this._wsSend({
@@ -3864,8 +3766,8 @@ class LayercodeClient {
             else {
                 // Buffer audio when not sending (to catch audio just before VAD triggers)
                 this.audioBuffer.push(base64);
-                // Keep buffer size reasonable (e.g., last 10 chunks ≈ 200ms at 20ms chunks)
-                if (this.audioBuffer.length > 10) {
+                // Keep buffer size based on configuration
+                if (this.audioBuffer.length > bufferFrames) {
                     this.audioBuffer.shift(); // Remove oldest chunk
                 }
             }
@@ -3897,7 +3799,6 @@ class LayercodeClient {
      * @param {WavRecorder | WavStreamPlayer} source - The audio source (recorder or player).
      * @param {(amplitude: number) => void} callback - The callback function to invoke on amplitude change.
      * @param {(amplitude: number) => void} updateInternalState - Function to update the internal amplitude state.
-     * @private
      */
     _setupAmplitudeMonitoring(source, callback, updateInternalState) {
         // Set up amplitude monitoring only if a callback is provided
@@ -3929,6 +3830,7 @@ class LayercodeClient {
             let authorizeSessionRequestBody = {
                 pipeline_id: this.options.pipelineId,
                 metadata: this.options.metadata,
+                sdk_version: SDK_VERSION,
             };
             // If we're reconnecting to a previous session, we need to include the session_id in the request. Otherwise we don't send session_id, and a new session will be created and the session_id will be returned in the response.
             if (this.options.sessionId) {
@@ -3952,6 +3854,8 @@ class LayercodeClient {
             })}`);
             const config = authorizeSessionResponseBody.config;
             console.log('config', config);
+            // Store VAD configuration
+            this.vadConfig = config.vad || null;
             if (config.transcription.trigger === 'push_to_talk') {
                 this.pushToTalkEnabled = true;
             }
@@ -3962,7 +3866,6 @@ class LayercodeClient {
             else {
                 throw new Error(`Unknown trigger: ${config.transcription.trigger}`);
             }
-            this._initializeVAD();
             // Bind the websocket message callbacks
             this.ws.onmessage = this._handleWebSocketMessage;
             this.ws.onopen = () => {
@@ -3982,18 +3885,13 @@ class LayercodeClient {
                 this._setStatus('error');
                 this.options.onError(new Error('WebSocket connection error'));
             };
-            // Initialize microphone audio capture
-            await this.wavRecorder.begin();
-            await this.wavRecorder.record(this._handleDataAvailable, 1638);
-            // Set up microphone amplitude monitoring
-            this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
             // Initialize audio player
             await this.wavPlayer.connect();
             // Set up audio player amplitude monitoring
             this._setupAmplitudeMonitoring(this.wavPlayer, this.options.onAgentAmplitudeChange, (amp) => (this.agentAudioAmplitude = amp));
-            // Mark recorder as started and attempt to notify server
-            this.recorderStarted = true;
-            this._sendReadyIfNeeded();
+            // wavRecorder will be started from the onDeviceSwitched callback,
+            // which is called when the device is first initialized and also when the device is switched
+            // this is to ensure that the device is initialized before the recorder is started
         }
         catch (error) {
             console.error('Error connecting to Layercode pipeline:', error);
@@ -4013,6 +3911,7 @@ class LayercodeClient {
             this.vad.destroy();
             this.vad = null;
         }
+        this.wavRecorder.listenForDeviceChange(null);
         this.wavRecorder.quit();
         this.wavPlayer.disconnect();
         // Reset turn tracking
@@ -4036,19 +3935,101 @@ class LayercodeClient {
      * @param {string} deviceId - The deviceId of the new microphone
      */
     async setInputDevice(deviceId) {
-        if (this.wavRecorder) {
+        var _a;
+        try {
+            this.deviceId = deviceId;
+            // Restart recording with the new device
+            await this._restartAudioRecording();
+            // Reinitialize VAD with the new audio stream if VAD is enabled
+            const shouldUseVAD = !this.pushToTalkEnabled && ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
+            if (shouldUseVAD) {
+                console.log('Reinitializing VAD with new audio stream');
+                const newStream = this.wavRecorder.getStream();
+                await this._reinitializeVAD(newStream);
+            }
+            console.log(`Successfully switched to input device: ${deviceId}`);
+        }
+        catch (error) {
+            console.error(`Failed to switch to input device ${deviceId}:`, error);
+            throw new Error(`Failed to switch to input device: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Restarts audio recording after a device switch to ensure audio is captured from the new device
+     */
+    async _restartAudioRecording() {
+        try {
+            console.log('Restarting audio recording after device switch...');
             try {
                 await this.wavRecorder.end();
             }
-            catch (e) { }
-            try {
-                await this.wavRecorder.quit();
+            catch (_a) {
+                // Ignore cleanup errors
             }
-            catch (e) { }
+            // Start with new device
+            await this.wavRecorder.begin(this.deviceId || undefined);
+            await this.wavRecorder.record(this._handleDataAvailable, 1638);
+            // Re-setup amplitude monitoring with the new stream
+            this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
+            console.log('Audio recording restart completed successfully');
+        }
+        catch (error) {
+            console.error('Error restarting audio recording after device switch:', error);
+            this.options.onError(error instanceof Error ? error : new Error(String(error)));
         }
-        await this.wavRecorder.begin(deviceId);
-        await this.wavRecorder.record(this._handleDataAvailable, 1638);
-        this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
+    }
+    /**
+     * Reinitializes VAD with a new stream (used after device switching)
+     */
+    async _reinitializeVAD(stream) {
+        // Clean up existing VAD
+        if (this.vad) {
+            this.vad.pause();
+            this.vad.destroy();
+            this.vad = null;
+        }
+        // Reinitialize with new stream
+        if (stream) {
+            this._initializeVAD();
+        }
+    }
+    /**
+     * Sets up the device change event listener
+     */
+    _setupDeviceChangeListener() {
+        this.wavRecorder.listenForDeviceChange(async (devices) => {
+            try {
+                const currentDeviceExists = devices.some((device) => device.deviceId === this.deviceId);
+                if (!currentDeviceExists) {
+                    console.log('Current device disconnected, switching to next available device');
+                    try {
+                        const nextDevice = devices.find((d) => d.default);
+                        if (nextDevice) {
+                            await this.setInputDevice(nextDevice.deviceId);
+                            // Mark recorder as started and attempt to notify server
+                            if (!this.recorderStarted) {
+                                this.recorderStarted = true;
+                                this._sendReadyIfNeeded();
+                            }
+                            // Notify about device switch
+                            if (this.options.onDeviceSwitched) {
+                                this.options.onDeviceSwitched(nextDevice.deviceId);
+                            }
+                        }
+                        else {
+                            console.warn('No alternative audio device found');
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error switching to next device:', error);
+                        throw error;
+                    }
+                }
+            }
+            catch (error) {
+                this.options.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
     }
 }