movie-agent 1.0.0 → 1.1.1

package/README.md

@@ -5,15 +5,21 @@ An intelligent movie recommendation system that helps users discover movies base
 ## Features
 
 - 🎬 Personalized movie recommendations based on mood, genre, and preferences
+- 🤖 AI-powered output formatting with LangChain and Google Gemini
+- 🌊 Streaming and non-streaming output modes
 - 📺 Real-time streaming availability for Canadian platforms
 - ⚡ Fast responses using TMDb API
 - 🎯 Smart filtering by runtime, release year, and streaming platforms
 - 📦 Easy integration into web applications and APIs
+- 🔒 Multi-tenant cache isolation for secure deployments (see [Cache Isolation Guide](docs/CACHE_ISOLATION.md))
 
 ## Prerequisites
 
 - Node.js (v18 or higher)
 - TMDb API key ([Get one here](https://www.themoviedb.org/settings/api))
+- LLM API key for AI formatting (optional):
+  - Google Gemini API key - [Get one here](https://aistudio.google.com/app/apikey)
+  - **OR** Azure OpenAI credentials - [Learn more](https://azure.microsoft.com/en-us/products/ai-services/openai-service)
 
 ## Installation
 
@@ -23,55 +29,186 @@ npm install movie-agent
 
 ## Quick Start
 
-### Option 1: Using MovieAgentFactory.create() with explicit config (Recommended)
+### Basic Usage - Get Structured Data
+
+```typescript
+import { MovieAgent } from 'movie-agent';
+
+// Create agent
+const agent = new MovieAgent();
+
+// Get structured recommendations
+const response = await agent.getRecommendations({
+  mood: 'excited',
+  platforms: ['Netflix', 'Prime Video'],
+});
+
+console.log(response.recommendations);
+```
+
+### AI-Formatted Output - Invoke Mode (Waits for complete response)
+
+```typescript
+import { MovieAgent } from 'movie-agent';
+
+const agent = new MovieAgent();
+
+// Get AI-formatted markdown output
+const output = await agent.invoke({
+  mood: 'happy',
+  platforms: ['Netflix'],
+});
+
+console.log(output); // Formatted markdown string
+```
+
+### AI-Formatted Output - Stream Mode (Real-time streaming)
+
+```typescript
+import { MovieAgent } from 'movie-agent';
+
+const agent = new MovieAgent();
+
+// Stream AI-formatted output in real-time
+await agent.stream({
+  mood: 'excited',
+  platforms: ['Netflix'],
+}, (chunk) => {
+  process.stdout.write(chunk); // or update your UI
+});
+```
+
+### Using with MovieAgentFactory
 
 ```typescript
 import { MovieAgentFactory } from 'movie-agent';
 
-// Create agent with explicit configuration
+// Create agent with explicit configuration (Gemini)
 const agent = MovieAgentFactory.create({
   tmdbApiKey: process.env.TMDB_API_KEY!,
   tmdbRegion: 'CA',
-  debug: true, // Enable debug logging
+  llmProvider: 'gemini',
+  geminiApiKey: process.env.GEMINI_API_KEY,
+  debug: true,
 });
 
-// Get recommendations
-const recommendations = await agent.getRecommendations({
-  mood: 'excited',
-  genre: 'Action',
-  platforms: ['Netflix', 'Prime Video'],
+// Or use Azure OpenAI
+const agentWithAzure = MovieAgentFactory.create({
+  tmdbApiKey: process.env.TMDB_API_KEY!,
+  tmdbRegion: 'CA',
+  llmProvider: 'azure',
+  azureOpenAiApiKey: process.env.AZURE_OPENAI_API_KEY,
+  azureOpenAiEndpoint: process.env.AZURE_OPENAI_ENDPOINT,
+  azureOpenAiDeployment: process.env.AZURE_OPENAI_DEPLOYMENT,
+  debug: true,
 });
 
-console.log(recommendations);
+// All three methods available: getRecommendations, invoke, stream
+const structured = await agent.getRecommendations({ mood: 'happy' });
+const formatted = await agent.invoke({ mood: 'happy' });
+await agent.stream({ mood: 'happy' }, (chunk) => console.log(chunk));
 ```
 
-### Option 2: Using MovieAgentFactory.fromEnv() convenience method
+## API Reference
+
+### MovieAgent Methods
+
+#### `getRecommendations(input: UserInput): Promise<AgentResponse | ErrorResponse>`
+Returns structured movie recommendations with metadata.
 
 ```typescript
-import { MovieAgentFactory } from 'movie-agent';
-import dotenv from 'dotenv';
+const response = await agent.getRecommendations({
+  mood: 'happy',
+  platforms: ['Netflix']
+});
+// Returns: { recommendations: [...], metadata: {...} }
+```
 
-// Load your .env file BEFORE creating the agent
-dotenv.config();
+#### `invoke(input: UserInput): Promise<string | ErrorResponse>`
+Returns AI-formatted markdown output (non-streaming). Waits for complete response before returning.
 
-// Create agent from environment variables
-const agent = MovieAgentFactory.fromEnv(true); // true = enable debug logging
+```typescript
+const output = await agent.invoke({
+  mood: 'excited',
+  platforms: ['Netflix']
+});
+// Returns: Formatted markdown string
+```
 
-// Get recommendations
-const recommendations = await agent.getRecommendations({
+#### `stream(input: UserInput, onChunk: (chunk: string) => void): Promise<void | ErrorResponse>`
+Streams AI-formatted output in real-time. Best for interactive UIs.
+
+```typescript
+await agent.stream({
   mood: 'relaxed',
-  genre: ['Comedy', 'Romance'],
-  runtime: { max: 120 },
+  platforms: ['Netflix']
+}, (chunk) => {
+  process.stdout.write(chunk);
 });
 ```
 
+## Input Parameters
+
+```typescript
+interface UserInput {
+  mood?: string;                    // e.g., 'excited', 'relaxed', 'thoughtful', 'happy', 'scared'
+  genre?: string | string[];        // e.g., 'Action' or ['Action', 'Thriller']
+  platforms?: string[];             // e.g., ['Netflix', 'Prime Video', 'Disney+']
+  runtime?: {
+    min?: number;                   // Minimum runtime in minutes
+    max?: number;                   // Maximum runtime in minutes
+  };
+  releaseYear?: number | {          // Single year or range
+    from?: number;
+    to?: number;
+  };
+}
+```
+
+## Output Comparison
+
+### `getRecommendations()` - Structured Data
+```json
+{
+  "recommendations": [
+    {
+      "tmdbId": 123,
+      "title": "Movie Title",
+      "releaseYear": "2024",
+      "runtime": 120,
+      "genres": ["Action", "Adventure"],
+      "description": "...",
+      "streamingPlatforms": [...],
+      "matchReason": "...",
+      "posterUrl": "https://image.tmdb.org/t/p/w500/abc123.jpg"
+    }
+  ],
+  "metadata": {...}
+}
+```
+
+### `invoke()` / `stream()` - AI-Formatted Markdown
+```markdown
+Hey there! 👋 Looking for some action-packed thrills? Here are your recommendations:
+
+### **Movie Title (2024)** - 120 minutes
+*Genres: Action, Adventure*
+A compelling description...
+📺 Available on: Netflix
+✨ Why: Perfect for your excited mood with thrilling action!
+```
+
 ## API Examples
 
 ```typescript
 // Simple mood-based search
-await agent.getRecommendations({
-  mood: 'happy'
-});
+await agent.getRecommendations({ mood: 'happy' });
+
+// AI-formatted output
+await agent.invoke({ mood: 'happy' });
+
+// Streaming output
+await agent.stream({ mood: 'happy' }, (chunk) => console.log(chunk));
 
 // Genre-specific with platform filter
 await agent.getRecommendations({
@@ -97,17 +234,14 @@ await agent.getRecommendations({
 
 ## Integration Examples
 
-### Next.js API Route
+### Next.js API Route (Structured Data)
 
 ```typescript
 // pages/api/recommendations.ts
-import { MovieAgentFactory } from 'movie-agent';
+import { MovieAgent } from 'movie-agent';
 import type { NextApiRequest, NextApiResponse } from 'next';
 
-const agent = MovieAgentFactory.create({
-  tmdbApiKey: process.env.TMDB_API_KEY!,
-  tmdbRegion: 'CA',
-});
+const agent = new MovieAgent();
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method !== 'POST') {
@@ -125,23 +259,50 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
 }
 ```
 
-### Express Server
+### Next.js API Route (AI-Formatted Streaming)
 
 ```typescript
-import express from 'express';
-import { MovieAgentFactory } from 'movie-agent';
-import dotenv from 'dotenv';
+// pages/api/recommendations-stream.ts
+import { MovieAgent } from 'movie-agent';
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+const agent = new MovieAgent();
 
-dotenv.config();
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { mood, genre, platforms } = req.body;
+    
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    
+    await agent.stream({ mood, genre, platforms }, (chunk) => {
+      res.write(chunk);
+    });
+    
+    res.end();
+  } catch (error) {
+    console.error('Error streaming recommendations:', error);
+    res.status(500).json({ error: 'Failed to stream recommendations' });
+  }
+}
+```
+
+### Express Server (Streaming)
+
+```typescript
+import express from 'express';
+import { MovieAgent } from 'movie-agent';
 
 const app = express();
 app.use(express.json());
 
-const agent = MovieAgentFactory.create({
-  tmdbApiKey: process.env.TMDB_API_KEY!,
-  tmdbRegion: 'CA',
-});
+const agent = new MovieAgent();
 
+// Structured data endpoint
 app.post('/api/recommendations', async (req, res) => {
   try {
     const recommendations = await agent.getRecommendations(req.body);
@@ -152,11 +313,72 @@ app.post('/api/recommendations', async (req, res) => {
   }
 });
 
+// Streaming endpoint
+app.post('/api/recommendations/stream', async (req, res) => {
+  try {
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.setHeader('Transfer-Encoding', 'chunked');
+    
+    await agent.stream(req.body, (chunk) => {
+      res.write(chunk);
+    });
+    
+    res.end();
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: 'Failed to stream recommendations' });
+  }
+});
+
 app.listen(3000, () => {
   console.log('Server running on http://localhost:3000');
 });
 ```
 
+### React Component with Streaming
+
+```typescript
+import { useState } from 'react';
+
+function MovieRecommendations() {
+  const [output, setOutput] = useState('');
+  const [loading, setLoading] = useState(false);
+
+  const getRecommendations = async () => {
+    setLoading(true);
+    setOutput('');
+
+    const response = await fetch('/api/recommendations/stream', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ mood: 'happy', platforms: ['Netflix'] }),
+    });
+
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      
+      const chunk = decoder.decode(value);
+      setOutput(prev => prev + chunk);
+    }
+
+    setLoading(false);
+  };
+
+  return (
+    <div>
+      <button onClick={getRecommendations} disabled={loading}>
+        Get Recommendations
+      </button>
+      <div style={{ whiteSpace: 'pre-wrap' }}>{output}</div>
+    </div>
+  );
+}
+```
+
 ## Configuration
 
 ### Environment Variables
@@ -165,6 +387,17 @@ app.listen(3000, () => {
 # Required
 TMDB_API_KEY=your_tmdb_api_key_here
 
+# LLM Provider Selection (optional)
+LLM_PROVIDER=gemini  # Options: gemini, azure
+
+# Option 1: Google Gemini (for AI-formatted output)
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Option 2: Azure OpenAI (for AI-formatted output)
+AZURE_OPENAI_API_KEY=your_azure_openai_api_key_here
+AZURE_OPENAI_ENDPOINT=https://your-resource-name.openai.azure.com/
+AZURE_OPENAI_DEPLOYMENT=your_deployment_name
+
 # Optional
 TMDB_REGION=CA
 CACHE_TTL=86400
@@ -172,6 +405,46 @@ MAX_RECOMMENDATIONS=5
 MIN_RECOMMENDATIONS=3
 ```
 
