tooled-prompt 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Authors of Tooled Prompt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,535 @@
+# tooled-prompt
+
+[![npm version](https://img.shields.io/npm/v/tooled-prompt.svg)](https://www.npmjs.com/package/tooled-prompt)
+[![CI](https://github.com/beshanoe/tooled-prompt/actions/workflows/ci.yml/badge.svg)](https://github.com/beshanoe/tooled-prompt/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](https://nodejs.org)
+
+Runtime LLM prompt library with smart tool recognition for TypeScript.
+
+## Why tooled-prompt?
+
+Most LLM libraries make you choose between simplicity and power. tooled-prompt gives you both through a single insight: **tagged template literals are the perfect API for LLM prompts with tools**.
+
+```typescript
+const result = await prompt`
+  Summarize ${readFile} the contents of config.json.
+`();
+```
+
+Functions embedded in templates are auto-detected as tools the LLM can call. No boilerplate, no tool registration, no JSON schema authoring — just write functions and use them.
+
+**vs. raw OpenAI SDK** — tooled-prompt handles the tool loop, schema generation, streaming, and structured output automatically.
+
+**vs. LangChain / Vercel AI SDK** — tooled-prompt is a zero-dependency runtime library (~15KB). No framework lock-in, no abstractions to learn. It works with any OpenAI-compatible endpoint.
+
+## Installation
+
+```bash
+npm install tooled-prompt
+```
+
+## Quick Start
+
+```typescript
+import "dotenv/config";
+import { prompt } from "tooled-prompt";
+
+// Define a tool function
+function getWeather(cityName: string) {
+  return `Weather in ${cityName}: Sunny, 72°F`;
+}
+
+// Use it in a prompt - tools are auto-detected!
+const result = await prompt`
+  What's the weather like in San Francisco?
+  Use ${getWeather} to find out.
+`();
+
+console.log(`\nResult: ${result}`);
+```
+
+## Features
+
+- **Smart Tool Recognition** — Functions in template literals are auto-detected as tools
+- **Multiple Schema Formats** — Define tool args with strings, arrays, objects, or Zod schemas
+- **Structured Output** — Get typed responses with Zod schema validation
+- **Store Pattern** — Capture structured output via tool calls with `store()` and `prompt.return`
+- **Image Support** — Pass images (Buffer/Uint8Array) directly in templates
+- **Streaming Events** — Subscribe to content, thinking, and tool events
+- **Multiple Instances** — Create isolated instances for different LLM providers
+- **TypeScript First** — Full type safety with generics
+
+## Configuration
+
+### Environment Variables
+
+Configure the default `prompt` instance via environment variables:
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `TOOLED_PROMPT_URL` | LLM API endpoint URL | `http://localhost:8080/v1` |
+| `TOOLED_PROMPT_MODEL` | Model name | `default` |
+| `TOOLED_PROMPT_API_KEY` | API key for authentication | — |
+| `TOOLED_PROMPT_TEMPERATURE` | Generation temperature (0–2) | — |
+| `TOOLED_PROMPT_MAX_ITERATIONS` | Max tool loop iterations | — |
+| `TOOLED_PROMPT_STREAM` | Enable streaming (`true`/`false`) | `true` |
+| `TOOLED_PROMPT_TIMEOUT` | Request timeout in ms | `60000` |
+| `TOOLED_PROMPT_SILENT` | Suppress console output (`true`/`false`) | `false` |
+| `TOOLED_PROMPT_SHOW_THINKING` | Show full thinking content (`true`/`false`) | `false` |
+
+`TOOLED_PROMPT_LLM_URL` and `TOOLED_PROMPT_LLM_MODEL` are accepted as aliases for `TOOLED_PROMPT_URL` and `TOOLED_PROMPT_MODEL`.
+
+Copy `.env.example` to `.env` to get started:
+
+```bash
+cp .env.example .env
+```
+
+### Programmatic Configuration
+
+```typescript
+import { setConfig } from 'tooled-prompt';
+
+// Configure the default instance
+setConfig({
+  llmUrl: 'https://api.openai.com/v1',
+  apiKey: process.env.OPENAI_API_KEY,
+  llmModel: 'gpt-4',
+  temperature: 0.7,
+  stream: true,
+  timeout: 30000,
+  silent: false,
+});
+```
+
+### Per-Call Configuration
+
+```typescript
+const result = await prompt`Your prompt here`({
+  temperature: 0.9,
+  maxIterations: 5,
+});
+```
+
+## Provider Setup
+
+tooled-prompt works with any OpenAI-compatible `/chat/completions` endpoint.
+
+### OpenAI
+
+```typescript
+import { setConfig } from 'tooled-prompt';
+
+setConfig({
+  llmUrl: 'https://api.openai.com/v1',
+  apiKey: process.env.OPENAI_API_KEY,
+  llmModel: 'gpt-4o',
+});
+```
+
+### Local Models (Ollama, vLLM, llama.cpp)
+
+```typescript
+import { setConfig } from 'tooled-prompt';
+
+// Ollama (default OpenAI-compatible endpoint)
+setConfig({
+  llmUrl: 'http://localhost:11434/v1',
+  llmModel: 'llama3.1',
+});
+
+// vLLM
+setConfig({
+  llmUrl: 'http://localhost:8000/v1',
+  llmModel: 'meta-llama/Llama-3.1-8B-Instruct',
+});
+```
+
+### OpenRouter
+
+```typescript
+import { setConfig } from 'tooled-prompt';
+
+setConfig({
+  llmUrl: 'https://openrouter.ai/api/v1',
+  apiKey: process.env.OPENROUTER_API_KEY,
+  llmModel: 'anthropic/claude-3.5-sonnet',
+});
+```
+
+> **Note:** Anthropic's native API (`https://api.anthropic.com`) is not OpenAI-compatible and is not currently supported. Use OpenRouter or a compatible proxy to access Anthropic models.
+
+## Tool Definition
+
+### 1. Auto-Inferred (Simplest)
+
+```typescript
+function readFile(filePath: string) {
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+// Just use it - name and params are inferred
+await prompt`Read ${readFile} and summarize config.json`();
+```
+
+### 2. String Description (Single Param)
+
+```typescript
+tool(getWeather, {
+  description: 'Get weather for a city',
+  args: 'The city name to look up'
+});
+```
+
+### 3. Array Description (Multiple Params)
+
+```typescript
+function copyFile(src: string, dest: string) {
+  fs.copyFileSync(src, dest);
+}
+
+tool(copyFile, {
+  description: 'Copy a file',
+  args: ['Source file path', 'Destination file path']
+});
+```
+
+### 4. Object Schema (Named Params with Optional)
+
+```typescript
+function search(query: string, limit?: number) {
+  // ...
+}
+
+tool(search, {
+  description: 'Search for items',
+  args: {
+    query: 'Search query string',
+    'limit?': 'Maximum number of results'
+  }
+});
+```
+
+### 5. Zod Schema Array (Full Type Safety)
+
+```typescript
+import { z } from 'zod/v4';
+
+tool(createUser, {
+  description: 'Create a new user',
+  args: [
+    z.string().describe('User full name'),
+    z.string().email().describe('User email address'),
+    z.number().optional().describe('User age'),
+  ]
+});
+```
+
+### 6. Object Syntax (For Arrow Functions)
+
+```typescript
+const myFunc = async (input: string) => input.toUpperCase();
+
+// Extract name from object key
+tool({ myFunc }, {
+  description: 'Transform text to uppercase',
+  args: 'Text to transform'
+});
+```
+
+## Structured Output
+
+Get typed, validated responses using Zod schemas:
+
+```typescript
+import { z } from 'zod/v4';
+
+const MovieSchema = z.object({
+  title: z.string(),
+  year: z.number(),
+  rating: z.number().min(0).max(10),
+});
+
+const movie = await prompt`
+  Tell me about the movie Inception
+`(MovieSchema);
+
+// movie is typed as { title: string; year: number; rating: number }
+console.log(movie.title, movie.year);
+```
+
+Or use simple schemas for string fields:
+
+```typescript
+const result = await prompt`Analyze this text: ${text}`({
+  sentiment: 'Overall sentiment (positive/negative/neutral)',
+  'confidence?': 'Confidence score if available',
+});
+```
+
+## Store & Return Pattern
+
+For complex workflows where you need the LLM to save structured data via a tool call (rather than as the final response), use `store()` or `prompt.return`.
+
+### `prompt.return` — Early-Exit Structured Output
+
+When `prompt.return` appears in a template and a schema is passed to the executor, the LLM gets a special tool to store the result. The tool loop exits as soon as the value is stored:
+
+```typescript
+import { z } from 'zod/v4';
+
+const schema = z.object({
+  summary: z.string(),
+  files: z.array(z.object({
+    path: z.string(),
+    description: z.string(),
+  })),
+});
+
+const result = await prompt`
+  Use ${readDir} and ${readFile} to analyze the project.
+  Save your analysis in ${prompt.return}.
+`(schema);
+
+// result is typed according to the schema
+console.log(result.summary);
+```
+
+### `store()` — Explicit Store
+
+For manual control, create a store and retrieve the value after execution:
+
+```typescript
+import { store } from 'tooled-prompt';
+import { z } from 'zod/v4';
+
+const changeLog = store(z.object({
+  summary: z.string(),
+  entries: z.array(z.object({
+    commit: z.string(),
+    description: z.string(),
+  })),
+}));
+
+await prompt`
+  Use ${gitLog} to read commits, then save a structured
+  changelog in ${changeLog}.
+`();
+
+const result = changeLog.get(); // typed, or undefined if not stored
+```
+
+## Image Support
+
+Pass images directly in templates. `Buffer` and `Uint8Array` values are auto-detected and converted to base64 for vision-capable models:
+
+```typescript
+import { readFileSync } from 'fs';
+
+const image = readFileSync('photo.png');
+
+const result = await prompt`Describe this image: ${image}`();
+```
+
+Multiple images work too:
+
+```typescript
+const before = readFileSync('before.png');
+const after = readFileSync('after.png');
+
+const result = await prompt`
+  Compare these two images:
+  Before: ${before}
+  After: ${after}
+`();
+```
+
+## Event Handling
+
+### Default Instance
+
+The default instance has logging enabled — it streams content to stdout and logs tool calls:
+
+```typescript
+import { prompt, setConfig } from 'tooled-prompt';
+
+// Logging is ON by default
+await prompt`Hello, world!`();  // Streams to stdout
+
+// Disable logging
+setConfig({ silent: true });
+await prompt`Hello, world!`();  // Silent
+```
+
+### Custom Event Handlers
+
+```typescript
+import { prompt, on, off } from 'tooled-prompt';
+
+// Subscribe to events
+on('content', (content) => {
+  process.stdout.write(content);
+});
+
+on('thinking', (content) => {
+  console.log('[Thinking]', content);
+});
+
+on('tool_call', (name, args) => {
+  console.log(`Calling ${name} with`, args);
+});
+
+on('tool_result', (name, result, duration) => {
+  console.log(`${name} returned in ${duration}ms:`, result);
+});
+
+on('tool_error', (name, error) => {
+  console.error(`${name} failed:`, error);
+});
+```
+
+### Created Instances (Silent by Default)
+
+```typescript
+import { createTooledPrompt } from 'tooled-prompt';
+
+// Silent by default
+const tp = createTooledPrompt();
+await tp.prompt`Hello`();  // No output
+
+// Opt-in to logging
+tp.on('content', (c) => process.stdout.write(c));
+await tp.prompt`Hello`();  // Now streams
+```
+
+## Multiple Instances
+
+Create isolated instances for different LLM providers or models:
+
+```typescript
+import { createTooledPrompt } from 'tooled-prompt';
+
+const openai = createTooledPrompt({
+  llmUrl: 'https://api.openai.com/v1',
+  apiKey: process.env.OPENAI_API_KEY,
+  llmModel: 'gpt-4o',
+});
+
+const local = createTooledPrompt({
+  llmUrl: 'http://localhost:11434/v1',
+  llmModel: 'llama3.1',
+});
+
+// Each instance is isolated
+const openaiResult = await openai.prompt`Summarize this document`();
+const localResult = await local.prompt`Translate to French: ${text}`();
+```
+
+You can also use different models for different tasks within one workflow:
+
+```typescript
+const imageLlm = createTooledPrompt({ llmModel: 'gemma-3-27b-it' });
+const toolLlm = createTooledPrompt({ llmModel: 'gpt-4o' });
+
+async function describeImage(path: string) {
+  const image = readFileSync(path);
+  return imageLlm.prompt`Describe this image: ${image}`();
+}
+
+// Tool LLM orchestrates, delegates image work to image LLM
+await toolLlm.prompt`
+  Find images using ${listFiles} and describe each with ${describeImage}.
+`();
+```
+
+## Error Handling
+
+### Common Errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Request timeout after Xms` | LLM endpoint didn't respond in time | Increase `timeout` in config |
+| `LLM request failed (4xx/5xx)` | Authentication or server error | Check `apiKey` and `llmUrl` |
+| `Max iterations (N) reached` | Tool loop didn't converge | Increase `maxIterations`, simplify the prompt, or check tool implementations |
+| `No response from LLM` | Empty response from provider | Check model availability and endpoint |
+| `Failed to parse JSON response` | Structured output returned invalid JSON | Try a more capable model or simplify the schema |
+| `Schema validation failed` | Response didn't match Zod schema | Adjust schema or prompt to match expected output |
+
+### Handling Errors
+
+```typescript
+try {
+  const result = await prompt`...`();
+} catch (err) {
+  if (err.message.includes('timeout')) {
+    // Retry with longer timeout
+  } else if (err.message.includes('Max iterations')) {
+    // Simplify the task or increase maxIterations
+  }
+}
+```
+
+## Limitations & Known Issues
+
+- **OpenAI-compatible only** — The library sends requests to `/chat/completions` with OpenAI's format. Anthropic's native API is not supported (use OpenRouter for Anthropic models).
+- **TypeScript `?` not detectable at runtime** — The parser uses `fn.toString()` to infer parameters. TypeScript's `?` optional marker is stripped at compile time. Use `= defaultValue` for runtime-detectable optional params, or provide explicit `args` descriptors.
+- **Tool results truncated at 2000 chars** — Long tool results are truncated to avoid context overflow. If your tools return large data, consider summarizing within the tool.
+- **No system prompt support** — There's currently no built-in way to prepend a system message. The user message is the only message sent.
+- **`zod` peer dependency** — Structured output and Zod-based arg descriptors require `zod >= 4.0.0` (optional peer dependency).
+
+## API Reference
+
+### Exports
+
+```typescript
+// Default instance
+export const prompt: PromptTemplate;
+export const setConfig: (config: TooledPromptConfig) => void;
+export const on: <K extends keyof TooledPromptEvents>(event: K, handler: TooledPromptEvents[K]) => void;
+export const off: <K extends keyof TooledPromptEvents>(event: K, handler: TooledPromptEvents[K]) => void;
+
+// Factory
+export function createTooledPrompt(config?: TooledPromptConfig): TooledPromptInstance;
+
+// Tool utilities
+export function tool<T extends Function>(fn: T, options?: ToolOptions): ToolFunction<T>;
+export function isTool(value: unknown): value is ToolFunction;
+export function getToolMetadata(fn: ToolFunction): ToolMetadata;
+export const TOOL_SYMBOL: unique symbol;
+
+// Store
+export function store<T>(schema: ZodType<T>): Store<T>;
+```
+
+### Event Types
+
+```typescript
+interface TooledPromptEvents {
+  thinking: (content: string) => void;
+  content: (content: string) => void;
+  tool_call: (name: string, args: Record<string, unknown>) => void;
+  tool_result: (name: string, result: string, duration: number) => void;
+  tool_error: (name: string, error: string) => void;
+}
+```
+
+### Configuration Options
+
+```typescript
+interface TooledPromptConfig {
+  llmUrl?: string;        // LLM API endpoint
+  llmModel?: string;      // Model name
+  apiKey?: string;        // API key
+  maxIterations?: number; // Max tool loop iterations
+  temperature?: number;   // Generation temperature (0–2)
+  stream?: boolean;       // Enable streaming (default: true)
+  timeout?: number;       // Request timeout in ms (default: 60000)
+  silent?: boolean;       // Suppress console output (default: false for default instance)
+  showThinking?: boolean; // Show full thinking content (default: false)
+}
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

package/dist/events.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Event system for tooled-prompt
+ *
+ * Provides a simple event emitter for streaming LLM events
+ */
+/**
+ * Event types emitted during prompt execution
+ */
+export interface TooledPromptEvents {
+    /** Thinking/reasoning content from the LLM */
+    thinking: (content: string) => void;
+    /** Response content from the LLM */
+    content: (content: string) => void;
+    /** Tool call started */
+    tool_call: (name: string, args: Record<string, unknown>) => void;
+    /** Tool call completed successfully */
+    tool_result: (name: string, result: string, duration: number) => void;
+    /** Tool call failed */
+    tool_error: (name: string, error: string) => void;
+}
+/**
+ * Event handler function type
+ */
+type EventHandler<K extends keyof TooledPromptEvents> = TooledPromptEvents[K];
+/**
+ * Simple typed event emitter for tooled-prompt events
+ */
+export declare class TooledPromptEmitter {
+    private handlers;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof TooledPromptEvents>(event: K, handler: EventHandler<K>): void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<K extends keyof TooledPromptEvents>(event: K, handler: EventHandler<K>): void;
+    /**
+     * Emit an event to all subscribers
+     */
+    emit<K extends keyof TooledPromptEvents>(event: K, ...args: Parameters<TooledPromptEvents[K]>): void;
+    /**
+     * Check if there are any handlers for an event
+     */
+    hasHandlers<K extends keyof TooledPromptEvents>(event: K): boolean;
+    /**
+     * Remove all handlers for all events
+     */
+    clear(): void;
+}
+/**
+ * Default content handler - writes to stdout
+ */
+export declare function defaultContentHandler(content: string): void;
+/**
+ * Default thinking handler - writes to stdout with formatting
+ */
+export declare function defaultThinkingHandler(content: string): void;
+/**
+ * Default tool_call handler - logs tool invocation
+ */
+export declare function defaultToolCallHandler(name: string, args: Record<string, unknown>): void;
+/**
+ * Default tool_result handler - logs result
+ */
+export declare function defaultToolResultHandler(_name: string, result: string, _duration: number): void;
+/**
+ * Default tool_error handler - logs error
+ */
+export declare function defaultToolErrorHandler(name: string, error: string): void;
+/**
+ * Options for installDefaultHandlers
+ */
+export interface DefaultHandlerOptions {
+    /** When returns true, suppresses all console output */
+    isSilent?: () => boolean;
+    /** When returns true, streams full thinking content instead of just showing a label */
+    showThinking?: () => boolean;
+}
+/**
+ * Install default logging handlers on an emitter
+ *
+ * @param target - Object with an `on` method for subscribing to events
+ * @param options - Optional getters for silent and showThinking behavior
+ */
+export declare function installDefaultHandlers(target: {
+    on: TooledPromptEmitter["on"];
+}, options?: DefaultHandlerOptions): void;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,oCAAoC;IACpC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,wBAAwB;IACxB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjE,uCAAuC;IACvC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACtE,uBAAuB;IACvB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnD;AAED;;GAEG;AACH,KAAK,YAAY,CAAC,CAAC,SAAS,MAAM,kBAAkB,IAAI,kBAAkB,CAAC,CAAC,CAAC,CAAC;AAE9E;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAGZ;IAEJ;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACnC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,IAAI;IAOP;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACpC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,IAAI;IAIP;;OAEG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACrC,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GACzC,IAAI;IASP;;OAEG;IACH,WAAW,CAAC,CAAC,SAAS,MAAM,kBAAkB,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO;IAKlE;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE3D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,IAAI,CAmBN;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAEzE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC;IACzB,uFAAuF;IACvF,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE;IAAE,EAAE,EAAE,mBAAmB,CAAC,IAAI,CAAC,CAAA;CAAE,EACzC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CA6CN"}