@ai.ntellect/core 1.0.0 → 1.1.0

package/benchmark/run-benchmark.ts

@@ -0,0 +1,222 @@
+import { ChatOllama } from '@langchain/ollama';
+import { StateGraph, Annotation } from '@langchain/langgraph';
+import { google } from 'googleapis';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Initialize Ollama
+const model = new ChatOllama({
+  model: 'llama3:latest',
+  baseUrl: 'http://localhost:11434',
+  temperature: 0,
+});
+
+// Gmail client
+function createGmailClient() {
+  const tokenPath = path.join(__dirname, '../gmail_token.json');
+  const credentials = JSON.parse(fs.readFileSync(path.join(__dirname, '../client_secret.json'), 'utf8'));
+  const token = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
+
+  const oauth2Client = new google.auth.OAuth2(
+    credentials.web.client_id,
+    credentials.web.client_secret,
+    'http://localhost:3000/oauth2callback'
+  );
+  oauth2Client.setCredentials(token);
+  return google.gmail({ version: 'v1', auth: oauth2Client });
+}
+
+// Fetch mails
+async function fetchMails(gmail: any, maxResults = 5) {
+  console.log('  [Fetch] Fetching mails from Gmail API...');
+  const res = await gmail.users.messages.list({
+    userId: 'me',
+    maxResults,
+    q: '',
+  });
+  const messages = res.data.messages || [];
+  const mails: any[] = [];
+  for (const msg of messages) {
+    const detail = await gmail.users.messages.get({
+      userId: 'me',
+      id: msg.id!,
+      format: 'metadata',
+      metadataHeaders: ['Subject', 'From'],
+    });
+    const headers = detail.data.payload?.headers || [];
+    mails.push({
+      id: msg.id,
+      subject: headers.find((h: any) => h.name === 'Subject')?.value || '(no subject)',
+      from: headers.find((h: any) => h.name === 'From')?.value || '(unknown)',
+    });
+  }
+  return mails;
+}
+
+// Summarize
+async function summarizeMails(mails: any[]) {
+  console.log('  [Summarize] Summarizing with LLM...');
+  const mailText = mails.map((m: any) => `From: ${m.from}\nSubject: ${m.subject}`).join('\n\n');
+  const prompt = `Summarize these emails in 3 bullet points max:\n\n${mailText}\n\nRespond in JSON: {"summary": "..."}`;
+
+  const response = await model.invoke([{ role: 'user', content: prompt }]);
+  try {
+    const parsed = JSON.parse(response.content as string);
+    return parsed.summary;
+  } catch {
+    return response.content;
+  }
+}
+
+// LangGraph workflow
+const MailState = Annotation.Root({
+  messages: Annotation<Array<{ role: 'user' | 'assistant'; content: string }>>({
+    reducer: (curr, update) => curr.concat(update),
+  }),
+  mails: Annotation<any[]>(),
+  summary: Annotation<string>(),
+  maxMails: Annotation<number>(),
+});
+
+const workflow = new StateGraph(MailState)
+  .addNode('fetch_mails', async (state) => {
+    const gmail = createGmailClient();
+    const mails = await fetchMails(gmail, state.maxMails || 5);
+    console.log(`  [LangGraph] Fetched ${mails.length} mails`);
+    return { mails };
+  })
+  .addNode('summarize', async (state) => {
+    const summary = await summarizeMails(state.mails);
+    console.log(`  [LangGraph] Summary: ${summary}`);
+    return { summary };
+  })
+  .addEdge('__start__', 'fetch_mails')
+  .addEdge('fetch_mails', 'summarize')
+  .addEdge('summarize', '__end__');
+
+const graph = workflow.compile();
+
+async function runLangGraph() {
+  console.log('\n🚀 Starting LangGraph benchmark...\n');
+  const startTime = Date.now();
+  const startMemory = process.memoryUsage().heapUsed;
+
+  const result = await graph.invoke({
+    messages: [{ role: 'user', content: 'Fetch 5 mails and summarize' }],
+    maxMails: 5,
+  });
+
+  const endTime = Date.now();
+  const endMemory = process.memoryUsage().heapUsed;
+
+  return {
+    framework: 'LangGraph',
+    totalTime: endTime - startTime,
+    llmCalls: 1,
+    memoryUsed: endMemory - startMemory,
+    summary: result.summary,
+    mailsCount: result.mails?.length || 0,
+  };
+}
+
+// CortexFlow simulation (lightweight)
+async function runCortexFlow() {
+  console.log('\n🚀 Starting CortexFlow benchmark...\n');
+  const startTime = Date.now();
+  const startMemory = process.memoryUsage().heapUsed;
+  let llmCalls = 0;
+
+  const llmCall = async (prompt: string) => {
+    llmCalls++;
+    const response = await fetch('http://localhost:11434/api/generate', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'llama3:latest',
+        prompt,
+        stream: false,
+        format: 'json',
+      }),
+      signal: AbortSignal.timeout(30000),
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = await response.json();
+    return data.response;
+  };
+
+  const gmail = createGmailClient();
+
+  // Simulate intent classification
+  llmCalls++;
+  const intent = await llmCall(`Classify intent: "fetch 5 mails". Possible: FETCH_MAILS, SUMMARIZE. JSON: {"intent": "...", "confidence": 0.9}`);
+
+  // Fetch mails
+  const mails = await fetchMails(gmail, 5);
+
+  // Summarize
+  const summary = await summarizeMails(mails);
+
+  const endTime = Date.now();
+  const endMemory = process.memoryUsage().heapUsed;
+
+  return {
+    framework: 'CortexFlow',
+    totalTime: endTime - startTime,
+    llmCalls,
+    memoryUsed: endMemory - startMemory,
+    summary,
+    mailsCount: mails.length,
+  };
+}
+
+// Main benchmark
+async function main() {
+  console.log('═══════════════════════════════════════════');
+  console.log('   CortexFlow vs LangGraph Benchmark');
+  console.log('   Scenario: Fetch 5 Gmail + LLM Summarization');
+  console.log('═══════════════════════════════════════════\n');
+
+  const cortexResult = await runCortexFlow();
+  const langGraphResult = await runLangGraph();
+
+  console.log('\n═══════════════════════════════════════════');
+  console.log('                    RESULTS');
+  console.log('═══════════════════════════════════════════\n');
+
+  console.log('Framework'.padEnd(20) + 'CortexFlow'.padEnd(20) + 'LangGraph');
+  console.log('-'.repeat(60));
+  console.log(
+    'Total Time'.padEnd(20) +
+    `${cortexResult.totalTime}ms`.padEnd(20) +
+    `${langGraphResult.totalTime}ms`
+  );
+  console.log(
+    'LLM Calls'.padEnd(20) +
+    `${cortexResult.llmCalls}`.padEnd(20) +
+    `${langGraphResult.llmCalls}`
+  );
+  console.log(
+    'Memory Used'.padEnd(20) +
+    `${(cortexResult.memoryUsed / 1024 / 1024).toFixed(2)}MB`.padEnd(20) +
+    `${(langGraphResult.memoryUsed / 1024 / 1024).toFixed(2)}MB`
+  );
+  console.log(
+    'Mails Fetched'.padEnd(20) +
+    `${cortexResult.mailsCount}`.padEnd(20) +
+    `${langGraphResult.mailsCount}`
+  );
+
+  console.log('\n─────────────────────────────────────────────');
+  console.log('Summary Comparison:');
+  console.log('CortexFlow:', cortexResult.summary?.substring(0, 100) + '...');
+  console.log('LangGraph:', langGraphResult.summary?.substring(0, 100) + '...');
+
+  if (langGraphResult.totalTime > 0) {
+    const speedup = (langGraphResult.totalTime / cortexResult.totalTime).toFixed(2);
+    console.log(`\n⚡ CortexFlow is ${speedup}x faster than LangGraph`);
+  }
+
+  console.log('\n═══════════════════════════════════════════\n');
+}
+
+main().catch(console.error);

