nova-terminal-assistant 0.1.0

package/src/core/model/providers/CodingPlanProvider.ts

@@ -0,0 +1,210 @@
+// ============================================================================
+// CodingPlanProvider - Support for Chinese Coding Plan platforms
+// ============================================================================
+//
+// Supports multiple Coding Plan platforms with a single API key:
+// - Alibaba Cloud (阿里云百炼)
+// - Tencent Cloud (腾讯云)
+// - Volcengine (火山引擎)
+// - Baidu Qianfan (百度千帆)
+// - Kimi Code
+// - Zhipu AI (智谱)
+// - MiniMax
+//
+// All platforms use OpenAI-compatible API with custom base URLs
+// ============================================================================
+
+import { OpenAICompatibleProvider, type OpenAICompatibleConfig } from './OpenAICompatibleProvider.js';
+
+/** Coding Plan platform identifiers */
+export type CodingPlanPlatform = 
+  | 'alibaba' 
+  | 'tencent' 
+  | 'volcengine' 
+  | 'baidu' 
+  | 'kimi' 
+  | 'zhipu' 
+  | 'minimax'
+  | 'custom';
+
+/** Coding Plan configuration */
+export interface CodingPlanConfig extends Omit<OpenAICompatibleConfig, 'baseUrl'> {
+  platform: CodingPlanPlatform;
+  /** Custom base URL (required if platform is 'custom') */
+  customBaseUrl?: string;
+}
+
+/** Platform-specific configurations */
+const PLATFORM_CONFIGS: Record<CodingPlanPlatform, { 
+  name: string; 
+  baseUrl: string;
+  models: string[];
+  anthropicBaseUrl?: string;
+}> = {
+  alibaba: {
+    name: 'Alibaba Cloud Coding Plan',
+    baseUrl: 'https://coding.dashscope.aliyuncs.com/v1',
+    anthropicBaseUrl: 'https://coding.dashscope.aliyuncs.com/apps/anthropic',
+    models: ['qwen3.5-plus', 'qwen3-coder', 'glm-5', 'minimax-m2.5', 'kimi-k2.5'],
+  },
+  tencent: {
+    name: 'Tencent Cloud Coding Plan',
+    baseUrl: 'https://api.hunyuan.cloud.tencent.com/v1', // 需要从控制台获取实际URL
+    models: ['hy-2.0-instruct', 'glm-5', 'kimi-k2.5', 'minimax-m2.5'],
+  },
+  volcengine: {
+    name: 'Volcengine Coding Plan',
+    baseUrl: 'https://ark.cn-beijing.volces.com/api/v3', // 需要从控制台获取实际URL
+    models: ['doubao-seed-code', 'deepseek-v3.2', 'glm-4.7', 'kimi-k2'],
+  },
+  baidu: {
+    name: 'Baidu Qianfan Coding Plan',
+    baseUrl: 'https://qianfan.baidubce.com/v2', // 需要从控制台获取实际URL
+    models: ['glm-5', 'minimax-m2.5', 'kimi-k2.5', 'ernie-4.5'],
+  },
+  kimi: {
+    name: 'Kimi Code',
+    baseUrl: 'https://api.moonshot.cn/v1',
+    models: ['kimi-k2', 'kimi-k2.5'],
+  },
+  zhipu: {
+    name: 'Zhipu AI Coding Plan',
+    baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+    models: ['glm-4.7', 'glm-5'],
+  },
+  minimax: {
+    name: 'MiniMax Coding Plan',
+    baseUrl: 'https://api.minimax.chat/v1',
+    models: ['minimax-2.7', 'abab6.5s-chat'],
+  },
+  custom: {
+    name: 'Custom Coding Plan',
+    baseUrl: '',
+    models: [],
+  },
+};
+
+/**
+ * Coding Plan Provider - Access multiple AI models through Chinese Coding Plan platforms
+ * 
+ * @example
+ * ```typescript
+ * // 使用阿里云百炼 Coding Plan
+ * const provider = new CodingPlanProvider({
+ *   platform: 'alibaba',
+ *   apiKey: 'your-coding-plan-api-key',
+ *   model: 'qwen3-coder',
+ * });
+ * 
+ * // 使用自定义 Coding Plan
+ * const provider = new CodingPlanProvider({
+ *   platform: 'custom',
+ *   customBaseUrl: 'https://your-coding-plan-endpoint.com/v1',
+ *   apiKey: 'your-api-key',
+ *   model: 'custom-model',
+ * });
+ * ```
+ */
+export class CodingPlanProvider extends OpenAICompatibleProvider {
+  readonly name: string;
+  readonly platform: CodingPlanPlatform;
+  readonly supportedModels: string[];
+
+  constructor(config: CodingPlanConfig) {
+    const platformConfig = PLATFORM_CONFIGS[config.platform];
+    
+    if (!platformConfig) {
+      throw new Error(`Unknown Coding Plan platform: ${config.platform}`);
+    }
+
+    if (config.platform === 'custom' && !config.customBaseUrl) {
+      throw new Error('customBaseUrl is required when platform is "custom"');
+    }
+
+    const baseUrl = config.platform === 'custom' 
+      ? config.customBaseUrl 
+      : platformConfig.baseUrl;
+
+    super({
+      apiKey: config.apiKey,
+      baseUrl: baseUrl,
+      model: config.model,
+      headers: config.headers,
+    });
+
+    this.name = platformConfig.name;
+    this.platform = config.platform;
+    this.supportedModels = platformConfig.models;
+
+    // Validate model if platform has known models
+    if (platformConfig.models.length > 0 && !platformConfig.models.includes(config.model)) {
+      console.warn(
+        `[CodingPlanProvider] Model "${config.model}" may not be supported by ${platformConfig.name}. ` +
+        `Known models: ${platformConfig.models.join(', ')}`
+      );
+    }
+  }
+
+  /**
+   * Get list of supported models for this platform
+   */
+  getSupportedModels(): string[] {
+    return [...this.supportedModels];
+  }
+
+  /**
+   * Get platform info
+   */
+  getPlatformInfo(): { name: string; platform: CodingPlanPlatform; baseUrl: string } {
+    const config = PLATFORM_CONFIGS[this.platform];
+    return {
+      name: this.name,
+      platform: this.platform,
+      baseUrl: this.platform === 'custom' ? '' : config.baseUrl,
+    };
+  }
+
+  /**
+   * Get Anthropic-compatible base URL (for Alibaba Cloud only)
+   */
+  getAnthropicBaseUrl(): string | null {
+    const config = PLATFORM_CONFIGS[this.platform];
+    return config.anthropicBaseUrl || null;
+  }
+}
+
+/**
+ * Get all supported Coding Plan platforms
+ */
+export function getSupportedCodingPlanPlatforms(): Array<{
+  platform: CodingPlanPlatform;
+  name: string;
+  baseUrl: string;
+  models: string[];
+}> {
+  return Object.entries(PLATFORM_CONFIGS)
+    .filter(([key]) => key !== 'custom')
+    .map(([platform, config]) => ({
+      platform: platform as CodingPlanPlatform,
+      name: config.name,
+      baseUrl: config.baseUrl,
+      models: config.models,
+    }));
+}
+
+/**
+ * Quick factory for creating Coding Plan providers
+ */
+export function createCodingPlanProvider(
+  platform: CodingPlanPlatform,
+  apiKey: string,
+  model: string,
+  customBaseUrl?: string
+): CodingPlanProvider {
+  return new CodingPlanProvider({
+    platform,
+    apiKey,
+    model,
+    customBaseUrl,
+  });
+}