+**Note:** If no LLM API key is provided, the `invoke()` and `stream()` methods will use a fallback formatter.
+
+### LLM Provider Configuration
+
+The package supports multiple LLM providers for AI-formatted output:
+
+#### Google Gemini (Default)
+```typescript
+const agent = MovieAgentFactory.create({
+  tmdbApiKey: 'your-tmdb-key',
+  llmProvider: 'gemini',
+  geminiApiKey: 'your-gemini-key',
+});
+```
+
+#### Azure OpenAI
+```typescript
+const agent = MovieAgentFactory.create({
+  tmdbApiKey: 'your-tmdb-key',
+  llmProvider: 'azure',
+  azureOpenAiApiKey: 'your-azure-key',
+  azureOpenAiEndpoint: 'https://your-resource.openai.azure.com/',
+  azureOpenAiDeployment: 'your-deployment-name',
+});
+```
+
+#### Using Environment Variables
+```bash
+# Set LLM_PROVIDER in .env
+LLM_PROVIDER=azure
+AZURE_OPENAI_API_KEY=your_key
+AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
+AZURE_OPENAI_DEPLOYMENT=gpt-4
+```
+
+```typescript
+// Automatically uses Azure OpenAI from environment
+const agent = MovieAgentFactory.fromEnv();
+```
+
 ### Input Parameters
 
 ```typescript
@@ -236,7 +509,13 @@ import {
   AgentResponse,
   MovieRecommendation,
   ErrorResponse,
+  buildPosterUrl,        // Utility to build poster URLs with different sizes
+  TMDB_IMAGE_BASE_URL,   // Base URL for TMDb images
 } from 'movie-agent';
+
+// Build poster URL with custom size (default is w500)
+const smallPoster = buildPosterUrl('/abc123.jpg', 'w185');
+// => "https://image.tmdb.org/t/p/w185/abc123.jpg"
 ```
 
 ## Response Format
