@compresr/sdk 1.3.2 → 1.5.0

package/README.md

@@ -1,263 +1,327 @@
 # Compresr TypeScript SDK
 
-[![npm](https://img.shields.io/npm/v/compresr)](https://www.npmjs.com/package/compresr)
-[![TypeScript](https://img.shields.io/badge/TypeScript-%3E%3D5.0-blue)](https://www.typescriptlang.org/)
-[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+Query-aware LLM context compression — reduce LLM API costs by 30-70%.
 
-Official TypeScript SDK for [Compresr](https://compresr.ai) - Intelligent context compression to reduce LLM API costs by 30-70%.
-
-## Installation
+## Install
 
 ```bash
-npm install compresr
-# or
-yarn add compresr
-# or
-pnpm add compresr
+npm install @compresr/sdk
 ```
 
-## Quick Start
-
-### API Key Setup
-
-Get your API key from [compresr.ai](https://compresr.ai):
+Get an API key at [compresr.ai](https://compresr.ai).
 
-1. Create an account at [compresr.ai](https://compresr.ai)
-2. Navigate to Dashboard → API Keys
-3. Click "Create New Key" and copy it (shown only once!)
-
-### Basic Usage
+## Quick start
 
 ```typescript
-import { CompressionClient } from 'compresr';
+import { CompressionClient } from '@compresr/sdk';
 
-const client = new CompressionClient({ apiKey: 'cmp_your_api_key' });
+const client = new CompressionClient({ apiKey: 'cmp_...' });
 
-// Agnostic compression (espresso_v1) — no query needed
 const result = await client.compress({
-  context: 'Your very long context that needs compression...',
+  context: 'Long passage to compress...',
+  query: 'What is the main conclusion?',
+  targetCompressionRatio: 0.5,
 });
 
-console.log(`Original: ${result.data.original_tokens} tokens`);
-console.log(`Compressed: ${result.data.compressed_tokens} tokens`);
-console.log(`Saved: ${result.data.tokens_saved} tokens`);
+console.log(`Saved ${result.data?.tokens_saved} tokens`);
+console.log(result.data?.compressed_context);
 ```
 
-### Query-Specific Compression
+The default model is `latte_v1` (query-aware). Pass any other model name your
+account has access to via `compressionModelName: '...'` — the backend
+validates.
+
+## Batch
 
 ```typescript
-// Query-specific compression (latte_v1) — query REQUIRED
-const result = await client.compress({
-  context: 'Python was created in 1991. JavaScript in 1995. Java in 1995.',
-  query: 'Who created Python?',
-  compressionModelName: 'latte_v1',
+const batch = await client.compressBatch({
+  contexts: ['Doc 1...', 'Doc 2...', 'Doc 3...'],
+  queries: 'What is self-attention?',
+  targetCompressionRatio: 0.5,
 });
 
-console.log(result.data.compressed_context);
-// Output preserves Python-relevant content
+console.log(`Total saved: ${batch.data?.total_tokens_saved} tokens`);
+```
+
+## Streaming
+
+```typescript
+for await (const chunk of client.compressStream({
+  context: '...',
+  query: '...',
+})) {
+  process.stdout.write(chunk.content);
+}
 ```
 
-## Compression Models
+## Compression options
+
+| Param | Purpose |
+|---|---|
+| `query` | Question the LLM is trying to answer — drives `latte_v1` compression |
+| `targetCompressionRatio` | `0-1` strength or `>1` for Nx factor (max 200) |
+| `coarse` | `true` = paragraph-level (default, faster); `false` = token-level (fine-grained) |
+| `heuristicChunking` | Structure-preserving chunking |
+| `disablePlaceholders` | Disable placeholder tokens in output |
+
+## Error handling
+
+```typescript
+import {
+  AuthenticationError,
+  RateLimitError,
+  ValidationError,
+  CompresrError,
+} from '@compresr/sdk';
+
+try {
+  await client.compress({ context, query });
+} catch (err) {
+  if (err instanceof AuthenticationError) console.error('Invalid API key');
+  else if (err instanceof RateLimitError) console.error('Rate limited');
+  else if (err instanceof ValidationError) console.error('Bad request:', err);
+  else if (err instanceof CompresrError) console.error('API error:', err);
+}
+```
 
-| Model | Query | Description |
-|-------|-------|-------------|
-| `espresso_v1` | Not needed | Agnostic compression — good for system prompts, documents |
-| `latte_v1` | **Required** | Query-specific — preserves tokens relevant to your question |
+## Drop-in agent client
 
-## API Reference
+`@compresr/sdk/agents` ships a tiny provider-shape facade layer on top of
+LangChain.js. One `CompressionClient` exposes three call surfaces — Anthropic
+`messages.create`, OpenAI `chat.completions.create`, and a native `run` — all
+backed by the same engine (`createAgent` + `CompresrToolMiddleware`). Every
+tool output above `minTokens` is auto-compressed before it re-enters the
+model's context.
 
-### `CompressionClient`
+- Pass `temperature`, `topP`, `maxTokens`, `stopSequences`, `presencePenalty`,
+  `frequencyPenalty`, `seed`, etc. to any facade — they're forwarded to the
+  underlying chat model per call via `.bind(...)` (no cache pollution).
 
 ```typescript
-import { CompressionClient } from 'compresr';
+import { CompressionClient } from '@compresr/sdk';
+import { WebSearchTool } from '@compresr/sdk/agents';
 
 const client = new CompressionClient({
-  apiKey: 'cmp_your_api_key',  // Required
-  timeout: 60000,              // Optional: request timeout in ms (default: 60000)
-  baseUrl: 'https://api.compresr.ai', // Optional: override API URL
+  apiKey: process.env.COMPRESR_API_KEY!,
+  llm: 'anthropic',                           // bare provider — model lives at the call site
+  llmApiKey: process.env.ANTHROPIC_API_KEY!,
+  compression: { targetCompressionRatio: 0.5, minTokens: 300 },
 });
 ```
 
-### Methods
-
-#### `compress(options): Promise<CompressResponse>`
+Use `llm: 'anthropic:claude-haiku-4-5'` if you want a default — but the call-site `model:` always wins.
 
-Compress context text.
+### Anthropic shape
 
 ```typescript
-const result = await client.compress({
-  context: 'Your context...',              // Required: string or string[]
-  compressionModelName: 'espresso_v1',     // Optional (default: 'espresso_v1')
-  query: 'Your question?',                 // Required for latte_v1
-  targetCompressionRatio: 0.5,             // Optional: 0-1 or >1 for Nx
-  coarse: false,                           // Optional: paragraph-level (latte_v1 only)
+const msg = await client.messages.create({
+  model: 'claude-haiku-4-5',
+  maxTokens: 512,
+  messages: [{ role: 'user', content: "What's the latest AI news?" }],
+  tools: [search],
 });
 ```
 
-#### `compressStream(options): AsyncGenerator<StreamChunk>`
+### OpenAI shape
+
+```typescript
+const completion = await client.chat.completions.create({
+  model: 'gpt-4o-mini',
+  messages: [{ role: 'user', content: "Summarize today's top story." }],
+  tools: [search],
+});
+```
 
-Stream compression chunks in real-time.
+### Native shape
 
 ```typescript
-for await (const chunk of client.compressStream({
-  context: 'Your context...',
-})) {
-  if (!chunk.done) {
-    process.stdout.write(chunk.content);
-  }
-}
+const result = await client.run({ prompt: 'Hello', tools: [search], maxTokens: 512 });
+console.log(result.text, result.citations, result.compresrStats);
 ```
 
-#### `compressBatch(options): Promise<CompressBatchResponse>`
+### Tools
 
-Batch compress multiple contexts (more efficient than multiple `compress()` calls).
+`WebSearchTool` returns a LangChain.js `BaseTool` — usable across all three
+facades.
 
 ```typescript
-// Same query for all contexts
-const result = await client.compressBatch({
-  contexts: ['Doc 1...', 'Doc 2...', 'Doc 3...'],
-  queries: 'What are the key points?',
-  compressionModelName: 'latte_v1',  // Optional (default for batch)
-});
+import { WebSearchTool } from '@compresr/sdk/agents';
 
-// Different query per context
-const result = await client.compressBatch({
-  contexts: ['ML doc...', 'NLP doc...'],
-  queries: ['What is ML?', 'What is NLP?'],
+const tavily = await WebSearchTool.tavily({
+  apiKey: process.env.TAVILY_API_KEY!,
+  maxResults: 5,
+  allowedDomains: ['arxiv.org'],
 });
 
-console.log(`Total saved: ${result.data.total_tokens_saved} tokens`);
+const brave = await WebSearchTool.brave({
+  apiKey: process.env.BRAVE_API_KEY!,
+  maxResults: 5,
+});
 ```
 
-## Response Types
+`WebSearchTool` is also re-exported from `@compresr/sdk` for convenience, but
+`@compresr/sdk/agents` is the recommended import path — heavy LangChain peers
+stay dynamic, so the subpath only pulls them in when you touch the surface.
+
+### Custom tools
 
-### CompressResponse
+Any LangChain.js tool works. Use the standard `tool({...})` decorator and
+Compresr compresses its output the same way:
 
 ```typescript
-interface CompressResponse {
-  success: boolean;
-  data: {
-    original_context: string | string[];
-    compressed_context: string | string[];
-    original_tokens: number;
-    compressed_tokens: number;
-    actual_compression_ratio: number;
-    tokens_saved: number;
-    duration_ms: number;
-  } | null;
-}
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+const fetchDocs = tool(
+  async ({ query }) => fetchInternalDocs(query),
+  {
+    name: 'fetch_docs',
+    description: 'Search the internal docs corpus',
+    schema: z.object({ query: z.string() }),
+  },
+);
+
+await client.run({ prompt: 'How does billing work?', tools: [fetchDocs] });
 ```
 
-### CompressBatchResponse
+### Provider switching
+
+Swap providers by changing one line — the facades stay the same:
 
 ```typescript
-interface CompressBatchResponse {
-  success: boolean;
-  data: {
-    results: CompressBatchItemResult[];
-    total_original_tokens: number;
-    total_compressed_tokens: number;
-    total_tokens_saved: number;
-    average_compression_ratio: number;
-    count: number;
-  } | null;
-}
+new CompressionClient({ apiKey, llm: 'anthropic:claude-haiku-4-5', llmApiKey });
+new CompressionClient({ apiKey, llm: 'openai:gpt-4o-mini',         llmApiKey });
+new CompressionClient({ apiKey, llm: 'google_genai:gemini-2.5-flash', llmApiKey });
 ```
 
-## Integration with OpenAI
+Streaming (`messages.stream`, `chat.completions.stream`) is a Phase-2 item
+and currently throws `CompresrError('streaming not yet implemented')`.
 
-```typescript
-import { CompressionClient } from 'compresr';
-import OpenAI from 'openai';
+### Why no provider-native server search?
 
-const compresr = new CompressionClient({ apiKey: 'cmp_xxx' });
-const openai = new OpenAI({ apiKey: 'sk-xxx' });
+Anthropic `web_search_20250305`, OpenAI `web_search_preview`, and Gemini
+`google_search` execute server-side and return encrypted or opaque content
+that Compresr can't read — so it can't compress them either. Use
+`WebSearchTool.tavily` / `WebSearchTool.brave` if you want compressible
+search output in the agent loop.
 
-// Compress your context first
-const compressed = await compresr.compress({
-  context: 'Your very long system prompt or document...',
-});
+## Framework integrations
+
+Optional peer dependencies — install only what you use:
+
+```bash
+npm install langchain @langchain/core          # engine for the agents layer
+npm install @langchain/anthropic               # for anthropic:... models
+npm install @langchain/openai                  # for openai:... models
+npm install @langchain/google-genai            # for google_genai:... models
+npm install @langchain/tavily                  # for WebSearchTool.tavily
+npm install @langchain/community               # for WebSearchTool.brave
+npm install @langchain/langgraph               # for LangGraph integration
+npm install llamaindex                         # for LlamaIndex integration
+```
+
+### LangChain — middleware, tool wrapper, retriever
 
-// Use compressed context with OpenAI
-const response = await openai.chat.completions.create({
-  model: 'gpt-4o',
-  messages: [
-    { role: 'system', content: compressed.data.compressed_context },
-    { role: 'user', content: 'Analyze this data...' },
+```typescript
+import { createAgent } from 'langchain';
+import {
+  compresrToolMiddleware,
+  wrapToolWithCompression,
+  CompresrExtractor,
+} from '@compresr/sdk/integrations/langchain';
+
+const agent = createAgent({
+  model,
+  tools: [webSearch],
+  middleware: [
+    compresrToolMiddleware({
+      apiKey: process.env.COMPRESR_API_KEY!,
+      queryArg: 'query',
+    }),
   ],
 });
+```
 
-console.log(`Saved ${compressed.data.tokens_saved} tokens!`);
+### LangGraph — compression as a graph node
+
+```typescript
+import { makeCompresrNode } from '@compresr/sdk/integrations/langgraph';
+
+graph.addNode(
+  'compress',
+  makeCompresrNode<State>({
+    apiKey: process.env.COMPRESR_API_KEY!,
+    contextKey: 'retrieved_text',
+    queryKey: 'user_question',
+  })
+);
 ```
 
-## Error Handling
+### LlamaIndex — node postprocessor for RAG
 
 ```typescript
-import {
-  CompressionClient,
-  CompresrError,
-  AuthenticationError,
-  ValidationError,
-  RateLimitError,
-} from 'compresr';
+import { CompresrNodePostprocessor } from '@compresr/sdk/integrations/llamaindex';
 
-try {
-  const result = await client.compress({ context: 'Hello' });
-} catch (error) {
-  if (error instanceof AuthenticationError) {
-    console.error('Invalid API key:', error.message);
-  } else if (error instanceof ValidationError) {
-    console.error('Invalid request:', error.message, 'Field:', error.field);
-  } else if (error instanceof RateLimitError) {
-    console.error('Rate limited. Retry after:', error.retryAfter, 'seconds');
-  } else if (error instanceof CompresrError) {
-    console.error('API error:', error.message, 'Code:', error.code);
-  }
-}
+const queryEngine = index.asQueryEngine({
+  nodePostprocessors: [
+    new CompresrNodePostprocessor({
+      apiKey: process.env.COMPRESR_API_KEY!,
+    }),
+  ],
+});
 ```
 
-### Error Types
+### Unified query API
+
+Every integration that accepts a query exposes the same three knobs:
+
+| Param | Purpose |
+|---|---|
+| `query` | Static query — same for every call |
+| `queryExtractor` | Callable that derives the query from the call context |
+| `queryArg` / `queryKey` | Name of the tool arg / state key to use as the query |
+
+Priority: `query` > `queryExtractor` > `queryArg`/`queryKey` > smart-pick
+from common arg keys (`query`, `question`, `search_query`, ...) > last user
+message in history.
+
+### Tutorials
+
+Runnable end-to-end examples under `tutorial/`:
+
+- `01-quickstart.ts` — core `CompressionClient`.
+- `02-langchain.ts` — middleware + tool wrapper + retriever.
+- `03-langgraph.ts` — compression node in a 3-node graph.
+- `04-llamaindex.ts` — node postprocessor + tool wrapper.
+- `05-agents.md` — drop-in agent client (Anthropic / OpenAI / native facades).
 
-| Error | Description |
-|-------|-------------|
-| `AuthenticationError` | Invalid or missing API key |
-| `ValidationError` | Invalid request parameters |
-| `RateLimitError` | Too many requests (includes `retryAfter`) |
-| `ScopeError` | API key lacks required permissions |
-| `ServerError` | Internal server error |
-| `ConnectionError` | Network/connection failure |
-| `NotFoundError` | Resource not found |
+Run any with `npx tsx --env-file=../.env tutorial/01-quickstart.ts`.
 
 ## Requirements
 
-- Node.js 18+ (uses native `fetch`)
-- TypeScript 5.0+ (optional, but recommended)
+- Node.js 20+ (uses native `fetch`)
+- TypeScript 5.0+ (optional, recommended)
+- Optional peers: `@langchain/core>=0.3`, `langchain>=1.0`,
+  `@langchain/anthropic>=1.0`, `@langchain/openai>=1.0`,
+  `@langchain/google-genai>=0.2`, `@langchain/tavily>=0.1`,
+  `@langchain/community>=0.3`, `@langchain/langgraph>=0.2`,
+  `llamaindex>=0.8` (install only what you use)
 
 ## Development
 
 ```bash
-# Install dependencies
 npm install
-
-# Run unit tests
-npm test
-
-# Run integration tests (requires COMPRESR_API_KEY)
-npm run test:integration
-
-# Build
+npm test                 # unit tests
+npm run test:integration # live tests (requires COMPRESR_API_KEY)
 npm run build
-
-# Lint
-npm run lint
 ```
 
-## Support
+## License
 
-- Email: support@compresr.ai
-- [API Documentation](https://compresr.ai/docs)
-- [GitHub Issues](https://github.com/compresr/sdk/issues)
+Apache 2.0 — see [LICENSE](LICENSE).
 
-## License
+## Support
 
-Apache 2.0 License - see [LICENSE](LICENSE) for details.
+- Docs: [compresr.ai/docs](https://compresr.ai/docs)
+- Issues: [GitHub](https://github.com/Compresr-ai/Compresr-SDK/issues)
+- Email: support@compresr.ai

package/dist/cjs/agents/engine.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Provider-agnostic agent engine — TypeScript port of Wave 2A.
+ *
+ * ``CompresrEngine`` wraps LangChain.js's ``initChatModel`` + ``createAgent``
+ * with Compresr's ``compresrToolMiddleware`` and normalizes the final
+ * ``AIMessage`` into a provider-shape-free :class:`NormalizedResult` that
+ * facades will remap back into provider-native shapes.
+ *
+ * Mirrors Python ``compresr/agents/engine.py``.
+ */
+import type { CompressionClient } from '../clients/compression.js';
+import { type ErrorPolicy } from '../integrations/_shared/index.js';
+import { type NormalizedResult } from './normalized.js';
+/**
+ * Immutable bundle of compression knobs forwarded to the tool middleware.
+ *
+ * Mirrors Python ``compresr.integrations._shared.CompressionPolicy``.
+ */
+export interface CompressionPolicyOptions {
+    targetCompressionRatio?: number;
+    compressionModelName?: string;
+    coarse?: boolean;
+    minTokens?: number;
+    onError?: ErrorPolicy;
+    allowTools?: Iterable<string>;
+    ignoreTools?: Iterable<string>;
+}
+/**
+ * Parse an LLM spec into ``{ provider, modelName }``.
+ *
+ * Accepted forms:
+ *  - Bare provider: ``"anthropic"`` -> ``{ provider, modelName: undefined }``.
+ *    The model must then be supplied at the call site.
+ *  - LangChain-style colon: ``"anthropic:claude-opus-4-8"``.
+ *  - Vercel-style slash: ``"anthropic/claude-opus-4-8"`` — normalized to the
+ *    colon form to match LangChain.js's ``initChatModel`` convention.
+ */
+export declare function parseLlmSpec(llm: string): {
+    provider: string;
+    modelName: string | undefined;
+};
+export interface CompresrEngineOptions {
+    compresrClient: CompressionClient;
+    llm: string;
+    llmApiKey?: string;
+    policy?: CompressionPolicyOptions;
+}
+export interface RunOptions {
+    messages: ReadonlyArray<unknown>;
+    tools?: ReadonlyArray<unknown>;
+    system?: string;
+    maxTokens?: number;
+    config?: Record<string, unknown>;
+    /**
+     * Per-call model name. If omitted, falls back to the engine's default
+     * (the model encoded in ``llm: 'provider:model'`` at construction).
+     * When neither is provided, ``run`` throws ``CompresrError("missing_model")``.
+     */
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    /** Gemini-native alias of ``maxTokens``. The engine aliases when needed. */
+    maxOutputTokens?: number;
+    stop?: string[];
+    stopSequences?: string[];
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    seed?: number;
+    logprobs?: boolean;
+    topLogprobs?: number;
+}
+interface LangChainBindings {
+    initChatModel: (modelStr: string, kwargs?: Record<string, unknown>) => unknown;
+    createAgent: (params: Record<string, unknown>) => unknown;
+}
+/**
+ * Test seam — lets vitest stub LangChain without monkey-patching
+ * ``node_modules``.
+ *
+ * @internal — not a stable public API; reserved for SDK tests only.
+ */
+export declare function _setLangChainBindings(b: LangChainBindings | undefined): void;
+export declare class CompresrEngine {
+    readonly provider: string;
+    /**
+     * Default model bound to the engine, parsed from the constructor's ``llm``
+     * spec. ``undefined`` when the spec is a bare provider — in that case the
+     * model must be supplied per-call on :meth:`run`.
+     */
+    readonly defaultModelName: string | undefined;
+    private readonly compresrClient;
+    private readonly llmApiKey?;
+    private readonly policy;
+    private readonly chatModels;
+    constructor(options: CompresrEngineOptions);
+    /**
+     * Back-compat alias for ``defaultModelName`` — returns the constructor
+     * default and may be ``undefined`` when the engine was built with a bare
+     * provider ``llm`` spec.
+     */
+    get modelName(): string | undefined;
+    private getChatModel;
+    private buildMiddleware;
+    private buildAgent;
+    /**
+     * Pull every option whose key lives in :data:`LLM_BIND_OPTIONS` and return a
+     * fresh object — the caller passes it to ``chat.bind(...)``. Non-LLM keys
+     * are silently ignored, which keeps the public ``RunOptions`` interface
+     * forgiving when callers mix in custom config.
+     *
+     * Gemini quirk: LangChain.js's ``ChatGoogleGenerativeAI`` uses
+     * ``maxOutputTokens`` instead of ``maxTokens``. We alias when the caller
+     * provided ``maxTokens`` without an explicit ``maxOutputTokens``.
+     */
+    private extractBindOptions;
+    run(options: RunOptions): Promise<NormalizedResult>;
+    private normalize;
+}
+export {};
+//# sourceMappingURL=engine.d.ts.map

package/dist/cjs/agents/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/agents/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAGL,KAAK,gBAAgB,EAEtB,MAAM,iBAAiB,CAAC;AA2BzB;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAChC;AA8BD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAiCA;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,iBAAiB,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,wBAAwB,CAAC;CACnC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAMf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAMD,UAAU,iBAAiB;IACzB,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;IAC/E,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;CAC3D;AAiCD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAE5E;AAoLD,qBAAa,cAAc;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoB;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmC;gBAElD,OAAO,EAAE,qBAAqB;IAkB1C;;;;OAIG;IACH,IAAI,SAAS,IAAI,MAAM,GAAG,SAAS,CAElC;YAEa,YAAY;YAwBZ,eAAe;YA2Bf,UAAU;IA+BxB;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;IAqBpB,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAsDzD,OAAO,CAAC,SAAS;CA6BlB"}