@cloudfort/callum-voice 0.0.3

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.callumvoice">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+</manifest>

package/android/src/main/java/com/callumvoice/CallumVoiceModule.kt

@@ -0,0 +1,289 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+package com.callumvoice
+
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.AudioRecord
+import android.media.AudioTrack
+import android.media.MediaRecorder
+import android.os.Build
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * React Native native module for Android audio capture and playback.
+ *
+ * Handles microphone recording (AudioRecord) and audio playback (AudioTrack)
+ * using PCM 16-bit mono at 48000 Hz. Communicates audio data to/from the
+ * JavaScript layer via DeviceEventManagerModule events.
+ */
+class CallumVoiceModule(reactContext: ReactApplicationContext)
+    : ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        private const val MODULE_NAME = "CallumVoice"
+        private const val SAMPLE_RATE = 48000
+        private const val FRAME_SIZE = 960 // 20ms at 48kHz
+
+        // JS event names
+        private const val EVENT_AUDIO_CAPTURED = "onAudioCaptured"
+        private const val EVENT_AUDIO_ERROR = "onAudioError"
+    }
+
+    private var audioRecord: AudioRecord? = null
+    private var audioTrack: AudioTrack? = null
+    private var captureThread: Thread? = null
+    private var playbackThread: Thread? = null
+    private var captureRunning = false
+    private var playbackRunning = false
+
+    override fun getName(): String = MODULE_NAME
+
+    /**
+     * Exported constants accessible from JavaScript via NativeModules.CallumVoice.
+     */
+    override fun getConstants(): Map<String, Any> {
+        return hashMapOf(
+            "SAMPLE_RATE" to SAMPLE_RATE,
+            "FRAME_SIZE" to FRAME_SIZE
+        )
+    }
+
+    // ── Microphone Capture ─────────────────────────────────────────
+
+    @ReactMethod
+    fun startAudioCapture(promise: Promise) {
+        try {
+            val bufferSize = AudioRecord.getMinBufferSize(
+                SAMPLE_RATE,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT
+            )
+
+            if (bufferSize == AudioRecord.ERROR || bufferSize == AudioRecord.ERROR_BAD_VALUE) {
+                promise.reject("AUDIO_ERROR", "Cannot get minimum buffer size")
+                return
+            }
+
+            val audioSource = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                MediaRecorder.AudioSource.VOICE_COMMUNICATION
+            } else {
+                MediaRecorder.AudioSource.VOICE_COMMUNICATION
+            }
+
+            audioRecord = AudioRecord(
+                audioSource,
+                SAMPLE_RATE,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT,
+                bufferSize * 2
+            )
+
+            if (audioRecord?.state != AudioRecord.STATE_INITIALIZED) {
+                promise.reject("AUDIO_ERROR", "AudioRecord initialization failed")
+                return
+            }
+
+            // Configure audio processing
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                val audioSessionId = audioRecord!!.audioSessionId
+                // TODO: Attach AcousticEchoCanceler, NoiseSuppressor, AutomaticGainController
+            }
+
+            audioRecord!!.startRecording()
+            captureRunning = true
+
+            captureThread = Thread {
+                val buffer = ShortArray(FRAME_SIZE)
+                while (captureRunning) {
+                    val read = audioRecord?.read(buffer, 0, FRAME_SIZE) ?: -1
+                    if (read > 0) {
+                        // Send captured PCM samples to JavaScript
+                        val writableArray = Arguments.createArray()
+                        for (i in 0 until read) {
+                            writableArray.pushInt(buffer[i].toInt())
+                        }
+                        reactApplicationContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit(EVENT_AUDIO_CAPTURED, writableArray)
+                    }
+                }
+            }.apply {
+                name = "CallumVoice-Capture"
+                start()
+            }
+
+            promise.resolve(null)
+        } catch (e: SecurityException) {
+            promise.reject("PERMISSION_DENIED", "Microphone permission not granted", e)
+        } catch (e: Exception) {
+            promise.reject("AUDIO_ERROR", "Failed to start audio capture: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun stopAudioCapture(promise: Promise) {
+        captureRunning = false
+        try {
+            captureThread?.join(1000)
+            audioRecord?.stop()
+            audioRecord?.release()
+        } catch (e: Exception) {
+            // ignore cleanup errors
+        }
+        audioRecord = null
+        captureThread = null
+        promise.resolve(null)
+    }
+
+    // ── Audio Playback ─────────────────────────────────────────────
+
+    @ReactMethod
+    fun startAudioPlayback(promise: Promise) {
+        try {
+            val bufferSize = AudioTrack.getMinBufferSize(
+                SAMPLE_RATE,
+                AudioFormat.CHANNEL_OUT_MONO,
+                AudioFormat.ENCODING_PCM_16BIT
+            )
+
+            if (bufferSize == AudioTrack.ERROR || bufferSize == AudioTrack.ERROR_BAD_VALUE) {
+                promise.reject("AUDIO_ERROR", "Cannot get minimum buffer size")
+                return
+            }
+
+            val streamType = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                AudioManager.STREAM_VOICE_CALL
+            } else {
+                AudioManager.STREAM_VOICE_CALL
+            }
+
+            audioTrack = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                AudioTrack.Builder()
+                    .setAudioAttributes(
+                        android.media.AudioAttributes.Builder()
+                            .setUsage(android.media.AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                            .setContentType(android.media.AudioAttributes.CONTENT_TYPE_SPEECH)
+                            .build()
+                    )
+                    .setAudioFormat(
+                        AudioFormat.Builder()
+                            .setSampleRate(SAMPLE_RATE)
+                            .setChannelMask(AudioFormat.CHANNEL_OUT_MONO)
+                            .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+                            .build()
+                    )
+                    .setBufferSizeInBytes(bufferSize * 2)
+                    .setTransferMode(AudioTrack.MODE_STREAM)
+                    .build()
+            } else {
+                @Suppress("DEPRECATION")
+                AudioTrack(
+                    streamType,
+                    SAMPLE_RATE,
+                    AudioFormat.CHANNEL_OUT_MONO,
+                    AudioFormat.ENCODING_PCM_16BIT,
+                    bufferSize * 2,
+                    AudioTrack.MODE_STREAM
+                )
+            }
+
+            if (audioTrack?.state != AudioTrack.STATE_INITIALIZED) {
+                promise.reject("AUDIO_ERROR", "AudioTrack initialization failed")
+                return
+            }
+
+            audioTrack!!.play()
+            playbackRunning = true
+
+            // TODO: Implement playback loop that receives audio from JS and writes to AudioTrack
+            // For now, audio playback is handled via enqueuePeerAudio method
+
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("AUDIO_ERROR", "Failed to start audio playback: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun stopAudioPlayback(promise: Promise) {
+        playbackRunning = false
+        try {
+            playbackThread?.join(1000)
+            audioTrack?.stop()
+            audioTrack?.release()
+        } catch (e: Exception) {
+            // ignore cleanup errors
+        }
+        audioTrack = null
+        playbackThread = null
+        promise.resolve(null)
+    }
+
+    /**
+     * Enqueue PCM audio samples for a specific peer.
+     * Called from JavaScript when binary audio is received from the server.
+     */
+    @ReactMethod
+    fun enqueuePeerAudio(peerId: String, samples: ReadableArray) {
+        if (audioTrack == null || !playbackRunning) return
+
+        val shortArray = ShortArray(samples.size())
+        for (i in 0 until samples.size()) {
+            shortArray[i] = samples.getInt(i).toShort()
+        }
+
+        audioTrack?.write(shortArray, 0, shortArray.size)
+    }
+
+    // ── Speaker Routing ────────────────────────────────────────────
+
+    @ReactMethod
+    fun setSpeakerphoneOn(on: Boolean, promise: Promise) {
+        try {
+            val audioManager = reactApplicationContext
+                .getSystemService(ReactApplicationContext.AUDIO_SERVICE) as AudioManager
+
+            audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+            audioManager.isSpeakerphoneOn = on
+
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("AUDIO_ERROR", "Failed to set speakerphone: ${e.message}", e)
+        }
+    }
+
+    // ── Audio Session ──────────────────────────────────────────────
+
+    @ReactMethod
+    fun configureAudioSession(promise: Promise) {
+        try {
+            val audioManager = reactApplicationContext
+                .getSystemService(ReactApplicationContext.AUDIO_SERVICE) as AudioManager
+
+            audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+            audioManager.isMusicActive = false
+
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("AUDIO_ERROR", "Failed to configure audio session: ${e.message}", e)
+        }
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        captureRunning = false
+        playbackRunning = false
+        try {
+            audioRecord?.stop()
+            audioRecord?.release()
+        } catch (e: Exception) { }
+        try {
+            audioTrack?.stop()
+            audioTrack?.release()
+        } catch (e: Exception) { }
+        audioRecord = null
+        audioTrack = null
+    }
+}

package/android/src/main/java/com/callumvoice/CallumVoicePackage.kt

@@ -0,0 +1,32 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+package com.callumvoice
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package registration for CallumVoice native module.
+ *
+ * Add this to your MainApplication.java/kt:
+ * ```
+ * override fun getPackages(): List<ReactPackage> {
+ *     return listOf(
+ *         MainReactPackage(),
+ *         CallumVoicePackage()
+ *     )
+ * }
+ * ```
+ */
+class CallumVoicePackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(CallumVoiceModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/callum-voice.podspec

@@ -0,0 +1,21 @@
+require_relative '../node_modules/react-native/scripts/react_native_pods'
+require_relative '../node_modules/@react-native-community/cli-platform-ios/native_modules'
+
+platform :ios, '13.0'
+
+Pod::Spec.new do |s|
+  s.name         = "callum-voice"
+  s.version      = "1.0.0"
+  s.summary      = "Real-time voice chat SDK for React Native"
+  s.homepage     = "https://cloudfort.ir"
+  s.license      = "MIT"
+  s.author       = "Cloudfort"
+  s.source       = { :git => "https://github.com/cloudfort/callum-voice.git", :tag => s.version.to_s }
+  s.platforms    = { :ios => "13.0" }
+
+  s.source_files = "ios/**/*.{h,m,swift}"
+
+  s.dependency "React-Core"
+
+  s.frameworks = "AVFoundation", "AudioToolbox"
+end

package/ios/CallumVoiceBridge.m

@@ -0,0 +1,7 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+#import "CallumVoiceModule-Bridging-Header.h"
+
+// This file is needed for React Native to discover the native module.
+// The actual implementation is in CallumVoiceModule.swift.
+// The bridging header exposes the Swift class to Objective-C.

package/ios/CallumVoiceModule-Bridging-Header.h

@@ -0,0 +1,7 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface CallumVoiceModule : RCTEventEmitter <RCTBridgeModule>
+@end

package/ios/CallumVoiceModule.swift

@@ -0,0 +1,198 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+import Foundation
+import AVFoundation
+import React
+
+/// React Native native module for iOS audio capture and playback.
+///
+/// Uses AVAudioEngine for microphone capture and audio playback.
+/// Communicates audio data to/from the JavaScript layer via RCTEventEmitter.
+@objc(CallumVoiceModule)
+class CallumVoiceModule: RCTEventEmitter {
+
+    private let sampleRate: Double = 48000
+    private let frameSize: AVAudioFrameCount = 960 // 20ms at 48kHz
+
+    private var audioEngine: AVAudioEngine?
+    private var outputEngine: AVAudioEngine?
+    private var captureRunning = false
+    private var playbackRunning = false
+
+    override static func moduleName() -> String! {
+        return "CallumVoice"
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    override func supportedEvents() -> [String]! {
+        return ["onAudioCaptured", "onAudioError"]
+    }
+
+    override func constantsToExport() -> [AnyHashable : Any]! {
+        return [
+            "SAMPLE_RATE": Int(sampleRate),
+            "FRAME_SIZE": Int(frameSize)
+        ]
+    }
+
+    // MARK: - Audio Capture
+
+    @objc
+    func startAudioCapture(_ resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let session = AVAudioSession.sharedInstance()
+            try session.setCategory(.playAndRecord,
+                                    mode: .voiceChat,
+                                    options: [.defaultToSpeaker, .allowBluetooth])
+            try session.setActive(true)
+            try session.setPreferredSampleRate(sampleRate)
+
+            let engine = AVAudioEngine()
+            let inputNode = engine.inputNode
+            let inputFormat = inputNode.outputFormat(forBus: 0)
+
+            // Install tap to capture PCM audio
+            inputNode.installTap(onBus: 0, bufferSize: frameSize, format: inputFormat) {
+                [weak self] buffer, time in
+                guard let self = self, self.captureRunning else { return }
+
+                // Convert to Int16 array and send to JS
+                let channelData = buffer.int16ChannelData![0]
+                let frameLength = Int(buffer.frameLength)
+                var samples = [Int16](repeating: 0, count: frameLength)
+                for i in 0..<frameLength {
+                    samples[i] = channelData[i]
+                }
+
+                self.sendEvent(withName: "onAudioCaptured", body: samples)
+            }
+
+            engine.prepare()
+            try engine.start()
+
+            audioEngine = engine
+            captureRunning = true
+
+            resolve(nil)
+        } catch {
+            reject("AUDIO_ERROR", "Failed to start audio capture: \(error.localizedDescription)", error)
+        }
+    }
+
+    @objc
+    func stopAudioCapture(_ resolve: @escaping RCTPromiseResolveBlock,
+                          rejecter reject: @escaping RCTPromiseRejectBlock) {
+        captureRunning = false
+        audioEngine?.inputNode.removeTap(onBus: 0)
+        audioEngine?.stop()
+        audioEngine = nil
+        resolve(nil)
+    }
+
+    // MARK: - Audio Playback
+
+    @objc
+    func startAudioPlayback(_ resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let session = AVAudioSession.sharedInstance()
+            try session.setCategory(.playAndRecord,
+                                    mode: .voiceChat,
+                                    options: [.defaultToSpeaker, .allowBluetooth])
+            try session.setActive(true)
+
+            let engine = AVAudioEngine()
+            let outputNode = engine.outputNode
+            let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate,
+                                        channels: 1)
+
+            engine.prepare()
+            try engine.start()
+
+            outputEngine = engine
+            playbackRunning = true
+
+            resolve(nil)
+        } catch {
+            reject("AUDIO_ERROR", "Failed to start audio playback: \(error.localizedDescription)", error)
+        }
+    }
+
+    @objc
+    func stopAudioPlayback(_ resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        playbackRunning = false
+        outputEngine?.stop()
+        outputEngine = nil
+        resolve(nil)
+    }
+
+    /// Enqueue PCM audio samples for a specific peer.
+    @objc
+    func enqueuePeerAudio(_ peerId: String, samples: [Int16]) {
+        guard playbackRunning, let engine = outputEngine else { return }
+
+        let frameCount = AVAudioFrameCount(samples.count)
+        guard let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1),
+              let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCount) else {
+            return
+        }
+
+        buffer.frameLength = frameCount
+        let channelData = buffer.int16ChannelData![0]
+        for i in 0..<samples.count {
+            channelData[i] = samples[i]
+        }
+
+        engine.outputNode.volume = 1.0
+        engine.outputNode.scheduleBuffer(buffer, at: nil, options: .interrupts)
+    }
+
+    // MARK: - Speaker Routing
+
+    @objc
+    func setSpeakerphoneOn(_ on: Bool,
+                           resolver resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let session = AVAudioSession.sharedInstance()
+            if on {
+                try session.overrideOutputAudioPort(.speaker)
+            } else {
+                try session.overrideOutputAudioPort(.none)
+            }
+            resolve(nil)
+        } catch {
+            reject("AUDIO_ERROR", "Failed to set speaker: \(error.localizedDescription)", error)
+        }
+    }
+
+    // MARK: - Audio Session
+
+    @objc
+    func configureAudioSession(_ resolve: @escaping RCTPromiseResolveBlock,
+                               rejecter reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let session = AVAudioSession.sharedInstance()
+            try session.setCategory(.playAndRecord,
+                                    mode: .voiceChat,
+                                    options: [.defaultToSpeaker, .allowBluetooth])
+            try session.setActive(true)
+            resolve(nil)
+        } catch {
+            reject("AUDIO_ERROR", "Failed to configure audio session: \(error.localizedDescription)", error)
+        }
+    }
+
+    deinit {
+        captureRunning = false
+        playbackRunning = false
+        audioEngine?.inputNode.removeTap(onBus: 0)
+        audioEngine?.stop()
+        outputEngine?.stop()
+    }
+}