@@ -261,6 +540,7 @@ interface MovieRecommendation {
   overview: string;
   streamingPlatforms: StreamingPlatform[];
   matchReason: string;
+  posterUrl: string | null;  // Full URL to movie poster image (w500 size)
 }
 ```
 
@@ -461,4 +741,4 @@ MIT
 
 - [The Movie Database (TMDb)](https://www.themoviedb.org/) for movie data and streaming availability
 - [LangChain.js](https://js.langchain.com/) for agent framework
-- [OpenAI](https://openai.com/) for LLM capabilities
+- [Google Gemini](https://ai.google.dev/) and [Azure OpenAI](https://azure.microsoft.com/en-us/products/ai-services/openai-service) for LLM capabilities

package/bin/movie-agent

@@ -10,6 +10,7 @@ const fs = require('fs');
 function parseArgs() {
   const args = process.argv.slice(2);
   const input = {};
+  let useStreaming = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -75,13 +76,15 @@ function parseArgs() {
           printUsage();
           process.exit(1);
       }
+    } else if (arg === '--stream') {
+      useStreaming = true;
     } else if (arg === '--help' || arg === '-h') {
       printUsage();
       process.exit(0);
     }
   }
 
-  return input;
+  return { input, useStreaming };
 }
 
 /**
@@ -100,11 +103,12 @@ Options:
   --year <number>           Specific release year
   --yearFrom <number>       Release year range start
   --yearTo <number>         Release year range end
+  --stream                  Enable streaming output (real-time generation)
   --help, -h                Show this help message
 
 Examples:
   movie-agent --mood excited --platforms Netflix
-  movie-agent --genre Action,Thriller --runtimeMax 120
+  movie-agent --genre Action,Thriller --runtimeMax 120 --stream
   movie-agent --mood relaxed --yearFrom 2020 --yearTo 2023
 `);
 }
