cactus-react-native 0.2.11 → 1.0.2

package/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/kernel_utils.h

@@ -0,0 +1,343 @@
+#ifndef KERNEL_UTILS_H
+#define KERNEL_UTILS_H
+
+#include <arm_neon.h>
+#include <algorithm>
+#include <cmath>
+#include <thread>
+#include <vector>
+#include <functional>
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+#include <atomic>
+#include <future>
+#include <unistd.h>
+#include <unordered_map>
+#include <chrono>
+#include <string>
+#include <cstdio>
+
+constexpr size_t NEON_VECTOR_SIZE = 16;
+
+inline int8_t clamp_to_int8(float value) {
+    int32_t clamped = static_cast<int32_t>(roundf(value));
+    return static_cast<int8_t>(std::max(-128, std::min(127, clamped)));
+}
+
+inline int8_t clamp_to_int8(int32_t value) {
+    return static_cast<int8_t>(std::max(-128, std::min(127, value)));
+}
+
+#if defined(__ARM_FEATURE_DOTPROD)
+inline int32x4_t accum_i8mm(int32x4_t acc, int8x16_t a, int8x16_t b) {
+    return vdotq_s32(acc, a, b);
+}
+#else
+inline int32x4_t accum_i8mm(int32x4_t acc, int8x16_t a, int8x16_t b) {
+    int16x8_t prod_low = vmull_s8(vget_low_s8(a), vget_low_s8(b));
+    int32x4_t acc_high = vpaddlq_s16(vmull_s8(vget_high_s8(a), vget_high_s8(b)));
+    return vaddq_s32(vaddq_s32(acc, vpaddlq_s16(prod_low)), acc_high);
+}
+#endif
+
+inline float16x8_t accum_f16_dot(float16x8_t acc, float16x8_t a_low, float16x8_t a_high, 
+                                 float16x8_t b_low, float16x8_t b_high) {
+    acc = vfmaq_f16(acc, a_low, b_low);
+    return vfmaq_f16(acc, a_high, b_high);
+}
+
+inline float32x4_t accum_f32_dot(float32x4_t acc, float32x4_t a_low, float32x4_t a_high, 
+                                  float32x4_t b_low, float32x4_t b_high) {
+    acc = vfmaq_f32(acc, a_low, b_low);
+    return vfmaq_f32(acc, a_high, b_high);
+}
+
+namespace CactusThreading {
+    
+    class ThreadPool {
+    private:
+        std::vector<std::thread> workers;
+        std::queue<std::function<void()>> tasks;
+        std::mutex queue_mutex;
+        std::condition_variable condition;
+        std::atomic<bool> stop{false};
+        std::atomic<size_t> active_workers{0};
+        std::condition_variable finish_condition;
+        
+        void worker_thread() {
+            while (true) {
+                std::function<void()> task;
+                {
+                    std::unique_lock<std::mutex> lock(queue_mutex);
+                    condition.wait(lock, [this] { return stop || !tasks.empty(); });
+                    
+                    if (stop && tasks.empty()) return;
+                    
+                    task = std::move(tasks.front());
+                    tasks.pop();
+                    active_workers++;
+                }
+                
+                task();
+                
+                active_workers--;
+                finish_condition.notify_all();
+            }
+        }
+        
+    public:
+        explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency()) {
+            workers.reserve(num_threads);
+            for (size_t i = 0; i < num_threads; ++i) {
+                workers.emplace_back(&ThreadPool::worker_thread, this);
+            }
+        }
+        
+        ~ThreadPool() {
+            {
+                std::unique_lock<std::mutex> lock(queue_mutex);
+                stop = true;
+            }
+            condition.notify_all();
+            for (auto& worker : workers) {
+                worker.join();
+            }
+        }
+        
+        template<typename F>
+        auto enqueue(F&& f) -> std::future<decltype(f())> {
+            using return_type = decltype(f());
+            
+            auto task = std::make_shared<std::packaged_task<return_type()>>(
+                std::forward<F>(f)
+            );
+            
+            std::future<return_type> res = task->get_future();
+            {
+                std::unique_lock<std::mutex> lock(queue_mutex);
+                if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
+                
+                tasks.emplace([task](){ (*task)(); });
+            }
+            condition.notify_one();
+            return res;
+        }
+        
+        void wait_all() {
+            std::unique_lock<std::mutex> lock(queue_mutex);
+            finish_condition.wait(lock, [this] { 
+                return tasks.empty() && active_workers == 0; 
+            });
+        }
+        
+        size_t num_workers() const { return workers.size(); }
+    };
+    
+    inline ThreadPool& get_thread_pool() {
+        static ThreadPool pool;
+        return pool;
+    }
+    
+    inline size_t get_optimal_thread_count(size_t total_work, size_t min_work_per_thread) {
+        if (total_work < min_work_per_thread) return 1;
+        size_t pool_size = get_thread_pool().num_workers();
+        return std::min(pool_size, 
+                       std::max(static_cast<size_t>(1), total_work / min_work_per_thread));
+    }
+    
+    struct Thresholds {
+
+        #if defined(__ANDROID__)
+        static constexpr size_t ELEMENT_WISE = 5000;
+        static constexpr size_t AXIS_REDUCE = 1000;
+        static constexpr size_t ALL_REDUCE = 10000;
+        static constexpr size_t SCALAR_BASIC = 30000;
+        static constexpr size_t SCALAR_EXPENSIVE = 10000;
+        static constexpr size_t ATTENTION = 512;
+        static constexpr size_t GEMM_TILED = 20000; 
+        static constexpr size_t GEMM_SMALL = 64 * 64 * 64;
+        static constexpr size_t GEMM_MEDIUM = 256 * 256 * 256;
+        static constexpr size_t GEMM_TILE_M = 64;
+        static constexpr size_t GEMM_TILE_N = 64;
+        static constexpr size_t GEMM_TILE_M_SMALL = 32;
+        static constexpr size_t GEMM_TILE_N_SMALL = 32;
+        #else // iOS
+        static constexpr size_t ELEMENT_WISE = 5000;
+        static constexpr size_t AXIS_REDUCE = 1000;
+        static constexpr size_t ALL_REDUCE = 10000;
+        static constexpr size_t SCALAR_BASIC = 5000;
+        static constexpr size_t SCALAR_EXPENSIVE = 2500;
+        static constexpr size_t ATTENTION = 4;
+        static constexpr size_t GEMM_TILED = 4;  
+        static constexpr size_t GEMM_SMALL = 64 * 64 * 64;
+        static constexpr size_t GEMM_MEDIUM = 256 * 256 * 256;
+        static constexpr size_t GEMM_TILE_M = 64;
+        static constexpr size_t GEMM_TILE_N = 64;
+        static constexpr size_t GEMM_TILE_M_SMALL = 32;
+        static constexpr size_t GEMM_TILE_N_SMALL = 32;
+        #endif
+        static constexpr size_t L2_CACHE_SIZE = 256 * 1024;
+    };
+    
+    class TaskHandle {
+    private:
+        std::vector<std::future<void>> futures_;
+        bool auto_wait_;
+        
+    public:
+        TaskHandle(bool auto_wait = true) : auto_wait_(auto_wait) {}
+        
+        ~TaskHandle() {
+            if (auto_wait_) {
+                wait();
+            }
+        }
+        
+        TaskHandle(TaskHandle&&) = default;
+        TaskHandle& operator=(TaskHandle&&) = default;
+        TaskHandle(const TaskHandle&) = delete;
+        TaskHandle& operator=(const TaskHandle&) = delete;
+        
+        void add_future(std::future<void>&& f) {
+            futures_.push_back(std::move(f));
+        }
+        
+        void wait() {
+            for (auto& f : futures_) {
+                if (f.valid()) {
+                    f.wait();
+                }
+            }
+            futures_.clear();
+        }
+        
+        bool is_ready() const {
+            for (const auto& f : futures_) {
+                if (f.valid() && f.wait_for(std::chrono::seconds(0)) != std::future_status::ready) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        
+        size_t task_count() const { return futures_.size(); }
+    };
+    
+    template<typename WorkFunc>
+    TaskHandle parallel_for(size_t total_work, size_t threshold, WorkFunc work_func, bool wait = true) {
+        const size_t num_threads = get_optimal_thread_count(total_work, threshold);
+        TaskHandle handle(!wait);  
+        
+        if (num_threads == 1) {
+            if (wait) {
+                work_func(0, total_work);
+                return handle;
+            }
+            auto& pool = get_thread_pool();
+            handle.add_future(pool.enqueue([work_func, total_work]() {
+                work_func(0, total_work);
+            }));
+            return handle;
+        }
+        
+        auto& pool = get_thread_pool();
+        const size_t work_per_thread = total_work / num_threads;
+        
+        for (size_t t = 0; t < num_threads; ++t) {
+            handle.add_future(pool.enqueue([work_func, t, num_threads, work_per_thread, total_work]() {
+                const size_t start_idx = t * work_per_thread;
+                const size_t end_idx = (t == num_threads - 1) ? total_work : (t + 1) * work_per_thread;
+                work_func(start_idx, end_idx);
+            }));
+        }
+        
+        if (wait) {
+            handle.wait();
+        }
+        return handle;
+    }
+    
+    template<typename WorkFunc>
+    void parallel_for_2d(size_t outer_size, size_t inner_size, size_t threshold, WorkFunc work_func) {
+        const size_t total_work = outer_size * inner_size;
+        parallel_for(total_work, threshold, [&](size_t start_idx, size_t end_idx) {
+            for (size_t work_idx = start_idx; work_idx < end_idx; ++work_idx) {
+                const size_t outer = work_idx / inner_size;
+                const size_t inner = work_idx % inner_size;
+                work_func(outer, inner);
+            }
+        });
+    }
+    
+    template<typename WorkFunc, typename ResultType, typename CombineFunc>
+    ResultType parallel_reduce(size_t total_work, size_t threshold, 
+                              WorkFunc work_func, ResultType init_value, CombineFunc combine_func) {
+        const size_t num_threads = get_optimal_thread_count(total_work, threshold);
+        
+        if (num_threads == 1) {
+            return work_func(0, total_work);
+        }
+        
+        auto& pool = get_thread_pool();
+        std::vector<std::future<ResultType>> futures;
+        std::vector<ResultType> partial_results(num_threads, init_value);
+        const size_t work_per_thread = total_work / num_threads;
+        
+        for (size_t t = 0; t < num_threads; ++t) {
+            futures.push_back(pool.enqueue([work_func, t, num_threads, work_per_thread, total_work]() -> ResultType {
+                const size_t start_idx = t * work_per_thread;
+                const size_t end_idx = (t == num_threads - 1) ? total_work : (t + 1) * work_per_thread;
+                return work_func(start_idx, end_idx);
+            }));
+        }
+        
+        ResultType result = init_value;
+        for (auto& future : futures) {
+            result = combine_func(result, future.get());
+        }
+        return result;
+    }
+    
+    inline size_t compute_gemm_parallelism(size_t M, size_t K, size_t N, size_t element_size) {
+        size_t total_ops = M * K * N;
+        
+        if (total_ops < Thresholds::GEMM_SMALL) return 1;
+        
+        if (total_ops < Thresholds::GEMM_MEDIUM) {
+            return std::min(static_cast<size_t>(2), get_thread_pool().num_workers());
+        }
+        
+        size_t bytes_accessed = (M * K + K * N + M * N) * element_size;
+        size_t cache_tiles = (bytes_accessed + Thresholds::L2_CACHE_SIZE - 1) / Thresholds::L2_CACHE_SIZE;
+        
+        size_t compute_threads = std::sqrt(static_cast<double>(total_ops) / Thresholds::GEMM_SMALL);
+        size_t memory_threads = cache_tiles;
+        
+        size_t optimal = std::min(compute_threads, memory_threads);
+        return std::min(optimal, get_thread_pool().num_workers());
+    }
+    
+    template<typename WorkFunc>
+    void parallel_for_2d_tiled(size_t rows, size_t cols, size_t tile_rows, size_t tile_cols, WorkFunc work_func) {
+        size_t num_row_tiles = (rows + tile_rows - 1) / tile_rows;
+        size_t num_col_tiles = (cols + tile_cols - 1) / tile_cols;
+        size_t total_tiles = num_row_tiles * num_col_tiles;
+
+        parallel_for(total_tiles, Thresholds::GEMM_TILED, [=](size_t start_tile, size_t end_tile) {
+            for (size_t tile_idx = start_tile; tile_idx < end_tile; ++tile_idx) {
+                size_t tile_row = tile_idx / num_col_tiles;
+                size_t tile_col = tile_idx % num_col_tiles;
+                
+                size_t row_start = tile_row * tile_rows;
+                size_t row_end = std::min(row_start + tile_rows, rows);
+                size_t col_start = tile_col * tile_cols;
+                size_t col_end = std::min(col_start + tile_cols, cols);
+                
+                work_func(row_start, row_end, col_start, col_end);
+            }
+        });
+    }
+}
+
+#endif // KERNEL_UTILS_H 

package/ios/cactus.xcframework/{tvos-arm64_x86_64-simulator → ios-arm64-simulator}/cactus.framework/_CodeSignature/CodeResources

@@ -6,7 +6,7 @@
 	<dict>
 		<key>Info.plist</key>
 		<data>
-		yn2lmWOqLhrj7vGnM5Vufqo5g4g=
+		oZrZEx0iJfsyoH1nUXO8hrSVJHs=
 		</data>
 	</dict>
 	<key>files2</key>

package/ios/cactus_util.xcframework/Info.plist

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>AvailableLibraries</key>
+    <array>
+        <dict>
+            <key>LibraryIdentifier</key>
+            <string>ios-arm64-simulator</string>
+            <key>LibraryPath</key>
+            <string>cactus_util.framework</string>
+            <key>SupportedArchitectures</key>
+            <array>
+                <string>arm64</string>
+            </array>
+            <key>SupportedPlatform</key>
+            <string>ios</string>
+            <key>SupportedPlatformVariant</key>
+            <string>simulator</string>
+        </dict>
+        <dict>
+            <key>LibraryIdentifier</key>
+            <string>ios-arm64</string>
+            <key>LibraryPath</key>
+            <string>cactus_util.framework</string>
+            <key>SupportedArchitectures</key>
+            <array>
+                <string>arm64</string>
+            </array>
+            <key>SupportedPlatform</key>
+            <string>ios</string>
+        </dict>
+    </array>
+    <key>CFBundlePackageType</key>
+    <string>XFWK</string>
+    <key>XCFrameworkFormatVersion</key>
+    <string>1.0</string>
+</dict>
+</plist>

package/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/cactus_util.h

@@ -0,0 +1,25 @@
+#ifndef cactus_util_H
+#define cactus_util_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* register_app(const char* encrypted_data);
+
+const char* get_device_id();
+
+// Helper function to free memory allocated by register_app
+void free_string(const char* str);
+
+#ifdef __ANDROID__
+// Function to set the Android app data directory
+// This should be called from Flutter/Java side before any other functions
+void set_android_data_directory(const char* data_dir);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/ios_utils.h

@@ -0,0 +1,10 @@
+#ifndef IOS_UTILS_H
+#define IOS_UTILS_H
+
+#include <string>
+
+#ifdef __APPLE__
+std::string get_ios_documents_path();
+#endif
+
+#endif

package/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/logging.h

@@ -0,0 +1,25 @@
+#ifndef LOGGING_H
+#define LOGGING_H
+
+#include <string>
+
+// Log levels
+enum LogLevel {
+    LOG_DEBUG = 0,
+    LOG_INFO = 1,
+    LOG_WARNING = 2,
+    LOG_ERROR = 3
+};
+
+// Cross-platform logging function
+void cactus_log(LogLevel level, const char* tag, const char* message);
+void cactus_log(LogLevel level, const char* tag, const std::string& message);
+
+// Convenience macros
+#define LOG_TAG "CactusUtil"
+#define CACTUS_LOG_DEBUG(msg) cactus_log(LOG_DEBUG, LOG_TAG, msg)
+#define CACTUS_LOG_INFO(msg) cactus_log(LOG_INFO, LOG_TAG, msg)
+#define CACTUS_LOG_WARNING(msg) cactus_log(LOG_WARNING, LOG_TAG, msg)
+#define CACTUS_LOG_ERROR(msg) cactus_log(LOG_ERROR, LOG_TAG, msg)
+
+#endif

package/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/cactus_util.h

@@ -0,0 +1,25 @@
+#ifndef cactus_util_H
+#define cactus_util_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* register_app(const char* encrypted_data);
+
+const char* get_device_id();
+
+// Helper function to free memory allocated by register_app
+void free_string(const char* str);
+
+#ifdef __ANDROID__
+// Function to set the Android app data directory
+// This should be called from Flutter/Java side before any other functions
+void set_android_data_directory(const char* data_dir);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/ios_utils.h

@@ -0,0 +1,10 @@
+#ifndef IOS_UTILS_H
+#define IOS_UTILS_H
+
+#include <string>
+
+#ifdef __APPLE__
+std::string get_ios_documents_path();
+#endif
+
+#endif

package/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/logging.h

@@ -0,0 +1,25 @@
+#ifndef LOGGING_H
+#define LOGGING_H
+
+#include <string>
+
+// Log levels
+enum LogLevel {
+    LOG_DEBUG = 0,
+    LOG_INFO = 1,
+    LOG_WARNING = 2,
+    LOG_ERROR = 3
+};
+
+// Cross-platform logging function
+void cactus_log(LogLevel level, const char* tag, const char* message);
+void cactus_log(LogLevel level, const char* tag, const std::string& message);
+
+// Convenience macros
+#define LOG_TAG "CactusUtil"
+#define CACTUS_LOG_DEBUG(msg) cactus_log(LOG_DEBUG, LOG_TAG, msg)
+#define CACTUS_LOG_INFO(msg) cactus_log(LOG_INFO, LOG_TAG, msg)
+#define CACTUS_LOG_WARNING(msg) cactus_log(LOG_WARNING, LOG_TAG, msg)
+#define CACTUS_LOG_ERROR(msg) cactus_log(LOG_ERROR, LOG_TAG, msg)
+
+#endif

package/ios/{cactus.xcframework/ios-arm64_x86_64-simulator/cactus.framework → cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework}/_CodeSignature/CodeResources

@@ -4,13 +4,47 @@
 <dict>
 	<key>files</key>
 	<dict>
+		<key>Headers/cactus_util.h</key>
+		<data>
+		7z1Ts4xufXPrnEBuKu+NppO1yKg=
+		</data>
+		<key>Headers/ios_utils.h</key>
+		<data>
+		DxZ6AL6QIFsgYUKBGkaAndkY1Ew=
+		</data>
+		<key>Headers/logging.h</key>
+		<data>
+		m5MdwrQVZglUAv3NSffShqQTwqE=
+		</data>
 		<key>Info.plist</key>
 		<data>
-		HXkBuOP5nCau6vVcgpSFZQf+U9Q=
+		OhVLqBjBr8wHfc8V3KCR4rpni5U=
 		</data>
 	</dict>
 	<key>files2</key>
-	<dict/>
+	<dict>
+		<key>Headers/cactus_util.h</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			mIHS5tpbAc2yQnCfoYds/waoVwabQF9bYng+EYTSSrg=
+			</data>
+		</dict>
+		<key>Headers/ios_utils.h</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			edmm6ZYsnfjlwb1IJ40iJ7zwVnZZrO91p++TgoSO9ig=
+			</data>
+		</dict>
+		<key>Headers/logging.h</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			YpnrA639xaUs3HHamW6aBrNfc58sEqAIKKxdkgsn7Kk=
+			</data>
+		</dict>
+	</dict>
 	<key>rules</key>
 	<dict>
 		<key>^.*</key>

package/lib/module/api/Database.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { CactusUtil } from "../native/index.js";
+import { packageVersion } from "../constants/packageVersion.js";
+export class Database {
+  static url = 'https://vlqqczxwyaodtcdmdmlw.supabase.co';
+  static key = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZscXFjenh3eWFvZHRjZG1kbWx3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTE1MTg2MzIsImV4cCI6MjA2NzA5NDYzMn0.nBzqGuK9j6RZ6mOPWU2boAC_5H9XDs-fPpo5P3WZYbI';
+  static async sendLogRecords(records) {
+    const response = await fetch(`${this.url}/rest/v1/logs`, {
+      method: 'POST',
+      headers: {
+        'apikey': this.key,
+        'Authorization': `Bearer ${this.key}`,
+        'Content-Type': 'application/json',
+        'Content-Profile': 'cactus',
+        'Prefer': 'return=minimal'
+      },
+      body: JSON.stringify(records)
+    });
+    if (!response.ok) {
+      throw new Error('Sending logs failed');
+    }
+  }
+  static async registerDevice(device_data) {
+    const response = await fetch(`${this.url}/functions/v1/device-registration`, {
+      method: 'POST',
+      body: JSON.stringify({
+        device_data
+      })
+    });
+    if (!response.ok) {
+      throw new Error('Registering device failed');
+    }
+    return await CactusUtil.registerApp(await response.text());
+  }
+  static async getModels() {
+    const response = await fetch(`${this.url}/functions/v1/get-models?sdk_name=react&sdk_version=${packageVersion}`, {
+      headers: {
+        apikey: this.key,
+        Authorization: `Bearer ${this.key}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error('Getting models failed');
+    }
+    const models = await response.json();
+    return models.map(model => ({
+      name: model.name,
+      slug: model.slug,
+      quantization: model.quantization,
+      sizeMb: model.size_mb,
+      downloadUrl: model.download_url,
+      supportsToolCalling: model.supports_tool_calling,
+      supportsVision: model.supports_vision,
+      createdAt: model.created_at,
+      isDownloaded: false
+    }));
+  }
+}
+//# sourceMappingURL=Database.js.map

package/lib/module/api/Database.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CactusUtil","packageVersion","Database","url","key","sendLogRecords","records","response","fetch","method","headers","body","JSON","stringify","ok","Error","registerDevice","device_data","registerApp","text","getModels","apikey","Authorization","models","json","map","model","name","slug","quantization","sizeMb","size_mb","downloadUrl","download_url","supportsToolCalling","supports_tool_calling","supportsVision","supports_vision","createdAt","created_at","isDownloaded"],"sourceRoot":"../../../src","sources":["api/Database.ts"],"mappings":";;AAAA,SAASA,UAAU,QAAQ,oBAAW;AAGtC,SAASC,cAAc,QAAQ,gCAA6B;AAc5D,OAAO,MAAMC,QAAQ,CAAC;EACpB,OAAwBC,GAAG,GAAG,0CAA0C;EACxE,OAAwBC,GAAG,GACzB,kNAAkN;EAEpN,aAAoBC,cAAcA,CAACC,OAAoB,EAAiB;IACtE,MAAMC,QAAQ,GAAG,MAAMC,KAAK,CAAC,GAAG,IAAI,CAACL,GAAG,eAAe,EAAE;MACvDM,MAAM,EAAE,MAAM;MACdC,OAAO,EAAE;QACP,QAAQ,EAAE,IAAI,CAACN,GAAG;QAClB,eAAe,EAAE,UAAU,IAAI,CAACA,GAAG,EAAE;QACrC,cAAc,EAAE,kBAAkB;QAClC,iBAAiB,EAAE,QAAQ;QAC3B,QAAQ,EAAE;MACZ,CAAC;MACDO,IAAI,EAAEC,IAAI,CAACC,SAAS,CAACP,OAAO;IAC9B,CAAC,CAAC;IAEF,IAAI,CAACC,QAAQ,CAACO,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAAC,qBAAqB,CAAC;IACxC;EACF;EAEA,aAAoBC,cAAcA,CAACC,WAAuB,EAAmB;IAC3E,MAAMV,QAAQ,GAAG,MAAMC,KAAK,CAC1B,GAAG,IAAI,CAACL,GAAG,mCAAmC,EAC9C;MACEM,MAAM,EAAE,MAAM;MACdE,IAAI,EAAEC,IAAI,CAACC,SAAS,CAAC;QAAEI;MAAY,CAAC;IACtC,CACF,CAAC;IAED,IAAI,CAACV,QAAQ,CAACO,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAAC,2BAA2B,CAAC;IAC9C;IAEA,OAAO,MAAMf,UAAU,CAACkB,WAAW,CAAC,MAAMX,QAAQ,CAACY,IAAI,CAAC,CAAC,CAAC;EAC5D;EAEA,aAAoBC,SAASA,CAAA,EAA2B;IACtD,MAAMb,QAAQ,GAAG,MAAMC,KAAK,CAC1B,GAAG,IAAI,CAACL,GAAG,uDAAuDF,cAAc,EAAE,EAClF;MACES,OAAO,EAAE;QAAEW,MAAM,EAAE,IAAI,CAACjB,GAAG;QAAEkB,aAAa,EAAE,UAAU,IAAI,CAAClB,GAAG;MAAG;IACnE,CACF,CAAC;IAED,IAAI,CAACG,QAAQ,CAACO,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAAC,uBAAuB,CAAC;IAC1C;IAEA,MAAMQ,MAAM,GAAI,MAAMhB,QAAQ,CAACiB,IAAI,CAAC,CAA2B;IAE/D,OAAOD,MAAM,CAACE,GAAG,CAAEC,KAAK,KAAM;MAC5BC,IAAI,EAAED,KAAK,CAACC,IAAI;MAChBC,IAAI,EAAEF,KAAK,CAACE,IAAI;MAChBC,YAAY,EAAEH,KAAK,CAACG,YAAY;MAChCC,MAAM,EAAEJ,KAAK,CAACK,OAAO;MACrBC,WAAW,EAAEN,KAAK,CAACO,YAAY;MAC/BC,mBAAmB,EAAER,KAAK,CAACS,qBAAqB;MAChDC,cAAc,EAAEV,KAAK,CAACW,eAAe;MACrCC,SAAS,EAAEZ,KAAK,CAACa,UAAU;MAC3BC,YAAY,EAAE;IAChB,CAAC,CAAC,CAAC;EACL;AACF","ignoreList":[]}