package/cli-dev.ts

@@ -0,0 +1,419 @@
+/**
+ * @file cli-dev.ts
+ * @description CortexFlow interactive development REPL.
+ *
+ * Provides a lightweight command-line debugger for Petri Net workflows.
+ * Load a JSON workflow definition, inspect token state, fire transitions manually
+ * or automatically, inject tokens, and export the graph to DOT format — all
+ * without writing a single line of test code.
+ *
+ * Usage:
+ * ```sh
+ * npx ts-node cli-dev.ts [workflow.json]
+ * ```
+ *
+ * Commands available at the prompt:
+ * - `load <file.json>`        — Load a workflow definition from disk
+ * - `show [placeId]`          — Display current token marking (optionally filtered to one place)
+ * - `enabled`                 — List all currently enabled transitions
+ * - `step <transitionId>`     — Fire a single transition
+ * - `auto`                    — Auto-fire transitions until the net is blocked (max 100 steps)
+ * - `inject <placeId> [json]` — Inject a token into a place
+ * - `history`                 — Show the ordered transition fire history
+ * - `dot`                     — Print a Graphviz DOT representation of the net
+ * - `reset`                   — Reset marking to the initial state
+ * - `help`                    — Print this command reference
+ * - `exit`                    — Quit the REPL
+ */
+
+import * as readline from 'readline';
+import { PetriNet, TransitionResult } from './routing/index';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * JSON schema for a workflow definition file loaded by the `load` command.
+ *
+ * Example file:
+ * ```json
+ * {
+ *   "name": "approval_flow",
+ *   "places": [
+ *     { "id": "idle",     "type": "initial", "tokens": [{ "id": "start" }] },
+ *     { "id": "pending",  "type": "normal"  },
+ *     { "id": "approved", "type": "final"   }
+ *   ],
+ *   "transitions": [
+ *     { "id": "submit",  "from": ["idle"],    "to": "pending"  },
+ *     { "id": "approve", "from": ["pending"], "to": "approved" }
+ *   ]
+ * }
+ * ```
+ */
+interface WorkflowDefinition {
+  name: string;
+  places: Array<{
+    id: string;
+    type: 'initial' | 'normal' | 'final';
+    tokens?: Array<{ id: string; data?: any }>;
+  }>;
+  transitions: Array<{
+    id: string;
+    from: string[];
+    to: string | string[];
+    description?: string;
+  }>;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Reads and parses a workflow definition JSON file, building a live `PetriNet`.
+ *
+ * @param filePath - Path to the JSON file (relative or absolute).
+ * @returns A fully configured `PetriNet` instance.
+ * @throws If the file does not exist or the JSON is malformed.
+ */
+function loadWorkflow(filePath: string): PetriNet {
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`Workflow file not found: ${absPath}`);
+  }
+
+  const def: WorkflowDefinition = JSON.parse(fs.readFileSync(absPath, 'utf8'));
+  const net = new PetriNet(def.name || 'loaded');
+
+  for (const place of def.places) {
+    net.addPlace({
+      id: place.id,
+      type: place.type,
+      tokens: place.tokens?.map(t => ({
+        id: t.id,
+        data: t.data || {},
+        createdAt: Date.now(),
+      })) || [],
+    });
+  }
+
+  for (const transition of def.transitions) {
+    net.addTransition({
+      id: transition.id,
+      from: transition.from,
+      to: transition.to,
+      description: transition.description,
+    });
+  }
+
+  return net;
+}
+
+/** Prints the full command reference to stdout. */
+function showHelp(): void {
+  console.log(`
+CortexFlow DEV CLI — Interactive Petri Net Debugger
+════════════════════════════════════════════════════
+
+Commands:
+  load <file.json>        Load a workflow from a JSON file
+  show [placeId]          Display token marking (all places, or one specific place)
+  enabled                 List currently enabled transitions
+  step <transitionId>     Fire a specific transition
+  auto                    Auto-fire all enabled transitions until blocked (max 100 steps)
+  inject <placeId> [json] Inject a token into a place (optional JSON data)
+  history                 Show the ordered transition fire history
+  dot                     Export the net to Graphviz DOT format
+  reset                   Reset marking to the initial state
+  help / ?                Show this help message
+  exit / quit             Quit the REPL
+
+Examples:
+  load ./examples/approval_flow.json
+  show
+  show idle
+  step submit
+  inject pending {"priority":"high"}
+  auto
+  dot > graph.dot
+`);
+}
+
+/**
+ * Renders the full token marking of a Petri net to stdout.
+ *
+ * Each place is prefixed with an icon reflecting its type:
+ * - 🟢 initial
+ * - 🔴 final
+ * - ⚪ normal
+ *
+ * Up to 3 token payloads are shown inline; excess tokens are summarised.
+ *
+ * @param net - The `PetriNet` whose marking to display.
+ */
+function showMarking(net: PetriNet): void {
+  console.log('\n📊 Current Marking:');
+  const places = (net as any).places as Map<string, any>;
+  const marking = (net as any).state.marking as Map<string, any[]>;
+
+  for (const [pid, place] of places) {
+    const tokens = marking.get(pid) || [];
+    const icon = place.type === 'initial' ? '🟢' : place.type === 'final' ? '🔴' : '⚪';
+    console.log(`  ${icon} ${pid} (${place.type}): ${tokens.length} token(s)`);
+
+    const preview = tokens.slice(0, 3);
+    for (const token of preview) {
+      console.log(`    - ${token.id}: ${JSON.stringify(token.data || {})}`);
+    }
+
+    if (tokens.length > 3) {
+      console.log(`    … and ${tokens.length - 3} more`);
+    }
+  }
+  console.log();
+}
+
+// ---------------------------------------------------------------------------
+// Main REPL
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  let net: PetriNet | null = null;
+  const args = process.argv.slice(2);
+
+  console.log('\n🚀 CortexFlow DEV CLI\n');
+
+  if (args.length > 0) {
+    try {
+      net = loadWorkflow(args[0]);
+      console.log(`✅ Loaded workflow: ${net.name}\n`);
+      showMarking(net);
+    } catch (error) {
+      console.error(`❌ Error loading workflow:`, (error as Error).message);
+      process.exit(1);
+    }
+  } else {
+    console.log('No workflow file provided. Use "load <file>" to load one.\n');
+  }
+
+  const prompt = () => {
+    const prefix = net ? `${net.name}> ` : 'cortex> ';
+    rl.question(prefix, async (input) => {
+      const parts = input.trim().split(/\s+/);
+      const cmd = parts[0]?.toLowerCase();
+
+      if (!cmd) {
+        prompt();
+        return;
+      }
+
+      try {
+        switch (cmd) {
+          // ── load ──────────────────────────────────────────────────────────
+          case 'load': {
+            if (!parts[1]) { console.log('Usage: load <file.json>'); break; }
+            try {
+              net = loadWorkflow(parts[1]);
+              console.log(`✅ Loaded workflow: ${net.name}\n`);
+              showMarking(net);
+            } catch (error) {
+              console.error(`❌ Error:`, (error as Error).message);
+            }
+            break;
+          }
+
+          // ── show ──────────────────────────────────────────────────────────
+          case 'show': {
+            if (!net) { console.log('No workflow loaded. Use "load" first.'); break; }
+            if (parts[1]) {
+              const marking = (net as any).state.marking as Map<string, any[]>;
+              const tokens = marking.get(parts[1]) || [];
+              console.log(`Place ${parts[1]}: ${tokens.length} token(s)`);
+              tokens.forEach(t => console.log(`  - ${t.id}:`, t.data));
+            } else {
+              showMarking(net);
+            }
+            break;
+          }
+
+          // ── enabled ───────────────────────────────────────────────────────
+          case 'enabled': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            const enabled = net.getEnabledTransitions();
+            if (enabled.length === 0) {
+              console.log('⚠️  No enabled transitions');
+            } else {
+              console.log('✅ Enabled transitions:');
+              enabled.forEach(tid => console.log(`  - ${tid}`));
+            }
+            break;
+          }
+
+          // ── step ──────────────────────────────────────────────────────────
+          case 'step': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            const tid = parts[1];
+            if (!tid) { console.log('Usage: step <transitionId>'); break; }
+
+            const result: TransitionResult = await net.fireTransition(tid);
+            if (result.success) {
+              console.log(`✅ Transition "${tid}" fired successfully`);
+              if (result.consumedTokens?.length) {
+                console.log(`  Consumed: ${result.consumedTokens.length} token(s)`);
+              }
+              if (result.producedTokens?.length) {
+                console.log(`  Produced: ${result.producedTokens.length} token(s)`);
+              }
+              showMarking(net);
+            } else {
+              console.log(`❌ Failed to fire "${tid}": ${result.error || 'Unknown error'}`);
+            }
+            break;
+          }
+
+          // ── auto ──────────────────────────────────────────────────────────
+          case 'auto': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            let steps = 0;
+            const MAX_AUTO_STEPS = 100;
+
+            while (true) {
+              const enabled = net.getEnabledTransitions();
+              if (enabled.length === 0) {
+                console.log(`⏹  Blocked after ${steps} step(s)`);
+                break;
+              }
+
+              const tid = enabled[0];
+              const result = await net.fireTransition(tid);
+              if (!result.success) {
+                console.log(`❌ Failed at step ${steps + 1} ("${tid}"): ${result.error}`);
+                break;
+              }
+
+              steps++;
+              process.stdout.write(`  Step ${steps}: "${tid}"`);
+
+              // Inline token counts for the first 10 steps to avoid flooding the terminal.
+              if (steps <= 10) {
+                const marking = (net as any).state.marking as Map<string, any[]>;
+                const nonEmpty = Array.from(marking.entries())
+                  .filter(([, tokens]) => tokens.length > 0)
+                  .map(([pid, tokens]) => `${pid}:${tokens.length}`)
+                  .join(' ');
+                process.stdout.write(`  [${nonEmpty}]`);
+              }
+              process.stdout.write('\n');
+
+              if (steps >= MAX_AUTO_STEPS) {
+                console.log(`⚠️  Stopping auto after ${MAX_AUTO_STEPS} steps`);
+                break;
+              }
+            }
+
+            showMarking(net);
+            break;
+          }
+
+          // ── inject ────────────────────────────────────────────────────────
+          case 'inject': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            const placeId = parts[1];
+            if (!placeId) { console.log('Usage: inject <placeId> [jsonData]'); break; }
+
+            const jsonStr = parts.slice(2).join(' ');
+            const data = jsonStr ? JSON.parse(jsonStr) : {};
+            const marking = (net as any).state.marking as Map<string, any[]>;
+
+            if (!marking.has(placeId)) {
+              console.log(`❌ Place "${placeId}" not found`);
+              break;
+            }
+
+            marking.get(placeId)!.push({
+              id: `token_${Date.now()}`,
+              data,
+              createdAt: Date.now(),
+            });
+
+            console.log(`✅ Token injected into "${placeId}"`);
+            showMarking(net);
+            break;
+          }
+
+          // ── history ───────────────────────────────────────────────────────
+          case 'history': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            const history = (net as any).state.history as string[];
+            if (history.length === 0) {
+              console.log('No transition history yet.');
+            } else {
+              console.log('📜 Transition History:');
+              history.forEach((tid, i) => console.log(`  ${i + 1}. ${tid}`));
+            }
+            break;
+          }
+
+          // ── dot ───────────────────────────────────────────────────────────
+          case 'dot': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            console.log(net.toDot());
+            break;
+          }
+
+          // ── reset ─────────────────────────────────────────────────────────
+          case 'reset': {
+            if (!net) { console.log('No workflow loaded.'); break; }
+            const places = (net as any).places as Map<string, any>;
+            const marking = (net as any).state.marking as Map<string, any[]>;
+
+            for (const [pid, place] of places) {
+              if (place.type === 'initial') {
+                marking.set(pid, place.tokens.map((t: any) => ({ ...t })));
+              } else {
+                marking.set(pid, []);
+              }
+            }
+            (net as any).state.history = [];
+            console.log('✅ Reset to initial marking\n');
+            showMarking(net);
+            break;
+          }
+
+          // ── help ──────────────────────────────────────────────────────────
+          case 'help':
+          case '?':
+            showHelp();
+            break;
+
+          // ── exit ──────────────────────────────────────────────────────────
+          case 'exit':
+          case 'quit':
+            console.log('\n👋 Goodbye!\n');
+            rl.close();
+            process.exit(0);
+
+          default:
+            console.log(`Unknown command: "${cmd}". Type "help" for available commands.`);
+        }
+      } catch (error) {
+        console.error(`❌ Error:`, (error as Error).message);
+      }
+
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+main().catch(console.error);