@@ -173,10 +177,15 @@ Or create a .env.development file with:
       process.exit(1);
     }
 
+    // Check for Gemini API key (optional, agent will work without it)
+    if (!process.env.GEMINI_API_KEY) {
+      console.warn(`\n⚠️  Warning: Gemini API key not found. Using fallback formatting.\n`);
+    }
+
     // Now it's safe to load the agent module
     const { MovieAgent } = require('../dist/agent');
 
-    const input = parseArgs();
+    const { input, useStreaming } = parseArgs();
 
     // Show help if no arguments provided
     if (Object.keys(input).length === 0) {
@@ -184,19 +193,35 @@ Or create a .env.development file with:
       process.exit(0);
     }
 
-    console.log('\n🔍 Finding movie recommendations...\n');
+    console.log('\\n🔍 Finding movie recommendations...\\n');
 
     const agent = new MovieAgent();
-    const response = await agent.getRecommendations(input);
 
-    const output = formatOutput(response);
-    console.log(output);
+    if (useStreaming) {
+      // Use streaming output
+      const result = await agent.stream(input, (chunk) => {
+        process.stdout.write(chunk);
+      });
+      
+      if (result && 'error' in result) {
+        throw new Error(result.message);
+      }
+    } else {
+      // Use non-streaming output
+      const output = await agent.invoke(input);
+      
+      if (typeof output === 'object' && 'error' in output) {
+        throw new Error(output.message);
+      }
+      
+      console.log(output);
+    }
 
   } catch (error) {
     console.error('\n❌ Error:', error.message);
     
     if (error.message.includes('API') || error.message.includes('network')) {
-      console.error('\nPlease check your internet connection and TMDb API key.');
+      console.error('\nPlease check your internet connection and API keys.');
     } else if (error.message.includes('Invalid') || error.message.includes('validation')) {
       console.error('\nPlease check your input parameters and try again.');
       console.error('Use --help for usage information.');

package/dist/agent.d.ts

@@ -6,12 +6,22 @@ import TmdbApiClient from './tmdbApi';
 export declare class MovieAgent {
     private tmdbClient;
     private logger;
+    private llmService;
+    private debug;
     /**
      * Creates a new MovieAgent instance
      * @param tmdbClient - Optional TMDb API client for testing
      * @param logger - Optional logger function for debugging
+     * @param enableLLM - Whether to enable LLM formatting (default: true if GEMINI_API_KEY is set)
+     * @param llmProvider - LLM provider to use ('gemini' or 'azure')
+     * @param llmApiKey - API key for the LLM provider
+     * @param azureConfig - Azure OpenAI configuration (endpoint and deployment)
+     * @param debug - Whether to include detailed error information in responses (default: false for production safety)
      */
-    constructor(tmdbClient?: TmdbApiClient, logger?: (message: string) => void);
+    constructor(tmdbClient?: TmdbApiClient, logger?: (message: string) => void, enableLLM?: boolean, llmProvider?: 'gemini' | 'azure', llmApiKey?: string, azureConfig?: {
+        endpoint?: string;
+        deployment?: string;
+    }, debug?: boolean);
     /**
      * Gets movie recommendations based on user input
      * @param input - User input with mood, platforms, genres, runtime, and year preferences
@@ -52,11 +62,11 @@ export declare class MovieAgent {
      */
     private discoverCandidates;
     /**
-     * Fetches watch providers for each candidate movie
-     * @param candidates - Array of movie details
+     * Extracts watch providers from movie details and filters to those with providers
+     * @param candidates - Array of movie details with embedded providers
      * @returns Array of movies with platform information
      */
-    private fetchWatchProviders;
+    private extractWatchProviders;
     /**
      * Applies user-specified filters to movies
      * @param movies - Movies with provider information
@@ -78,6 +88,23 @@ export declare class MovieAgent {
      * @returns Array of formatted recommendations
      */
     private formatRecommendations;
+    /**
+     * Get recommendations with AI-formatted output (invoke mode)
+     * @param input - User input with mood, platforms, genres, runtime, and year preferences
+     * @returns Promise resolving to AI-formatted string output or error response
+     */
+    invoke(input: UserInput): Promise<string | ErrorResponse>;
+    /**
+     * Get recommendations with AI-formatted streaming output
+     * @param input - User input with mood, platforms, genres, runtime, and year preferences
+     * @param onChunk - Callback function called for each chunk of streamed content
+     * @returns Promise resolving when streaming is complete, or error response
+     */
+    stream(input: UserInput, onChunk: (chunk: string) => void): Promise<void | ErrorResponse>;
+    /**
+     * Fallback formatting when LLM is not available
+     */
+    private fallbackFormat;
     /**
      * Generates a match reason for a movie
      * @param movie - Movie to explain

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,aAAa,EAGb,aAAa,EACd,MAAM,SAAS,CAAC;AASjB,OAAO,aAA+B,MAAM,WAAW,CAAC;AAaxD;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,MAAM,CAA4B;IAE1C;;;;OAIG;gBACS,UAAU,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAM1E;;;;OAIG;IACG,kBAAkB,CACtB,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,aAAa,GAAG,aAAa,CAAC;IAgEzC;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAmEnB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAqBrB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;OAKG;YACW,kBAAkB;IA0ChC;;;;OAIG;YACW,mBAAmB;IAgCjC;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IA+BpB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAoCrB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAiC7B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;CAuC5B"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,aAAa,EAGb,aAAa,EACd,MAAM,SAAS,CAAC;AAWjB,OAAO,aAGN,MAAM,WAAW,CAAC;AAcnB;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,KAAK,CAAU;IAEvB;;;;;;;;;OASG;gBAED,UAAU,CAAC,EAAE,aAAa,EAC1B,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAClC,SAAS,CAAC,EAAE,OAAO,EACnB,WAAW,CAAC,EAAE,QAAQ,GAAG,OAAO,EAChC,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,EACxD,KAAK,CAAC,EAAE,OAAO;IAgBjB;;;;OAIG;IACG,kBAAkB,CACtB,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,aAAa,GAAG,aAAa,CAAC;IAkEzC;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAmEnB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IA+BrB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;OAKG;YACW,kBAAkB;IA2ChC;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA8B7B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IA+BpB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAoCrB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,aAAa,CAAC;IAoB/D;;;;;OAKG;IACG,MAAM,CACV,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAC/B,OAAO,CAAC,IAAI,GAAG,aAAa,CAAC;IAwBhC;;OAEG;IACH,OAAO,CAAC,cAAc;IAsBtB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;CAuC5B"}