agentic-flow 2.0.2-alpha → 2.0.2

package/dist/wasm/edge-full.d.ts

@@ -0,0 +1,366 @@
+/**
+ * RuVector Edge-Full Integration
+ *
+ * Complete WASM toolkit for edge AI providing:
+ *
+ * Modules:
+ * - edge: Core WASM primitives (HNSW, Identity, Crypto)
+ * - graph: Graph database with Cypher/SPARQL/SQL support
+ * - rvlite: Lightweight vector operations
+ * - sona: Self-learning neural adaptation (SONA)
+ * - dag: DAG workflow orchestration
+ * - onnx: ONNX embeddings inference
+ *
+ * Features:
+ * - Pure WASM: Runs in browser, Node.js, Cloudflare Workers, Deno
+ * - Post-quantum cryptography
+ * - P2P swarm coordination
+ * - Raft consensus
+ * - SIMD acceleration
+ *
+ * @see https://github.com/ruvnet/ruvector/tree/main/examples/edge-full
+ */
+/**
+ * Main EdgeFull module interface
+ */
+interface EdgeFullModule {
+    edge: EdgeModule;
+    graph: GraphModule;
+    rvlite: RvLiteModule;
+    sona: SonaModule;
+    dag: DagModule;
+    onnx: OnnxModule;
+    isReady: () => boolean;
+    getVersion: () => string;
+}
+/**
+ * Edge module - Core WASM primitives
+ */
+interface EdgeModule {
+    default: () => Promise<void>;
+    init: () => Promise<void>;
+    initSync?: () => void;
+    version?: string;
+    WasmHnswIndex: new (dim: number, m?: number, efConstruction?: number) => HnswIndexInstance;
+    WasmIdentity: {
+        generate: () => IdentityInstance;
+        fromSecretKey: (key: Uint8Array) => IdentityInstance;
+    };
+    WasmCrypto?: {
+        hash: (data: Uint8Array) => Uint8Array;
+        encrypt: (key: Uint8Array, data: Uint8Array) => Uint8Array;
+        decrypt: (key: Uint8Array, ciphertext: Uint8Array) => Uint8Array;
+    };
+    WasmHybridKeyPair?: {
+        generate: () => {
+            publicKey: Uint8Array;
+            secretKey: Uint8Array;
+        };
+        encrypt: (publicKey: Uint8Array, data: Uint8Array) => Uint8Array;
+        decrypt: (secretKey: Uint8Array, ciphertext: Uint8Array) => Uint8Array;
+    };
+    WasmSemanticMatcher: new () => SemanticMatcherInstance;
+    WasmAdaptiveCompressor?: new () => unknown;
+    WasmQuantizer?: new () => unknown;
+    WasmRaftNode?: new () => unknown;
+    WasmSpikingNetwork?: new () => unknown;
+    HnswIndex?: new (dim: number, m?: number, efConstruction?: number) => HnswIndexInstance;
+    Identity?: {
+        generate: () => IdentityInstance;
+        fromSecretKey: (key: Uint8Array) => IdentityInstance;
+    };
+    SemanticMatcher?: new () => SemanticMatcherInstance;
+    isReady?: () => boolean;
+}
+interface HnswIndexInstance {
+    add: (vector: Float32Array) => number;
+    search: (query: Float32Array, k: number) => Array<{
+        index: number;
+        distance: number;
+    }>;
+    len: () => number;
+    serialize: () => Uint8Array;
+    deserialize: (data: Uint8Array) => void;
+}
+interface IdentityInstance {
+    publicKey: () => Uint8Array;
+    secretKey: () => Uint8Array;
+    sign: (data: Uint8Array) => Uint8Array;
+    verify: (data: Uint8Array, signature: Uint8Array) => boolean;
+}
+interface SemanticMatcherInstance {
+    registerAgent: (id: string, embedding: Float32Array, capabilities: string[]) => void;
+    matchTask: (embedding: Float32Array, topK: number) => Array<{
+        agentId: string;
+        score: number;
+        capabilities: string[];
+    }>;
+}
+/**
+ * Graph module - Cypher/SPARQL/SQL
+ */
+interface GraphModule {
+    default: () => Promise<void>;
+    init: () => Promise<void>;
+    initSync?: () => void;
+    GraphDB: new () => GraphDBInstance;
+    isReady?: () => boolean;
+}
+interface GraphDBInstance {
+    cypher: (query: string) => Promise<any>;
+    sparql: (query: string) => Promise<any>;
+    sql: (query: string) => Promise<any>;
+    createNode: (labels: string[], properties: Record<string, any>) => string;
+    createEdge: (from: string, to: string, type: string, properties?: Record<string, any>) => string;
+    getNode: (id: string) => any;
+    deleteNode: (id: string) => boolean;
+    vectorSearch: (embedding: Float32Array, k: number) => Array<{
+        nodeId: string;
+        distance: number;
+    }>;
+    export: () => Uint8Array;
+    import: (data: Uint8Array) => void;
+}
+/**
+ * RvLite module - Lightweight vector ops
+ */
+interface RvLiteModule {
+    default: () => Promise<void>;
+    init: () => Promise<void>;
+    initSync?: () => void;
+    cosineSimilarity?: (a: Float32Array, b: Float32Array) => number;
+    dotProduct?: (a: Float32Array, b: Float32Array) => number;
+    euclideanDistance?: (a: Float32Array, b: Float32Array) => number;
+    normalize?: (v: Float32Array) => Float32Array;
+    batchCosineSimilarity?: (queries: Float32Array[], corpus: Float32Array[]) => number[][];
+    isSIMDEnabled?: () => boolean;
+    isReady?: () => boolean;
+}
+/**
+ * SONA module - Self-learning
+ */
+interface SonaModule {
+    default: () => Promise<void>;
+    init: () => Promise<void>;
+    initSync?: () => void;
+    SonaEngine?: new (config?: SonaConfig) => SonaEngineInstance;
+    isReady?: () => boolean;
+}
+interface SonaConfig {
+    embeddingDim?: number;
+    hiddenDim?: number;
+    microLoraRank?: number;
+    baseLoraRank?: number;
+    ewcLambda?: number;
+    learningRate?: number;
+}
+interface SonaEngineInstance {
+    route: (taskEmbedding: Float32Array) => {
+        agentId: string;
+        confidence: number;
+    };
+    learn: (taskEmbedding: Float32Array, agentId: string, reward: number) => void;
+    addPattern: (pattern: {
+        task: string;
+        agent: string;
+        success: boolean;
+    }) => void;
+    findPatterns: (query: Float32Array, k: number) => Array<{
+        task: string;
+        agent: string;
+        similarity: number;
+    }>;
+    getStats: () => {
+        patterns: number;
+        trajectories: number;
+        avgReward: number;
+    };
+    serialize: () => Uint8Array;
+    deserialize: (data: Uint8Array) => void;
+}
+/**
+ * DAG module - Workflow orchestration
+ */
+interface DagModule {
+    default: () => Promise<void>;
+    init: () => Promise<void>;
+    initSync?: () => void;
+    DagWorkflow?: new () => DagWorkflowInstance;
+    isReady?: () => boolean;
+}
+interface DagWorkflowInstance {
+    addNode: (id: string, handler: (input: any) => Promise<any>) => void;
+    addEdge: (from: string, to: string) => void;
+    execute: (input: any) => Promise<any>;
+    executeParallel: (inputs: any[]) => Promise<any[]>;
+    getTopologicalOrder: () => string[];
+    validate: () => {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * ONNX module - Embeddings
+ */
+interface OnnxModule {
+    default: () => Promise<void>;
+    init: () => Promise<void>;
+    initSync?: () => void;
+    embed?: (text: string) => Promise<Float32Array>;
+    embedBatch?: (texts: string[]) => Promise<Float32Array[]>;
+    loadModel?: (modelData?: Uint8Array) => Promise<void>;
+    isModelLoaded?: () => boolean;
+    getModelInfo?: () => {
+        name: string;
+        dimension: number;
+    };
+    similarity?: (text1: string, text2: string) => Promise<number>;
+    isReady?: () => boolean;
+}
+/**
+ * Initialize EdgeFull WASM module
+ */
+export declare function initEdgeFull(): Promise<boolean>;
+/**
+ * Check if EdgeFull is available
+ */
+export declare function isEdgeFullAvailable(): boolean;
+/**
+ * Get EdgeFull module (initialize if needed)
+ */
+export declare function getEdgeFull(): Promise<EdgeFullModule | null>;
+/**
+ * EdgeFull HNSW Index with JS fallback
+ */
+export declare class EdgeFullHnswIndex {
+    private wasmIndex;
+    private jsVectors;
+    private dimensions;
+    constructor(dimensions: number, m?: number, efConstruction?: number);
+    add(vector: Float32Array | number[]): number;
+    search(query: Float32Array | number[], k?: number): Array<{
+        index: number;
+        distance: number;
+    }>;
+    size(): number;
+    isWasmAccelerated(): boolean;
+    private euclideanDistance;
+}
+/**
+ * EdgeFull Graph Database with Cypher support
+ */
+export declare class EdgeFullGraphDB {
+    private wasmGraph;
+    private jsNodes;
+    private jsEdges;
+    private nodeCounter;
+    private edgeCounter;
+    constructor();
+    cypher(query: string): Promise<any>;
+    createNode(labels: string[], properties?: Record<string, any>): string;
+    createEdge(from: string, to: string, type: string, properties?: Record<string, any>): string;
+    getNode(id: string): any;
+    isWasmAccelerated(): boolean;
+}
+/**
+ * EdgeFull SONA Engine with JS fallback
+ */
+export declare class EdgeFullSonaEngine {
+    private wasmSona;
+    private jsPatterns;
+    private agentScores;
+    constructor(config?: SonaConfig);
+    route(taskEmbedding: Float32Array): {
+        agentId: string;
+        confidence: number;
+    };
+    learn(taskEmbedding: Float32Array, agentId: string, reward: number): void;
+    addPattern(pattern: {
+        task: string;
+        agent: string;
+        success: boolean;
+    }): void;
+    getStats(): {
+        patterns: number;
+        trajectories: number;
+        avgReward: number;
+    };
+    isWasmAccelerated(): boolean;
+}
+/**
+ * EdgeFull ONNX Embeddings
+ */
+export declare class EdgeFullOnnxEmbeddings {
+    private initialized;
+    init(): Promise<boolean>;
+    embed(text: string): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    similarity(text1: string, text2: string): Promise<number>;
+    isAvailable(): boolean;
+    private simpleEmbed;
+    private cosineSimilarity;
+}
+/**
+ * EdgeFull DAG Workflow
+ */
+export declare class EdgeFullDagWorkflow {
+    private wasmDag;
+    private nodes;
+    private edges;
+    constructor();
+    addNode(id: string, handler: (input: any) => Promise<any>): void;
+    addEdge(from: string, to: string): void;
+    execute(input: any): Promise<any>;
+    getTopologicalOrder(): string[];
+    isWasmAccelerated(): boolean;
+}
+/**
+ * Cosine similarity (SIMD-accelerated when available)
+ */
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * Dot product (SIMD-accelerated when available)
+ */
+export declare function dotProduct(a: Float32Array, b: Float32Array): number;
+/**
+ * Normalize vector (SIMD-accelerated when available)
+ */
+export declare function normalize(v: Float32Array): Float32Array;
+/**
+ * Check if SIMD is enabled
+ */
+export declare function isSIMDEnabled(): boolean;
+export interface EdgeFullStats {
+    available: boolean;
+    version: string;
+    modules: {
+        edge: boolean;
+        graph: boolean;
+        rvlite: boolean;
+        sona: boolean;
+        dag: boolean;
+        onnx: boolean;
+    };
+    simdEnabled: boolean;
+}
+/**
+ * Get EdgeFull statistics
+ */
+export declare function getEdgeFullStats(): EdgeFullStats;
+declare const _default: {
+    initEdgeFull: typeof initEdgeFull;
+    isEdgeFullAvailable: typeof isEdgeFullAvailable;
+    getEdgeFull: typeof getEdgeFull;
+    getEdgeFullStats: typeof getEdgeFullStats;
+    EdgeFullHnswIndex: typeof EdgeFullHnswIndex;
+    EdgeFullGraphDB: typeof EdgeFullGraphDB;
+    EdgeFullSonaEngine: typeof EdgeFullSonaEngine;
+    EdgeFullOnnxEmbeddings: typeof EdgeFullOnnxEmbeddings;
+    EdgeFullDagWorkflow: typeof EdgeFullDagWorkflow;
+    cosineSimilarity: typeof cosineSimilarity;
+    dotProduct: typeof dotProduct;
+    normalize: typeof normalize;
+    isSIMDEnabled: typeof isSIMDEnabled;
+};
+export default _default;
+//# sourceMappingURL=edge-full.d.ts.map

package/dist/wasm/onnx-embeddings-wasm.d.ts

@@ -0,0 +1,123 @@
+/**
+ * ONNX Embeddings WASM Integration
+ *
+ * Provides browser-compatible embeddings using ruvector-onnx-embeddings-wasm.
+ *
+ * Features:
+ * - Pure WASM: No native dependencies, runs in browser
+ * - all-MiniLM-L6-v2: 384-dimensional semantic embeddings
+ * - SIMD Acceleration: Uses WebAssembly SIMD when available
+ * - Small Bundle: Optimized WASM binary size
+ *
+ * Use Cases:
+ * - Browser-based semantic search
+ * - Client-side RAG applications
+ * - Edge computing (Cloudflare Workers, Deno Deploy)
+ * - Offline-first applications
+ *
+ * Performance:
+ * - ~50ms per embedding (SIMD enabled)
+ * - ~200ms per embedding (SIMD disabled)
+ * - Batch processing: ~30ms per embedding
+ */
+interface ModelInfo {
+    name: string;
+    dimension: number;
+    vocabSize: number;
+    maxSequenceLength: number;
+}
+export interface OnnxEmbeddingResult {
+    embedding: Float32Array;
+    timeMs: number;
+    source: 'wasm' | 'fallback';
+}
+export interface OnnxBatchResult {
+    embeddings: Float32Array[];
+    totalTimeMs: number;
+    avgTimeMs: number;
+    source: 'wasm' | 'fallback';
+}
+export interface OnnxEmbeddingsStats {
+    available: boolean;
+    simdEnabled: boolean;
+    modelLoaded: boolean;
+    modelInfo?: ModelInfo;
+    totalEmbeddings: number;
+    totalLatencyMs: number;
+    avgLatencyMs: number;
+}
+/**
+ * Initialize ONNX Embeddings WASM module
+ */
+export declare function initOnnxEmbeddingsWasm(): Promise<boolean>;
+/**
+ * Check if ONNX WASM embeddings are available
+ */
+export declare function isOnnxWasmAvailable(): boolean;
+/**
+ * Check if SIMD acceleration is enabled
+ */
+export declare function isSIMDEnabled(): boolean;
+/**
+ * Generate embedding for text using WASM
+ */
+export declare function embed(text: string): Promise<OnnxEmbeddingResult>;
+/**
+ * Generate embeddings for multiple texts (batch processing)
+ */
+export declare function embedBatch(texts: string[]): Promise<OnnxBatchResult>;
+/**
+ * Compute similarity between two texts
+ */
+export declare function similarity(text1: string, text2: string): Promise<number>;
+/**
+ * Compute cosine similarity between two embeddings
+ */
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * Get embedding statistics
+ */
+export declare function getStats(): OnnxEmbeddingsStats;
+/**
+ * Shutdown WASM module
+ */
+export declare function shutdown(): Promise<void>;
+/**
+ * Reset stats (for testing)
+ */
+export declare function resetStats(): void;
+/**
+ * OnnxEmbeddingsWasm class for object-oriented usage
+ */
+export declare class OnnxEmbeddingsWasm {
+    private initialized;
+    init(): Promise<boolean>;
+    embed(text: string): Promise<OnnxEmbeddingResult>;
+    embedBatch(texts: string[]): Promise<OnnxBatchResult>;
+    similarity(text1: string, text2: string): Promise<number>;
+    cosineSimilarity(a: Float32Array, b: Float32Array): number;
+    isAvailable(): boolean;
+    isSIMDEnabled(): boolean;
+    getStats(): OnnxEmbeddingsStats;
+    shutdown(): Promise<void>;
+}
+/**
+ * Get singleton OnnxEmbeddingsWasm instance
+ */
+export declare function getOnnxEmbeddingsWasm(): OnnxEmbeddingsWasm;
+declare const _default: {
+    OnnxEmbeddingsWasm: typeof OnnxEmbeddingsWasm;
+    getOnnxEmbeddingsWasm: typeof getOnnxEmbeddingsWasm;
+    initOnnxEmbeddingsWasm: typeof initOnnxEmbeddingsWasm;
+    isOnnxWasmAvailable: typeof isOnnxWasmAvailable;
+    isSIMDEnabled: typeof isSIMDEnabled;
+    embed: typeof embed;
+    embedBatch: typeof embedBatch;
+    similarity: typeof similarity;
+    cosineSimilarity: typeof cosineSimilarity;
+    getStats: typeof getStats;
+    shutdown: typeof shutdown;
+    resetStats: typeof resetStats;
+};
+export default _default;
+//# sourceMappingURL=onnx-embeddings-wasm.d.ts.map

package/dist/wasm/ruvector-edge.d.ts

@@ -0,0 +1,109 @@
+/**
+ * RuVector Edge WASM Integration
+ *
+ * Provides WASM-accelerated primitives for:
+ * - Ed25519 identity generation (P2P Swarm)
+ * - HNSW vector indexing (150x faster search)
+ * - Semantic task matching (agent routing)
+ *
+ * Falls back to pure JS implementations when WASM unavailable.
+ */
+/**
+ * Check if WASM is supported in current environment
+ */
+export declare function isWasmSupported(): boolean;
+/**
+ * Initialize RuVector Edge WASM module
+ */
+export declare function initRuVectorWasm(): Promise<boolean>;
+/**
+ * Check if WASM module is initialized
+ */
+export declare function isWasmInitialized(): boolean;
+export interface WasmIdentityKeys {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+    publicKeyHex: string;
+}
+/**
+ * Generate Ed25519 identity using WASM (or fallback to Node crypto)
+ */
+export declare function generateIdentity(): Promise<WasmIdentityKeys>;
+/**
+ * Sign data using WASM identity (or fallback)
+ */
+export declare function signData(data: Uint8Array, secretKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Verify signature using WASM (or fallback)
+ */
+export declare function verifySignature(data: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): Promise<boolean>;
+export interface HnswSearchResult {
+    index: number;
+    distance: number;
+}
+/**
+ * HNSW Index wrapper with WASM acceleration
+ */
+export declare class RuVectorHnswIndex {
+    private wasmIndex;
+    private jsVectors;
+    private dimensions;
+    private m;
+    private efConstruction;
+    constructor(dimensions: number, m?: number, efConstruction?: number);
+    /**
+     * Add vector to index
+     */
+    add(vector: Float32Array | number[]): number;
+    /**
+     * Search for k nearest neighbors
+     */
+    search(query: Float32Array | number[], k?: number): HnswSearchResult[];
+    /**
+     * Get index size
+     */
+    size(): number;
+    /**
+     * Check if using WASM acceleration
+     */
+    isWasmAccelerated(): boolean;
+    private euclideanDistance;
+}
+export interface SemanticMatch {
+    agent: string;
+    score: number;
+    capabilities: string[];
+}
+/**
+ * Semantic matcher for intelligent agent routing
+ */
+export declare class RuVectorSemanticMatcher {
+    private wasmMatcher;
+    private jsAgents;
+    constructor();
+    /**
+     * Register agent with capabilities
+     */
+    registerAgent(agentId: string, embedding: Float32Array | number[], capabilities: string[]): void;
+    /**
+     * Find best matching agents for task
+     */
+    matchTask(taskEmbedding: Float32Array | number[], topK?: number): SemanticMatch[];
+    /**
+     * Check if using WASM acceleration
+     */
+    isWasmAccelerated(): boolean;
+    private cosineSimilarity;
+}
+declare const _default: {
+    isWasmSupported: typeof isWasmSupported;
+    initRuVectorWasm: typeof initRuVectorWasm;
+    isWasmInitialized: typeof isWasmInitialized;
+    generateIdentity: typeof generateIdentity;
+    signData: typeof signData;
+    verifySignature: typeof verifySignature;
+    RuVectorHnswIndex: typeof RuVectorHnswIndex;
+    RuVectorSemanticMatcher: typeof RuVectorSemanticMatcher;
+};
+export default _default;
+//# sourceMappingURL=ruvector-edge.d.ts.map

package/dist/workers/consolidated-phases.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Consolidated Phase System
+ *
+ * Eliminates redundancy between phase-executors.ts and ruvector-native-integration.ts
+ * by providing a unified phase registry that:
+ * 1. Uses native implementations as primary (faster, SIMD-optimized)
+ * 2. Falls back to legacy implementations if needed
+ * 3. Shares the cached ONNX embedder across all phases
+ */
+import { WorkerContext } from './types.js';
+import { PhaseResult } from './custom-worker-config.js';
+export interface UnifiedPhaseContext {
+    files: string[];
+    patterns: string[];
+    bytes: number;
+    dependencies: Map<string, string[]>;
+    metrics: Record<string, number>;
+    embeddings: Map<string, Float32Array>;
+    vectors: Map<string, number[]>;
+    phaseData: Map<string, Record<string, unknown>>;
+    vulnerabilities: Array<{
+        type: string;
+        file: string;
+        line: number;
+        severity: string;
+    }>;
+}
+export declare function createUnifiedContext(): UnifiedPhaseContext;
+export type UnifiedPhaseExecutor = (workerContext: WorkerContext, phaseContext: UnifiedPhaseContext, options: Record<string, unknown>) => Promise<PhaseResult>;
+export declare function registerUnifiedPhase(type: string, executor: UnifiedPhaseExecutor): void;
+export declare function getUnifiedPhase(type: string): UnifiedPhaseExecutor | undefined;
+export declare function listUnifiedPhases(): string[];
+export declare function runUnifiedPipeline(workerContext: WorkerContext, phases: string[], options?: Record<string, unknown>): Promise<{
+    success: boolean;
+    phases: string[];
+    context: UnifiedPhaseContext;
+    results: Record<string, PhaseResult>;
+    duration: number;
+}>;
+//# sourceMappingURL=consolidated-phases.d.ts.map

package/dist/workers/consolidated-phases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidated-phases.d.ts","sourceRoot":"","sources":["../../src/workers/consolidated-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAyC,MAAM,2BAA2B,CAAC;AAO/F,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACtC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChD,eAAe,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxF;AAED,wBAAgB,oBAAoB,IAAI,mBAAmB,CAY1D;AAMD,MAAM,MAAM,oBAAoB,GAAG,CACjC,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,mBAAmB,EACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,OAAO,CAAC,WAAW,CAAC,CAAC;AAI1B,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAEvF;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAE9E;AAED,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAE5C;AAqeD,wBAAsB,kBAAkB,CACtC,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,OAAO,CAAC;IACT,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAqCD"}