package/lib/VoiceClient.d.ts

@@ -0,0 +1,104 @@
+import { VoiceClientState } from './VoiceClientState';
+import { VoiceConfig } from './VoiceConfig';
+import { VoiceEventListener } from './VoiceEventListener';
+/**
+ * Cross-platform voice-chat client for React Native.
+ *
+ * Connects to the Go voice service over WebSocket, captures microphone audio
+ * via a native audio engine, and plays back remote peer audio.
+ *
+ * @example
+ * ```ts
+ * const client = new VoiceClient(createVoiceConfig({
+ *   server: 'callem.cloudfort.ir',
+ *   apiKey: 'vc_live_...',
+ *   peerId: 'user_123',
+ * }));
+ *
+ * client.setListener({
+ *   onConnected: () => console.log('Connected!'),
+ *   onPeerSpeaking: (id) => console.log(`${id} is speaking`),
+ * });
+ *
+ * await client.connect();
+ * await client.joinRoom('game_room_1');
+ * await client.enableMic();
+ * ```
+ */
+export declare class VoiceClient {
+    private readonly config;
+    private listener;
+    private ws;
+    private _state;
+    private currentRoom;
+    private micEnabled;
+    private speakerEnabled;
+    private reconnectAttempts;
+    private prevRoom;
+    private prevMicEnabled;
+    private peers;
+    private speakingTimer;
+    private reconnectTimer;
+    constructor(config: VoiceConfig);
+    /** Current connection state */
+    get state(): VoiceClientState;
+    /** Whether connected to server */
+    get isConnected(): boolean;
+    /** Whether joined a room */
+    get isInRoom(): boolean;
+    /** Whether microphone is active */
+    get isMicEnabled(): boolean;
+    /** Whether speaker output is active */
+    get isSpeakerEnabled(): boolean;
+    /** Current room ID (null if not in room) */
+    get currentRoomId(): string | null;
+    /** List of peer IDs in the current room */
+    get peerIds(): string[];
+    /** Set the event listener */
+    setListener(listener: VoiceEventListener | null): void;
+    /** Connect to the voice server */
+    connect(): Promise<void>;
+    /** Disconnect from the server */
+    disconnect(): void;
+    /** Join a voice room */
+    joinRoom(roomId: string): Promise<void>;
+    /** Leave the current room */
+    leaveRoom(): Promise<void>;
+    /** Enable microphone (must be in a room) */
+    enableMic(): Promise<void>;
+    /** Disable microphone */
+    disableMic(): void;
+    /** Toggle microphone, returns new state */
+    toggleMic(): Promise<boolean>;
+    /** Enable speaker output */
+    enableSpeaker(): void;
+    /** Disable speaker output */
+    disableSpeaker(): void;
+    /** Toggle speaker, returns new state */
+    toggleSpeaker(): boolean;
+    /** Check if a specific peer is speaking */
+    isPeerSpeaking(peerId: string): boolean;
+    /** Get peer speaking state with RMS level */
+    getPeerSpeakingInfo(peerId: string): {
+        speaking: boolean;
+        rms: number;
+    };
+    /** Dispose and release all resources */
+    dispose(): void;
+    private handleWebSocketConnected;
+    private handleTextMessage;
+    private handleBinaryMessage;
+    private handlePeerAudio;
+    private checkSpeaking;
+    private handleClose;
+    private handleDisconnect;
+    private sendText;
+    /** Send captured audio to server (called from native audio engine) */
+    sendAudio(samples: Int16Array): void;
+    private cleanup;
+    private stopMic;
+    private resolveScheme;
+    private setState;
+    private raiseError;
+}
+//# sourceMappingURL=VoiceClient.d.ts.map