package/dist/agent/agent-workflow.d.ts

@@ -0,0 +1,41 @@
+import { GraphFlow } from "../execution/index";
+import { AgentContext, AgentContextSchema } from "../types/agent";
+import { AgentLogger } from "./tools/logger";
+import { BaseAgent } from "./base";
+export interface CognitiveNodeContext {
+    executor: {
+        makeDecision: (context: AgentContext) => Promise<{
+            actions: any[];
+            response: string;
+            thought?: string;
+        }>;
+        executeActions: (actions: any[], context: AgentContext) => Promise<void>;
+        updateDynamicGoal: (context: AgentContext) => Promise<string>;
+        reflect: (context: AgentContext) => Promise<{
+            learning: string;
+            adjustedGoal?: string;
+        }>;
+        scheduleTask?: (cron: string, request: string) => Promise<string | null>;
+        decomposeTask?: (actions: any[], context: AgentContext) => Promise<{
+            groups: any[][];
+            response: string;
+        }>;
+    };
+    baseAgent: BaseAgent;
+    logger: AgentLogger;
+    maxIterations: number;
+    enableClone?: boolean;
+    entityResolver?: {
+        resolve: (ctx: any) => any;
+        getIndex: () => any;
+    };
+    exploreStrategy?: {
+        plan: (candidates: any[], cwd: string) => {
+            type: string;
+            path: string;
+            reason: string;
+        }[];
+    };
+}
+export declare function buildAgentWorkflow(ctx: CognitiveNodeContext): GraphFlow<typeof AgentContextSchema>;
+//# sourceMappingURL=agent-workflow.d.ts.map

package/dist/agent/agent-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-workflow.d.ts","sourceRoot":"","sources":["../../agent/agent-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAmB,MAAM,gBAAgB,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAEnC,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE;QACR,YAAY,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC;YAAE,OAAO,EAAE,GAAG,EAAE,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACzG,cAAc,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QACzE,iBAAiB,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;QAC9D,OAAO,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,YAAY,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACzF,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QACzE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC;YAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC3G,CAAC;IACF,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,WAAW,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE;QACf,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC;QAC3B,QAAQ,EAAE,MAAM,GAAG,CAAC;KACrB,CAAC;IACF,eAAe,CAAC,EAAE;QAChB,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,MAAM,KAAK;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KAC5F,CAAC;CACH;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,oBAAoB,GAAG,SAAS,CAAC,OAAO,kBAAkB,CAAC,CA4hBlG"}