typed-agents 1.0.0

package/dist/tools/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./registry"), exports);
+__exportStar(require("./tool.decorator"), exports);
+__exportStar(require("./tool.types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,mDAAiC;AACjC,+CAA6B"}

package/dist/tools/registry.d.ts

@@ -0,0 +1,128 @@
+import { ToolClass, ToolMetadata } from "./tool.types";
+/**
+ * Internal shape of a single entry stored inside the registry for each tool method.
+ * Groups the JavaScript method name with its associated metadata so both are
+ * always available together during tool resolution and dispatch.
+ */
+interface RegisteredTool {
+    /** The JavaScript property key of the decorated method on the tool class. */
+    method: string;
+    /** The full metadata supplied to the `@tool()` decorator for this method. */
+    metadata: ToolMetadata;
+}
+/**
+ * Global, static registry that tracks every tool method decorated with `@tool()`.
+ *
+ * `ToolRegistry` acts as the single source of truth for all tools known to the
+ * framework. It is populated automatically at class-definition time through the
+ * `@tool()` decorator — you should never need to call its methods directly in
+ * application code.
+ *
+ * Internally it maintains a `Map` keyed by tool class constructor, so multiple
+ * independent tool classes can coexist without naming collisions at the class level.
+ *
+ * ### Lifecycle
+ * 1. A module containing a `@tool()`-decorated class is imported.
+ * 2. TypeScript executes the decorator, which calls {@link ToolRegistry.registerMethod}.
+ * 3. The framework later calls {@link ToolRegistry.getTools} or
+ *    {@link ToolRegistry.getAllRegisteredClasses} to build the tool dispatch map
+ *    for an agent run.
+ * 4. In test environments, {@link ToolRegistry.clear} resets all state between tests.
+ *
+ * @example
+ *
+ * // Inspect all tools registered on a specific class:
+ * const tools = ToolRegistry.getTools(MyToolsClass);
+ * tools.forEach(t => console.log(t.metadata.name));
+ *
+ */
+export declare class ToolRegistry {
+    /**
+     * The backing store mapping each tool class to the list of its registered methods.
+     * Kept private to enforce all access through the typed static API.
+     */
+    private static tools;
+    /**
+     * Registers a single decorated method on a tool class.
+     *
+     * Called automatically by the `@tool()` decorator — **do not invoke manually**
+     * in production code. Each call appends the method entry to the class's existing
+     * list (or creates a new list if this is the first tool on the class).
+     *
+     * **Side-effects / warnings:**
+     * - Emits a `console.warn` if `metadata.description` is missing or empty,
+     *   since a missing description degrades LLM tool-selection quality.
+     * - Emits a `console.warn` if another tool with the same `metadata.name` is
+     *   already registered anywhere in the registry, because duplicate names cause
+     *   non-deterministic behaviour when the model invokes that tool.
+     *
+     * @param toolClass  - The class constructor on which the decorated method lives.
+     * @param method     - The JavaScript property key of the decorated method (e.g. `'searchWeb'`).
+     * @param metadata   - The full {@link ToolMetadata} passed to the `@tool()` decorator.
+     */
+    static registerMethod(toolClass: ToolClass, method: string, metadata: ToolMetadata): void;
+    /**
+     * Returns all registered tool entries for a specific tool class.
+     *
+     * Use this to retrieve the tools belonging to a single class before building
+     * its dispatch map or generating its tool definitions for the LLM.
+     *
+     * @param toolClass - The class constructor whose tools you want to retrieve.
+     * @returns An array of `{ method, metadata }` entries, or an empty array if
+     *          the class has no registered tools (or was never imported).
+     *
+     * @example
+     *
+     * const entries = ToolRegistry.getTools(WebSearchTools);
+     * const definitions = entries.map(e => toToolDefinition(e.metadata));
+     *
+     */
+    static getTools(toolClass: ToolClass): RegisteredTool[];
+    /**
+     * Returns the constructors of every class that has at least one registered tool.
+     *
+     * Useful when building a full agent tool set dynamically — iterate the result,
+     * instantiate each class, and bind its tools via {@link getTools}.
+     *
+     * @returns An array of class constructors in insertion order.
+     *
+     * @example
+     *
+     * const allClasses = ToolRegistry.getAllRegisteredClasses();
+     * const instances = allClasses.map(Cls => new Cls());
+     *
+     */
+    static getAllRegisteredClasses(): ToolClass[];
+    /**
+     * Returns the `name` values of every registered tool, across all classes.
+     *
+     * Primarily used internally for duplicate-name detection inside
+     * {@link registerMethod}, but also handy for debugging or building allow-lists.
+     *
+     * @returns A flat array of tool name strings in registration order.
+     *
+     * @example
+     *
+     * console.log(ToolRegistry.getAllToolNames());
+     * // ['search_web', 'read_file', 'send_email']
+     *
+     */
+    static getAllToolNames(): string[];
+    /**
+     * Removes all registered tools from the registry, resetting it to its initial state.
+     *
+     * **Only use this in test environments.** Calling `clear()` in production will
+     * silently break any agent that relies on the cleared tools, since the decorators
+     * only run once at module load time and will not re-register.
+     *
+     * @example
+     *
+     * afterEach(() => {
+     *   ToolRegistry.clear();
+     * });
+     *
+     */
+    static clear(): void;
+}
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEvD;;;;GAIG;AACH,UAAU,cAAc;IACtB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IAEf,6EAA6E;IAC7E,QAAQ,EAAE,YAAY,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,YAAY;IACvB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK,CAA0C;IAE9D;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,cAAc,CACnB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,YAAY,GACrB,IAAI;IAeP;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,EAAE;IAIvD;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,uBAAuB,IAAI,SAAS,EAAE;IAI7C;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,eAAe,IAAI,MAAM,EAAE;IAMlC;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;CAGrB"}

package/dist/tools/registry.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = void 0;
+/**
+ * Global, static registry that tracks every tool method decorated with `@tool()`.
+ *
+ * `ToolRegistry` acts as the single source of truth for all tools known to the
+ * framework. It is populated automatically at class-definition time through the
+ * `@tool()` decorator — you should never need to call its methods directly in
+ * application code.
+ *
+ * Internally it maintains a `Map` keyed by tool class constructor, so multiple
+ * independent tool classes can coexist without naming collisions at the class level.
+ *
+ * ### Lifecycle
+ * 1. A module containing a `@tool()`-decorated class is imported.
+ * 2. TypeScript executes the decorator, which calls {@link ToolRegistry.registerMethod}.
+ * 3. The framework later calls {@link ToolRegistry.getTools} or
+ *    {@link ToolRegistry.getAllRegisteredClasses} to build the tool dispatch map
+ *    for an agent run.
+ * 4. In test environments, {@link ToolRegistry.clear} resets all state between tests.
+ *
+ * @example
+ *
+ * // Inspect all tools registered on a specific class:
+ * const tools = ToolRegistry.getTools(MyToolsClass);
+ * tools.forEach(t => console.log(t.metadata.name));
+ *
+ */
+class ToolRegistry {
+    /**
+     * The backing store mapping each tool class to the list of its registered methods.
+     * Kept private to enforce all access through the typed static API.
+     */
+    static tools = new Map();
+    /**
+     * Registers a single decorated method on a tool class.
+     *
+     * Called automatically by the `@tool()` decorator — **do not invoke manually**
+     * in production code. Each call appends the method entry to the class's existing
+     * list (or creates a new list if this is the first tool on the class).
+     *
+     * **Side-effects / warnings:**
+     * - Emits a `console.warn` if `metadata.description` is missing or empty,
+     *   since a missing description degrades LLM tool-selection quality.
+     * - Emits a `console.warn` if another tool with the same `metadata.name` is
+     *   already registered anywhere in the registry, because duplicate names cause
+     *   non-deterministic behaviour when the model invokes that tool.
+     *
+     * @param toolClass  - The class constructor on which the decorated method lives.
+     * @param method     - The JavaScript property key of the decorated method (e.g. `'searchWeb'`).
+     * @param metadata   - The full {@link ToolMetadata} passed to the `@tool()` decorator.
+     */
+    static registerMethod(toolClass, method, metadata) {
+        if (!metadata.description) {
+            console.warn(`[ToolRegistry] Tool "${metadata.name}" has not description`);
+        }
+        const existing = this.tools.get(toolClass) ?? [];
+        existing.push({ method, metadata });
+        this.tools.set(toolClass, existing);
+        const allNames = this.getAllToolNames();
+        if (allNames.filter((n) => n === metadata.name).length > 1) {
+            console.warn(`[ToolRegistry] ⚠️ Duplicated tool: "${metadata.name}"`);
+        }
+    }
+    /**
+     * Returns all registered tool entries for a specific tool class.
+     *
+     * Use this to retrieve the tools belonging to a single class before building
+     * its dispatch map or generating its tool definitions for the LLM.
+     *
+     * @param toolClass - The class constructor whose tools you want to retrieve.
+     * @returns An array of `{ method, metadata }` entries, or an empty array if
+     *          the class has no registered tools (or was never imported).
+     *
+     * @example
+     *
+     * const entries = ToolRegistry.getTools(WebSearchTools);
+     * const definitions = entries.map(e => toToolDefinition(e.metadata));
+     *
+     */
+    static getTools(toolClass) {
+        return this.tools.get(toolClass) ?? [];
+    }
+    /**
+     * Returns the constructors of every class that has at least one registered tool.
+     *
+     * Useful when building a full agent tool set dynamically — iterate the result,
+     * instantiate each class, and bind its tools via {@link getTools}.
+     *
+     * @returns An array of class constructors in insertion order.
+     *
+     * @example
+     *
+     * const allClasses = ToolRegistry.getAllRegisteredClasses();
+     * const instances = allClasses.map(Cls => new Cls());
+     *
+     */
+    static getAllRegisteredClasses() {
+        return Array.from(this.tools.keys());
+    }
+    /**
+     * Returns the `name` values of every registered tool, across all classes.
+     *
+     * Primarily used internally for duplicate-name detection inside
+     * {@link registerMethod}, but also handy for debugging or building allow-lists.
+     *
+     * @returns A flat array of tool name strings in registration order.
+     *
+     * @example
+     *
+     * console.log(ToolRegistry.getAllToolNames());
+     * // ['search_web', 'read_file', 'send_email']
+     *
+     */
+    static getAllToolNames() {
+        return Array.from(this.tools.values())
+            .flat()
+            .map((t) => t.metadata.name);
+    }
+    /**
+     * Removes all registered tools from the registry, resetting it to its initial state.
+     *
+     * **Only use this in test environments.** Calling `clear()` in production will
+     * silently break any agent that relies on the cleared tools, since the decorators
+     * only run once at module load time and will not re-register.
+     *
+     * @example
+     *
+     * afterEach(() => {
+     *   ToolRegistry.clear();
+     * });
+     *
+     */
+    static clear() {
+        this.tools.clear();
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+//# sourceMappingURL=registry.js.map

package/dist/tools/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":";;;AAeA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAa,YAAY;IACvB;;;OAGG;IACK,MAAM,CAAC,KAAK,GAAG,IAAI,GAAG,EAA+B,CAAC;IAE9D;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,cAAc,CACnB,SAAoB,EACpB,MAAc,EACd,QAAsB;QAEtB,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;YAC1B,OAAO,CAAC,IAAI,CAAC,wBAAwB,QAAQ,CAAC,IAAI,uBAAuB,CAAC,CAAC;QAC7E,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACjD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAEpC,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3D,OAAO,CAAC,IAAI,CAAC,uCAAuC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,QAAQ,CAAC,SAAoB;QAClC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,uBAAuB;QAC5B,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,eAAe;QACpB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;aACnC,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK;QACV,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;;AAtHH,oCAuHC"}

package/dist/tools/tool.decorator.d.ts

@@ -0,0 +1,71 @@
+import "reflect-metadata";
+import { ToolMetadata } from "./tool.types";
+/**
+ * Method decorator that marks a class method as an AI-invokable tool.
+ *
+ * Applying `@tool()` to a method does two things at class-definition time:
+ * 1. **Stores metadata** on the method via `Reflect.defineMetadata`, making it
+ *    available for later introspection with `Reflect.getMetadata`.
+ * 2. **Registers the method** in the global {@link ToolRegistry}, so the framework
+ *    can discover and dispatch it without any additional wiring.
+ *
+ * The decorator is designed to be the *only* configuration point you need:
+ * after decorating a method, its class can be passed directly to an agent and
+ * all tools will be available automatically.
+ *
+ * ### Requirements
+ * - `experimentalDecorators: true` and `emitDecoratorMetadata: true` must be
+ *   enabled in `tsconfig.json`.
+ * - `reflect-metadata` must be imported once at the application entry point
+ *   (or is handled by this module's top-level import).
+ *
+ * ### Warnings
+ * - If `metadata.description` is absent, the decorator applies a default description
+ *   ("No description provided"), which may hurt LLM tool-selection quality. It is
+ *   strongly recommended to always provide a meaningful description.
+ * - Registering two tools with the same `metadata.name` (across any class) may lead
+ *   to non-deterministic model behaviour. Ensure tool names are unique globally.
+ *
+ * @param metadata - Configuration object describing the tool to the framework and
+ *                   to the language model. At minimum, `name` and `description`
+ *                   should always be provided.
+ *
+ * @returns A standard TypeScript method decorator function.
+ *
+ * @example — Basic tool
+ *
+ * import { z } from 'zod';
+ * import { tool } from './tool.decorator';
+ *
+ * class WebTools {
+ *   @tool({
+ *     name: 'search_web',
+ *     description: 'Searches the web and returns the top results for a query.',
+ *     inputSchema: z.object({ query: z.string().describe('The search query') }),
+ *     outputSchema: z.array(z.string()),
+ *   })
+ *   async searchWeb(input: { query: string }): Promise<string[]> {
+ *     // implementation
+ *   }
+ * }
+ *
+ *
+ * @example — Composable tool (delegates to a sub-agent)
+ *
+ * class OrchestratorTools {
+ *   @tool({
+ *     name: 'run_research_agent',
+ *     description: 'Runs a specialised research agent for in-depth information gathering.',
+ *     inputSchema: z.object({ topic: z.string() }),
+ *     isComposable: true,
+ *     agentClass: ResearchAgent,
+ *     maxSteps: 15,
+ *   })
+ *   async runResearch(input: { topic: string }) {
+ *     // The framework handles delegation — this body may be empty.
+ *   }
+ * }
+ *
+ */
+export declare function tool(metadata: ToolMetadata): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => void;
+//# sourceMappingURL=tool.decorator.d.ts.map

package/dist/tools/tool.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.decorator.d.ts","sourceRoot":"","sources":["../../src/tools/tool.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAa,MAAM,cAAc,CAAC;AAcvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAgB,IAAI,CAAC,QAAQ,EAAE,YAAY,IAEvC,QAAQ,MAAM,EACd,aAAa,MAAM,EACnB,YAAY,kBAAkB,UAyBjC"}

package/dist/tools/tool.decorator.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = tool;
+require("reflect-metadata");
+const registry_1 = require("./registry");
+/**
+ * Reflect metadata key used to store {@link ToolMetadata} on a decorated method.
+ *
+ * Scoped with a namespaced string (`typed-agents:tool`) to avoid collisions with
+ * other libraries that also use `reflect-metadata`. Kept as a module-level constant
+ * so it can be referenced both when writing and when reading the metadata.
+ *
+ * @internal
+ */
+const TOOL_METADATA_KEY = Symbol("typed-agents:tool");
+/**
+ * Method decorator that marks a class method as an AI-invokable tool.
+ *
+ * Applying `@tool()` to a method does two things at class-definition time:
+ * 1. **Stores metadata** on the method via `Reflect.defineMetadata`, making it
+ *    available for later introspection with `Reflect.getMetadata`.
+ * 2. **Registers the method** in the global {@link ToolRegistry}, so the framework
+ *    can discover and dispatch it without any additional wiring.
+ *
+ * The decorator is designed to be the *only* configuration point you need:
+ * after decorating a method, its class can be passed directly to an agent and
+ * all tools will be available automatically.
+ *
+ * ### Requirements
+ * - `experimentalDecorators: true` and `emitDecoratorMetadata: true` must be
+ *   enabled in `tsconfig.json`.
+ * - `reflect-metadata` must be imported once at the application entry point
+ *   (or is handled by this module's top-level import).
+ *
+ * ### Warnings
+ * - If `metadata.description` is absent, the decorator applies a default description
+ *   ("No description provided"), which may hurt LLM tool-selection quality. It is
+ *   strongly recommended to always provide a meaningful description.
+ * - Registering two tools with the same `metadata.name` (across any class) may lead
+ *   to non-deterministic model behaviour. Ensure tool names are unique globally.
+ *
+ * @param metadata - Configuration object describing the tool to the framework and
+ *                   to the language model. At minimum, `name` and `description`
+ *                   should always be provided.
+ *
+ * @returns A standard TypeScript method decorator function.
+ *
+ * @example — Basic tool
+ *
+ * import { z } from 'zod';
+ * import { tool } from './tool.decorator';
+ *
+ * class WebTools {
+ *   @tool({
+ *     name: 'search_web',
+ *     description: 'Searches the web and returns the top results for a query.',
+ *     inputSchema: z.object({ query: z.string().describe('The search query') }),
+ *     outputSchema: z.array(z.string()),
+ *   })
+ *   async searchWeb(input: { query: string }): Promise<string[]> {
+ *     // implementation
+ *   }
+ * }
+ *
+ *
+ * @example — Composable tool (delegates to a sub-agent)
+ *
+ * class OrchestratorTools {
+ *   @tool({
+ *     name: 'run_research_agent',
+ *     description: 'Runs a specialised research agent for in-depth information gathering.',
+ *     inputSchema: z.object({ topic: z.string() }),
+ *     isComposable: true,
+ *     agentClass: ResearchAgent,
+ *     maxSteps: 15,
+ *   })
+ *   async runResearch(input: { topic: string }) {
+ *     // The framework handles delegation — this body may be empty.
+ *   }
+ * }
+ *
+ */
+function tool(metadata) {
+    return function (target, propertyKey, descriptor) {
+        /**
+         * Resolved metadata with guaranteed defaults applied.
+         * `description` falls back to a placeholder so downstream consumers
+         * (e.g. tool-definition serialisers) never receive `undefined`.
+         */
+        const finalMetadata = {
+            ...metadata,
+            description: metadata.description ?? "No description provided",
+        };
+        Reflect.defineMetadata(TOOL_METADATA_KEY, finalMetadata, target, propertyKey);
+        registry_1.ToolRegistry.registerMethod(target.constructor, propertyKey, finalMetadata);
+    };
+}
+//# sourceMappingURL=tool.decorator.js.map

package/dist/tools/tool.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.decorator.js","sourceRoot":"","sources":["../../src/tools/tool.decorator.ts"],"names":[],"mappings":";;AAkFA,oBA6BC;AA/GD,4BAA0B;AAE1B,yCAA0C;AAE1C;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,SAAgB,IAAI,CAAC,QAAsB;IACzC,OAAO,UACL,MAAc,EACd,WAAmB,EACnB,UAA8B;QAE9B;;;;WAIG;QACH,MAAM,aAAa,GAAiB;YAClC,GAAG,QAAQ;YACX,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,yBAAyB;SAC/D,CAAC;QAEF,OAAO,CAAC,cAAc,CACpB,iBAAiB,EACjB,aAAa,EACb,MAAM,EACN,WAAW,CACZ,CAAC;QAEF,uBAAY,CAAC,cAAc,CACzB,MAAM,CAAC,WAAwB,EAC/B,WAAW,EACX,aAAa,CACd,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}