package/lib/VoiceClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoiceClient.d.ts","sourceRoot":"","sources":["../src/VoiceClient.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AA+D1D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAmC;IAEnD,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,MAAM,CAAmD;IACjE,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,aAAa,CAA+C;IACpE,OAAO,CAAC,cAAc,CAA8C;gBAExD,MAAM,EAAE,WAAW;IAM/B,+BAA+B;IAC/B,IAAI,KAAK,IAAI,gBAAgB,CAE5B;IAED,kCAAkC;IAClC,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,4BAA4B;IAC5B,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,mCAAmC;IACnC,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,uCAAuC;IACvC,IAAI,gBAAgB,IAAI,OAAO,CAE9B;IAED,4CAA4C;IAC5C,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAEjC;IAED,2CAA2C;IAC3C,IAAI,OAAO,IAAI,MAAM,EAAE,CAEtB;IAID,6BAA6B;IAC7B,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI;IAMtD,kCAAkC;IAC5B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2C9B,iCAAiC;IACjC,UAAU,IAAI,IAAI;IASlB,wBAAwB;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgC7C,6BAA6B;IACvB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BhC,4CAA4C;IACtC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAchC,yBAAyB;IACzB,UAAU,IAAI,IAAI;IAMlB,2CAA2C;IACrC,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAWnC,4BAA4B;IAC5B,aAAa,IAAI,IAAI;IAOrB,6BAA6B;IAC7B,cAAc,IAAI,IAAI;IAOtB,wCAAwC;IACxC,aAAa,IAAI,OAAO;IAWxB,2CAA2C;IAC3C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIvC,6CAA6C;IAC7C,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;IAQvE,wCAAwC;IACxC,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,wBAAwB;IAsBhC,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,QAAQ;IAMhB,sEAAsE;IACtE,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IASpC,OAAO,CAAC,OAAO;IAgCf,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,UAAU;CAGnB"}