package/src/core/model/providers/OllamaCloudProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OllamaCloudProvider.d.ts","sourceRoot":"","sources":["OllamaCloudProvider.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,OAAO,EAAmD,MAAM,wBAAwB,CAAC;AAEvG,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,aAAa,EAAc,WAAW,EAAE,MAAM,aAAa,CAAC;AAI9G,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAgDD,qBAAa,mBAAoB,YAAW,aAAa;IACvD,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,iBAAiB;IAK/B,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IA4ClF,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,WAAW,CAAC;IAiHvF,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAWvD,OAAO,CAAC,UAAU;IASlB;;;OAGG;IACH,OAAO,CAAC,YAAY;IA2BpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAiDvB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,sBAAsB;IA0B9B,OAAO,CAAC,iBAAiB;YAUX,OAAO;CAWtB"}

package/src/core/model/providers/OllamaCloudProvider.ts

@@ -0,0 +1,405 @@
+// ============================================================================
+// OllamaCloudProvider - Ollama Cloud API (https://ollama.com)
+// ============================================================================
+//
+// Uses Ollama's native REST API (/api/chat) for cloud-hosted models.
+// Supports:
+// - All Ollama Cloud models (deepseek-v3.2, kimi-k2.5, qwen3-coder, etc.)
+// - Streaming responses with thinking/reasoning support
+// - Tool/function calling (Ollama native format)
+// - Model discovery via /api/tags
+// - API key authentication (Bearer token)
+//
+// NOTE: Ollama Cloud uses native API format, NOT OpenAI-compatible.
+// ============================================================================
+
+import type { Message, ContentBlock, ToolUseContent, ToolResultContent } from '../../types/session.js';
+import type { ToolDefinition } from '../../types/tools.js';
+import type { ModelProvider, ModelRequestOptions, ModelResponse, TokenUsage, StreamEvent } from '../types.js';
+import { ModelError, RateLimitError } from '../../types/errors.js';
+import { createToolCallId } from '../../types/session.js';
+
+export interface OllamaCloudConfig {
+  apiKey: string;
+  baseUrl?: string;
+  model: string;
+}
+
+/** Ollama Cloud /api/chat response format (non-streaming) */
+interface OllamaChatResponse {
+  model: string;
+  created_at: string;
+  message: {
+    role: string;
+    content: string;
+    thinking?: string;
+    tool_calls?: Array<{
+      function: {
+        name: string;
+        arguments: { [key: string]: unknown };
+      };
+    }>;
+  };
+  done: boolean;
+  done_reason?: string;
+  total_duration?: number;
+  load_duration?: number;
+  prompt_eval_count?: number;
+  prompt_eval_duration?: number;
+  eval_count?: number;
+  eval_duration?: number;
+}
+
+/** Ollama Cloud /api/chat streaming chunk */
+interface OllamaChatChunk {
+  model: string;
+  created_at: string;
+  message: {
+    role: string;
+    content: string;
+    thinking?: string;
+    tool_calls?: Array<{
+      function: {
+        name: string;
+        arguments: { [key: string]: unknown };
+      };
+    }>;
+  };
+  done: boolean;
+  done_reason?: string;
+  prompt_eval_count?: number;
+  eval_count?: number;
+}
+
+export class OllamaCloudProvider implements ModelProvider {
+  readonly name = 'Ollama Cloud';
+  private apiKey: string;
+  private baseUrl: string;
+
+  constructor(config: OllamaCloudConfig) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || 'https://ollama.com').replace(/\/+$/, '');
+  }
+
+  async complete(messages: Message[], options: ModelRequestOptions): Promise<ModelResponse> {
+    const ollamaMessages = this.convertMessages(messages, options.systemPrompt);
+    const tools = this.convertTools(options.tools);
+    const body: Record<string, unknown> = {
+      model: options.model,
+      messages: ollamaMessages,
+      stream: false,
+      ...(tools.length > 0 && { tools }),
+      ...(options.maxTokens && { options: { num_predict: options.maxTokens } }),
+      ...(options.temperature !== undefined && options.temperature !== 1 && {
+        options: { ...this.getOptions(options), temperature: options.temperature },
+      }),
+    };
+
+    const res = await this.request('/api/chat', body);
+    const data = await res.json() as OllamaChatResponse;
+
+    if (!res.ok) {
+      throw new ModelError(
+        `Ollama Cloud API error: ${res.status} ${res.statusText} - ${JSON.stringify(data)}`,
+        res.status,
+        this.name,
+      );
+    }
+
+    const content = this.convertResponseContent(data.message);
+    const usage: TokenUsage = {
+      inputTokens: data.prompt_eval_count || 0,
+      outputTokens: data.eval_count || 0,
+    };
+
+    // Ollama returns done_reason "stop" even for tool calls; detect from response content
+    const hasToolCalls = content.some((c): c is ToolUseContent => c.type === 'tool_use');
+    const stopReason = hasToolCalls ? 'tool_use' : this.convertStopReason(data.done_reason);
+
+    return {
+      content,
+      model: data.model,
+      stopReason,
+      usage,
+      sessionId: options.sessionId,
+    };
+  }
+
+  async *stream(messages: Message[], options: ModelRequestOptions): AsyncGenerator<StreamEvent> {
+    const ollamaMessages = this.convertMessages(messages, options.systemPrompt);
+    const tools = this.convertTools(options.tools);
+    const body: Record<string, unknown> = {
+      model: options.model,
+      messages: ollamaMessages,
+      stream: true,
+      ...(tools.length > 0 && { tools }),
+      options: this.getOptions(options),
+    };
+
+    let res: Response;
+    try {
+      res = await this.request('/api/chat', body);
+    } catch (err) {
+      yield { type: 'error', error: new ModelError(`Ollama Cloud request failed: ${(err as Error).message}`, undefined, this.name) };
+      return;
+    }
+
+    if (!res.ok) {
+      let errorText = '';
+      try { errorText = await res.text(); } catch { /* ignore */ }
+      yield { type: 'error', error: new ModelError(`Ollama Cloud API error: ${res.status} ${errorText || res.statusText}`, res.status, this.name) };
+      return;
+    }
+
+    yield { type: 'message_start', model: options.model };
+
+    const reader = res.body?.getReader();
+    if (!reader) {
+      yield { type: 'error', error: new ModelError('No response body from Ollama Cloud', undefined, this.name) };
+      return;
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let totalInput = 0;
+    let totalOutput = 0;
+    // Track tool calls for streaming (Ollama sends them in the final chunk)
+    let pendingToolCalls: Array<{ name: string; arguments: string }> = [];
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const chunk: OllamaChatChunk = JSON.parse(line);
+
+            // Emit thinking content
+            if (chunk.message?.thinking) {
+              yield { type: 'thinking_delta', delta: chunk.message.thinking };
+            }
+
+            // Emit text content
+            if (chunk.message?.content) {
+              yield { type: 'text_delta', delta: chunk.message.content };
+            }
+
+            // Collect tool calls (Ollama sends them in final chunk or inline)
+            if (chunk.message?.tool_calls) {
+              for (const tc of chunk.message.tool_calls) {
+                const argsStr = typeof tc.function.arguments === 'string'
+                  ? tc.function.arguments
+                  : JSON.stringify(tc.function.arguments);
+                pendingToolCalls.push({
+                  name: tc.function.name,
+                  arguments: argsStr,
+                });
+              }
+            }
+
+            // Track token usage
+            if (chunk.prompt_eval_count) totalInput = chunk.prompt_eval_count;
+            if (chunk.eval_count) totalOutput = chunk.eval_count;
+
+            // Stream done
+            if (chunk.done) {
+              // Emit any pending tool calls before message_complete
+              if (pendingToolCalls.length > 0) {
+                for (const tc of pendingToolCalls) {
+                  const toolCallId = createToolCallId(`tool_${Date.now()}_${Math.random()}`);
+                  yield { type: 'tool_call_start', toolCallId, toolName: tc.name };
+                  yield { type: 'tool_call_delta', toolCallId, delta: tc.arguments };
+                }
+              }
+
+              // Ollama uses "stop" even for tool calls; detect from pending tool calls
+              const hasToolCalls = pendingToolCalls.length > 0;
+              const stopReason = hasToolCalls ? 'tool_use' : this.convertStopReason(chunk.done_reason);
+
+              yield {
+                type: 'message_complete',
+                stopReason,
+                usage: { inputTokens: totalInput, outputTokens: totalOutput },
+              };
+            }
+          } catch {
+            // Skip malformed lines
+          }
+        }
+      }
+    } catch (err) {
+      yield { type: 'error', error: new ModelError(`Ollama Cloud stream error: ${(err as Error).message}`, undefined, this.name) };
+    }
+  }
+
+  async countTokens(messages: Message[]): Promise<number> {
+    // Approximate: ~4 chars per token
+    const text = messages.map(m => {
+      if (typeof m.content === 'string') return m.content;
+      return m.content.map(c => c.type === 'text' ? c.text : '').join('');
+    }).join('');
+    return Math.ceil(text.length / 4);
+  }
+
+  // --- Private helpers ---
+
+  private getOptions(options: ModelRequestOptions): Record<string, unknown> {
+    const opts: Record<string, unknown> = {};
+    if (options.maxTokens) opts.num_predict = options.maxTokens;
+    if (options.temperature !== undefined && options.temperature !== 1) {
+      opts.temperature = options.temperature;
+    }
+    return opts;
+  }
+
+  /**
+   * Convert internal ToolDefinition[] to Ollama's native tool format.
+   * Ollama uses the same format as OpenAI: { type: "function", function: { name, description, parameters } }
+   */
+  private convertTools(tools: ToolDefinition[]): Array<Record<string, unknown>> {
+    if (!tools || tools.length === 0) return [];
+
+    return tools.map(tool => {
+      const parameters: Record<string, unknown> = {
+        type: 'object',
+        properties: {},
+      };
+
+      if (tool.inputSchema?.properties) {
+        parameters.properties = tool.inputSchema.properties;
+      }
+      if (tool.inputSchema?.required) {
+        parameters.required = tool.inputSchema.required;
+      }
+
+      return {
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description || '',
+          parameters,
+        },
+      };
+    });
+  }
+
+  /**
+   * Convert messages to Ollama format.
+   * Handles: system, user, assistant (with optional tool_calls), and tool results.
+   * Ollama doesn't have a native tool role; tool results are sent as user messages.
+   */
+  private convertMessages(messages: Message[], systemPrompt?: string): Array<Record<string, unknown>> {
+    const result: Array<Record<string, unknown>> = [];
+
+    if (systemPrompt) {
+      result.push({ role: 'system', content: systemPrompt });
+    }
+
+    for (const msg of messages) {
+      if (msg.role === 'user') {
+        const text = this.extractText(msg.content);
+        result.push({ role: 'user', content: text });
+      } else if (msg.role === 'assistant') {
+        // Check if assistant message contains tool calls
+        const toolUseBlocks = msg.content.filter((c): c is ToolUseContent => c.type === 'tool_use');
+        const textBlocks = msg.content.filter(c => c.type === 'text');
+
+        if (toolUseBlocks.length > 0) {
+          // Ollama supports tool_calls in assistant messages
+          const msgObj: Record<string, unknown> = {
+            role: 'assistant',
+            content: textBlocks.map(c => (c as { text: string }).text).join('') || '',
+            tool_calls: toolUseBlocks.map(tc => ({
+              function: {
+                name: tc.name,
+                arguments: tc.input,
+              },
+            })),
+          };
+          result.push(msgObj);
+        } else {
+          const text = this.extractText(msg.content);
+          result.push({ role: 'assistant', content: text });
+        }
+      } else if (msg.role === 'tool') {
+        // Ollama doesn't have a native tool role; include as user message
+        const toolResults = msg.content.filter((c): c is ToolResultContent => c.type === 'tool_result');
+        const text = toolResults.map(tr => {
+          const content = typeof tr.content === 'string'
+            ? tr.content
+            : JSON.stringify(tr.content);
+          return `[Tool Result for ${(tr as any).tool_use_id}]: ${content}`;
+        }).join('\n');
+        result.push({ role: 'user', content: text });
+      }
+    }
+
+    return result;
+  }
+
+  private extractText(content: Message['content']): string {
+    if (typeof content === 'string') return content;
+    return content
+      .map(block => {
+        if (block.type === 'text') return block.text;
+        if (block.type === 'tool_use') return `[Calling tool: ${block.name}]`;
+        if (block.type === 'tool_result') return `[Tool result: ${typeof block.content === 'string' ? block.content : JSON.stringify(block.content)}]`;
+        return '';
+      })
+      .join('\n');
+  }
+
+  private convertResponseContent(message: OllamaChatResponse['message']): ContentBlock[] {
+    const content: ContentBlock[] = [];
+
+    if (message.thinking) {
+      content.push({ type: 'text', text: message.thinking });
+    }
+
+    if (message.content) {
+      content.push({ type: 'text', text: message.content });
+    }
+
+    // Handle tool calls
+    if (message.tool_calls) {
+      for (const tc of message.tool_calls) {
+        content.push({
+          type: 'tool_use' as const,
+          id: createToolCallId(`tool_${Date.now()}_${Math.random()}`) as any,
+          name: tc.function.name,
+          input: tc.function.arguments,
+        });
+      }
+    }
+
+    return content;
+  }
+
+  private convertStopReason(reason?: string): ModelResponse['stopReason'] {
+    if (!reason) return 'end_turn';
+    switch (reason) {
+      case 'stop': return 'end_turn';
+      case 'length': return 'max_tokens';
+      case 'tool_calls': return 'tool_use';
+      default: return 'end_turn';
+    }
+  }
+
+  private async request(path: string, body: Record<string, unknown>): Promise<Response> {
+    return fetch(`${this.baseUrl}${path}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(120000),
+    });
+  }
+}

package/src/core/model/providers/OllamaManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OllamaManager.d.ts","sourceRoot":"","sources":["OllamaManager.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,4CAA4C;AAC5C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE;QACP,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH;AAED,8CAA8C;AAC9C,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,yCAAyC;AACzC,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE;QACP,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,wCAAwC;AACxC,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,SAAQ;IAK/C,wCAAwC;IAClC,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAW9B,gCAAgC;IAC1B,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAKhC,wCAAwC;IAClC,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAK1C,uCAAuC;IACjC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAIvD;;;OAGG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCjG,uCAAuC;IACjC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK9C;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW;YA4BhC,OAAO;CAsBtB"}