mnehmos.trace.mcp 1.0.0

package/dist/adapters/trpc/adapter.d.ts

@@ -0,0 +1,159 @@
+/**
+ * 📋 tRPC Schema Adapter
+ *
+ * Extracts and converts tRPC router definitions to NormalizedSchema.
+ *
+ * This adapter implements the SchemaAdapter interface for tRPC
+ * router files. It supports extraction of:
+ * - Procedure input schemas (from `.input()` calls)
+ * - Procedure output schemas (from `.output()` calls)
+ * - Nested router structures
+ * - Zod schema validation rules
+ *
+ * Uses ts-morph for AST analysis, parsing the actual TypeScript
+ * source code to extract schema definitions without requiring
+ * runtime evaluation.
+ *
+ * @module adapters/trpc/adapter
+ */
+import type { SchemaAdapter, SchemaRef, NormalizedSchema } from '../../core/types.js';
+/**
+ * Schema adapter for tRPC router definitions.
+ *
+ * Implements the SchemaAdapter interface to extract schemas from
+ * tRPC router files. Uses ts-morph for AST analysis to parse
+ * Zod schemas without runtime evaluation.
+ *
+ * Supported tRPC patterns:
+ * - `t.router({ ... })` - Standard tRPC v10+ pattern
+ * - `createTRPCRouter({ ... })` - Next.js/T3 pattern
+ * - `createRouter({ ... })` - Legacy pattern
+ * - Nested routers via object composition
+ *
+ * Supported Zod schemas:
+ * - Primitives: `z.string()`, `z.number()`, `z.boolean()`
+ * - Objects: `z.object({ ... })`
+ * - Arrays: `z.array(...)`
+ * - Unions: `z.union([...])`, `z.enum([...])`
+ * - Modifiers: `.optional()`, `.nullable()`, `.default()`
+ * - Constraints: `.min()`, `.max()`, `.email()`, etc.
+ *
+ * @implements {SchemaAdapter}
+ *
+ * @example
+ * ```typescript
+ * import { TRPCAdapter } from './adapter.js';
+ * import { registerAdapter } from '../registry.js';
+ *
+ * // Register the adapter
+ * registerAdapter(new TRPCAdapter());
+ *
+ * // Extract procedure input schema
+ * const adapter = new TRPCAdapter();
+ * const schema = await adapter.extract({
+ *   source: 'trpc',
+ *   id: 'trpc:users.getById@./router.ts'
+ * });
+ *
+ * // Extract procedure output schema
+ * const outputSchema = await adapter.extract({
+ *   source: 'trpc',
+ *   id: 'trpc:users.getById.output@./router.ts'
+ * });
+ *
+ * // List all procedures in a file
+ * const refs = await adapter.list('./router.ts');
+ * ```
+ */
+export declare class TRPCAdapter implements SchemaAdapter {
+    /** Adapter kind identifier */
+    readonly kind: "trpc";
+    /**
+     * Check if this adapter supports the given schema reference.
+     *
+     * @param ref - The schema reference to check
+     * @returns True if the ref source is 'trpc'
+     */
+    supports(ref: SchemaRef): boolean;
+    /**
+     * Extract a schema from a tRPC procedure.
+     *
+     * Parses the ref ID to determine the procedure and schema type:
+     * - `trpc:{path}@{file}` - Extract input schema (default)
+     * - `trpc:{path}.input@{file}` - Extract input schema (explicit)
+     * - `trpc:{path}.output@{file}` - Extract output schema
+     *
+     * The extraction process:
+     * 1. Parse the reference ID to get procedure path and schema type
+     * 2. Load and parse the TypeScript file with ts-morph
+     * 3. Find all router definitions and extract procedures
+     * 4. Locate the target procedure by path
+     * 5. Convert the Zod schema to NormalizedSchema
+     *
+     * @param ref - The schema reference specifying what to extract
+     * @returns Promise resolving to the normalized schema
+     * @throws {Error} If the ref ID is invalid
+     * @throws {Error} If the file is not found
+     * @throws {Error} If the procedure is not found
+     *
+     * @example
+     * ```typescript
+     * // Extract input schema (default)
+     * const schema = await adapter.extract({
+     *   source: 'trpc',
+     *   id: 'trpc:users.getById@./router.ts'
+     * });
+     *
+     * // Extract output schema
+     * const outputSchema = await adapter.extract({
+     *   source: 'trpc',
+     *   id: 'trpc:users.create.output@./router.ts'
+     * });
+     *
+     * // Access the extracted schema
+     * console.log(schema.name);        // 'users.getById.input'
+     * console.log(schema.properties);  // { id: { type: {...}, optional: false, ... } }
+     * console.log(schema.required);    // ['id']
+     * ```
+     */
+    extract(ref: SchemaRef): Promise<NormalizedSchema>;
+    /**
+     * List all tRPC procedures in a file.
+     *
+     * Scans the file for router definitions and returns a SchemaRef
+     * for each procedure found. Only returns input schema refs by default,
+     * as these are the most commonly needed for validation.
+     *
+     * The listing process:
+     * 1. Load and parse the TypeScript file with ts-morph
+     * 2. Find all router definitions (including nested routers)
+     * 3. Extract procedure definitions
+     * 4. Build SchemaRef IDs for each procedure
+     *
+     * Handles errors gracefully - returns empty array if file not found
+     * or parsing fails, per ADR guidelines.
+     *
+     * @param basePath - Path to the tRPC router file
+     * @returns Promise resolving to array of procedure SchemaRefs
+     *
+     * @example
+     * ```typescript
+     * const refs = await adapter.list('./server/routers/index.ts');
+     * // [
+     * //   { source: 'trpc', id: 'trpc:users.list@./server/routers/index.ts' },
+     * //   { source: 'trpc', id: 'trpc:users.getById@./server/routers/index.ts' },
+     * //   { source: 'trpc', id: 'trpc:users.create@./server/routers/index.ts' },
+     * //   { source: 'trpc', id: 'trpc:posts.list@./server/routers/index.ts' },
+     * //   ...
+     * // ]
+     *
+     * // Then extract each schema
+     * for (const ref of refs) {
+     *   const schema = await adapter.extract(ref);
+     *   console.log(`${schema.name}: ${Object.keys(schema.properties).length} props`);
+     * }
+     * ```
+     */
+    list(basePath: string): Promise<SchemaRef[]>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/trpc/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/trpc/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,gBAAgB,EACjB,MAAM,qBAAqB,CAAC;AAc7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,WAAY,YAAW,aAAa;IAC/C,8BAA8B;IAC9B,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAEhC;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO;IAIjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA2CxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CA+BnD"}

package/dist/adapters/trpc/adapter.js

@@ -0,0 +1,223 @@
+/**
+ * 📋 tRPC Schema Adapter
+ *
+ * Extracts and converts tRPC router definitions to NormalizedSchema.
+ *
+ * This adapter implements the SchemaAdapter interface for tRPC
+ * router files. It supports extraction of:
+ * - Procedure input schemas (from `.input()` calls)
+ * - Procedure output schemas (from `.output()` calls)
+ * - Nested router structures
+ * - Zod schema validation rules
+ *
+ * Uses ts-morph for AST analysis, parsing the actual TypeScript
+ * source code to extract schema definitions without requiring
+ * runtime evaluation.
+ *
+ * @module adapters/trpc/adapter
+ */
+import { existsSync } from 'fs';
+import { parseTRPCRef, buildTRPCRefId } from './parser.js';
+import { createProject, extractProcedures, zodToNormalizedSchema, createEmptySchema, } from './extractor.js';
+// ============================================================================
+// Adapter Implementation
+// ============================================================================
+/**
+ * Schema adapter for tRPC router definitions.
+ *
+ * Implements the SchemaAdapter interface to extract schemas from
+ * tRPC router files. Uses ts-morph for AST analysis to parse
+ * Zod schemas without runtime evaluation.
+ *
+ * Supported tRPC patterns:
+ * - `t.router({ ... })` - Standard tRPC v10+ pattern
+ * - `createTRPCRouter({ ... })` - Next.js/T3 pattern
+ * - `createRouter({ ... })` - Legacy pattern
+ * - Nested routers via object composition
+ *
+ * Supported Zod schemas:
+ * - Primitives: `z.string()`, `z.number()`, `z.boolean()`
+ * - Objects: `z.object({ ... })`
+ * - Arrays: `z.array(...)`
+ * - Unions: `z.union([...])`, `z.enum([...])`
+ * - Modifiers: `.optional()`, `.nullable()`, `.default()`
+ * - Constraints: `.min()`, `.max()`, `.email()`, etc.
+ *
+ * @implements {SchemaAdapter}
+ *
+ * @example
+ * ```typescript
+ * import { TRPCAdapter } from './adapter.js';
+ * import { registerAdapter } from '../registry.js';
+ *
+ * // Register the adapter
+ * registerAdapter(new TRPCAdapter());
+ *
+ * // Extract procedure input schema
+ * const adapter = new TRPCAdapter();
+ * const schema = await adapter.extract({
+ *   source: 'trpc',
+ *   id: 'trpc:users.getById@./router.ts'
+ * });
+ *
+ * // Extract procedure output schema
+ * const outputSchema = await adapter.extract({
+ *   source: 'trpc',
+ *   id: 'trpc:users.getById.output@./router.ts'
+ * });
+ *
+ * // List all procedures in a file
+ * const refs = await adapter.list('./router.ts');
+ * ```
+ */
+export class TRPCAdapter {
+    /** Adapter kind identifier */
+    kind = 'trpc';
+    /**
+     * Check if this adapter supports the given schema reference.
+     *
+     * @param ref - The schema reference to check
+     * @returns True if the ref source is 'trpc'
+     */
+    supports(ref) {
+        return ref.source === 'trpc';
+    }
+    /**
+     * Extract a schema from a tRPC procedure.
+     *
+     * Parses the ref ID to determine the procedure and schema type:
+     * - `trpc:{path}@{file}` - Extract input schema (default)
+     * - `trpc:{path}.input@{file}` - Extract input schema (explicit)
+     * - `trpc:{path}.output@{file}` - Extract output schema
+     *
+     * The extraction process:
+     * 1. Parse the reference ID to get procedure path and schema type
+     * 2. Load and parse the TypeScript file with ts-morph
+     * 3. Find all router definitions and extract procedures
+     * 4. Locate the target procedure by path
+     * 5. Convert the Zod schema to NormalizedSchema
+     *
+     * @param ref - The schema reference specifying what to extract
+     * @returns Promise resolving to the normalized schema
+     * @throws {Error} If the ref ID is invalid
+     * @throws {Error} If the file is not found
+     * @throws {Error} If the procedure is not found
+     *
+     * @example
+     * ```typescript
+     * // Extract input schema (default)
+     * const schema = await adapter.extract({
+     *   source: 'trpc',
+     *   id: 'trpc:users.getById@./router.ts'
+     * });
+     *
+     * // Extract output schema
+     * const outputSchema = await adapter.extract({
+     *   source: 'trpc',
+     *   id: 'trpc:users.create.output@./router.ts'
+     * });
+     *
+     * // Access the extracted schema
+     * console.log(schema.name);        // 'users.getById.input'
+     * console.log(schema.properties);  // { id: { type: {...}, optional: false, ... } }
+     * console.log(schema.required);    // ['id']
+     * ```
+     */
+    async extract(ref) {
+        const parsed = parseTRPCRef(ref.id);
+        if (!parsed) {
+            throw new Error(`Invalid tRPC ref ID: ${ref.id}`);
+        }
+        const { path: procedurePath, schemaType, filePath } = parsed;
+        // Check if file exists
+        if (!existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        // Create project and load file
+        const project = createProject();
+        const sourceFile = project.addSourceFileAtPath(filePath);
+        // Extract all procedures
+        const procedures = extractProcedures(sourceFile);
+        // Find the target procedure
+        const procedure = procedures.find(p => p.path.join('.') === procedurePath);
+        if (!procedure) {
+            throw new Error(`Procedure "${procedurePath}" not found in ${filePath}`);
+        }
+        // Get the appropriate schema
+        const schemaNode = schemaType === 'output'
+            ? procedure.outputSchema
+            : procedure.inputSchema;
+        // Build the schema name
+        const schemaName = `${procedurePath}.${schemaType}`;
+        if (!schemaNode) {
+            // Return empty schema for procedures without explicit input/output
+            return createEmptySchema(ref, procedure.location, schemaName);
+        }
+        return zodToNormalizedSchema(schemaNode, ref, procedure.location, schemaName);
+    }
+    /**
+     * List all tRPC procedures in a file.
+     *
+     * Scans the file for router definitions and returns a SchemaRef
+     * for each procedure found. Only returns input schema refs by default,
+     * as these are the most commonly needed for validation.
+     *
+     * The listing process:
+     * 1. Load and parse the TypeScript file with ts-morph
+     * 2. Find all router definitions (including nested routers)
+     * 3. Extract procedure definitions
+     * 4. Build SchemaRef IDs for each procedure
+     *
+     * Handles errors gracefully - returns empty array if file not found
+     * or parsing fails, per ADR guidelines.
+     *
+     * @param basePath - Path to the tRPC router file
+     * @returns Promise resolving to array of procedure SchemaRefs
+     *
+     * @example
+     * ```typescript
+     * const refs = await adapter.list('./server/routers/index.ts');
+     * // [
+     * //   { source: 'trpc', id: 'trpc:users.list@./server/routers/index.ts' },
+     * //   { source: 'trpc', id: 'trpc:users.getById@./server/routers/index.ts' },
+     * //   { source: 'trpc', id: 'trpc:users.create@./server/routers/index.ts' },
+     * //   { source: 'trpc', id: 'trpc:posts.list@./server/routers/index.ts' },
+     * //   ...
+     * // ]
+     *
+     * // Then extract each schema
+     * for (const ref of refs) {
+     *   const schema = await adapter.extract(ref);
+     *   console.log(`${schema.name}: ${Object.keys(schema.properties).length} props`);
+     * }
+     * ```
+     */
+    async list(basePath) {
+        try {
+            // Check if file exists
+            if (!existsSync(basePath)) {
+                return [];
+            }
+            // Create project and load file
+            const project = createProject();
+            const sourceFile = project.addSourceFileAtPath(basePath);
+            // Extract all procedures
+            const procedures = extractProcedures(sourceFile);
+            // Convert to SchemaRefs
+            const refs = [];
+            for (const proc of procedures) {
+                const procPath = proc.path.join('.');
+                refs.push({
+                    source: 'trpc',
+                    id: buildTRPCRefId(procPath, 'input', basePath),
+                });
+            }
+            return refs;
+        }
+        catch {
+            // Per ADR, list() should handle errors gracefully
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapters/trpc/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../../src/adapters/trpc/adapter.ts"],"names":[],"mappings":"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"}

package/dist/adapters/trpc/extractor.d.ts

@@ -0,0 +1,218 @@
+/**
+ * 🔧 tRPC Router/Procedure Extractor
+ *
+ * AST-based extraction of tRPC router definitions and Zod schemas.
+ * This module provides utilities to:
+ * - Parse TypeScript files containing tRPC routers
+ * - Extract procedure definitions (query, mutation, subscription)
+ * - Convert Zod schemas to NormalizedSchema format
+ *
+ * Uses ts-morph for AST analysis, supporting patterns like:
+ * - `t.router({ ... })` - Standard tRPC v10+ pattern
+ * - `createTRPCRouter({ ... })` - Next.js/T3 pattern
+ * - Nested routers via object composition
+ *
+ * @module adapters/trpc/extractor
+ */
+import { Project, Node, CallExpression, SourceFile } from 'ts-morph';
+import type { NormalizedSchema, SchemaRef, SourceLocation } from '../../core/types.js';
+/**
+ * Information about an extracted tRPC procedure.
+ *
+ * Represents a single procedure within a router, including its
+ * path (e.g., `["users", "getById"]`), type, and schema AST nodes.
+ *
+ * @example
+ * ```typescript
+ * const info: ProcedureInfo = {
+ *   path: ['users', 'getById'],
+ *   type: 'query',
+ *   inputSchema: inputNode,
+ *   outputSchema: undefined,
+ *   location: { file: './router.ts', line: 42 }
+ * };
+ * ```
+ */
+export interface ProcedureInfo {
+    /** Full path as array (e.g., ["users", "getById"]) */
+    path: string[];
+    /** Procedure type: query for reads, mutation for writes, subscription for realtime */
+    type: 'query' | 'mutation' | 'subscription';
+    /** Input schema AST node (from `.input(...)` call), if defined */
+    inputSchema?: Node;
+    /** Output schema AST node (from `.output(...)` call), if defined */
+    outputSchema?: Node;
+    /** Source location where the procedure is defined */
+    location: SourceLocation;
+}
+/**
+ * Create a new ts-morph Project instance for AST analysis.
+ *
+ * Configures the project without tsconfig to allow standalone
+ * file analysis without project-wide compilation context.
+ *
+ * @returns A new ts-morph Project instance
+ *
+ * @example
+ * ```typescript
+ * const project = createProject();
+ * const sourceFile = project.addSourceFileAtPath('./router.ts');
+ * const procedures = extractProcedures(sourceFile);
+ * ```
+ */
+export declare function createProject(): Project;
+/**
+ * Extract all procedures from a tRPC router source file.
+ *
+ * Scans the file for router definitions and extracts all procedure
+ * definitions, including those in nested routers. Each procedure
+ * is returned with its full path, type, and schema nodes.
+ *
+ * Supported patterns:
+ * - `t.router({ user: t.procedure.query(...) })`
+ * - `createTRPCRouter({ users: userRouter })`
+ * - `createRouter({ nested: { deep: procedure } })`
+ *
+ * @param sourceFile - The ts-morph SourceFile to analyze
+ * @returns Array of ProcedureInfo objects for all found procedures
+ *
+ * @example
+ * ```typescript
+ * const project = createProject();
+ * const file = project.addSourceFileAtPath('./server/routers/index.ts');
+ * const procedures = extractProcedures(file);
+ *
+ * for (const proc of procedures) {
+ *   console.log(`${proc.path.join('.')} - ${proc.type}`);
+ *   // Output: "users.getById - query"
+ * }
+ * ```
+ */
+export declare function extractProcedures(sourceFile: SourceFile): ProcedureInfo[];
+/**
+ * Check if a call expression is a tRPC router call.
+ *
+ * Matches patterns like:
+ * - `t.router(...)` - Method call on object
+ * - `trpc.router(...)` - Namespaced call
+ * - `createRouter(...)` - Function call
+ * - `createTRPCRouter(...)` - T3/Next.js pattern
+ *
+ * @param node - The AST node to check
+ * @returns True if the node is a router call expression
+ *
+ * @example
+ * ```typescript
+ * sourceFile.forEachDescendant((node) => {
+ *   if (Node.isCallExpression(node) && isRouterCall(node)) {
+ *     // Process router definition
+ *   }
+ * });
+ * ```
+ */
+export declare function isRouterCall(node: Node): node is CallExpression;
+/**
+ * Check if a node is a tRPC procedure chain.
+ *
+ * Procedure chains are method chains that terminate in `.query()`,
+ * `.mutation()`, or `.subscription()`. This function walks up the
+ * chain to find these terminal methods.
+ *
+ * @param node - The AST node to check
+ * @returns True if the node is a procedure chain
+ *
+ * @example
+ * ```typescript
+ * // These would return true:
+ * // t.procedure.input(z.string()).query(...)
+ * // t.procedure.mutation(...)
+ * // publicProcedure.subscription(...)
+ * ```
+ */
+export declare function isProcedureChain(node: Node | undefined): boolean;
+/**
+ * Parse a router object literal and extract all procedures.
+ *
+ * Recursively processes router definitions, handling:
+ * - Direct procedure definitions
+ * - Nested router references
+ * - Inline nested routers
+ *
+ * @param routerCall - The router call expression node
+ * @param currentPath - Current path prefix for nested routers
+ * @param filePath - Path to the source file
+ * @returns Array of ProcedureInfo for all found procedures
+ */
+export declare function parseRouterObject(routerCall: CallExpression, currentPath: string[], filePath: string): ProcedureInfo[];
+/**
+ * Parse a procedure method chain to extract input/output schemas.
+ *
+ * Walks the method chain (`.input().output().query()`) and extracts:
+ * - Input schema from `.input(zodSchema)`
+ * - Output schema from `.output(zodSchema)`
+ * - Procedure type from terminal method (`.query()`, `.mutation()`, `.subscription()`)
+ *
+ * @param node - The procedure chain call expression
+ * @param path - Full path to this procedure
+ * @param filePath - Path to the source file
+ * @returns ProcedureInfo or null if parsing fails
+ *
+ * @example
+ * ```typescript
+ * // For: t.procedure.input(z.object({ id: z.string() })).query(...)
+ * // Returns: { path: ['getById'], type: 'query', inputSchema: <Node>, ... }
+ * ```
+ */
+export declare function parseProcedureChain(node: Node, path: string[], filePath: string): ProcedureInfo | null;
+/**
+ * Convert a Zod schema AST node to NormalizedSchema.
+ *
+ * Parses Zod schema definitions and converts them to the framework's
+ * NormalizedSchema format. Supports common Zod types:
+ * - Primitives: `z.string()`, `z.number()`, `z.boolean()`
+ * - Objects: `z.object({ ... })`
+ * - Arrays: `z.array(...)`
+ * - Unions: `z.union([...])`, `z.enum([...])`
+ * - Modifiers: `.optional()`, `.nullable()`, `.default()`
+ * - Constraints: `.min()`, `.max()`, `.email()`, etc.
+ *
+ * @param node - The AST node containing the Zod schema
+ * @param ref - The SchemaRef for source tracking
+ * @param location - Source location for error reporting
+ * @param name - Optional schema name
+ * @returns The converted NormalizedSchema
+ *
+ * @example
+ * ```typescript
+ * const schema = zodToNormalizedSchema(
+ *   inputSchemaNode,
+ *   { source: 'trpc', id: 'trpc:users.create@./router.ts' },
+ *   { file: './router.ts', line: 42 },
+ *   'users.create.input'
+ * );
+ * ```
+ */
+export declare function zodToNormalizedSchema(node: Node, ref: SchemaRef, location: SourceLocation, name?: string): NormalizedSchema;
+/**
+ * Create an empty NormalizedSchema.
+ *
+ * Used for procedures without explicit input or output schemas.
+ * Returns a valid schema with empty properties.
+ *
+ * @param ref - The SchemaRef for source tracking
+ * @param location - Source location for error reporting
+ * @param name - Optional schema name
+ * @returns An empty NormalizedSchema
+ *
+ * @example
+ * ```typescript
+ * // For a procedure with no .input() call
+ * const emptyInput = createEmptySchema(
+ *   ref,
+ *   { file: './router.ts', line: 10 },
+ *   'users.list.input'
+ * );
+ * ```
+ */
+export declare function createEmptySchema(ref: SchemaRef, location: SourceLocation, name?: string): NormalizedSchema;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/adapters/trpc/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/adapters/trpc/extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,OAAO,EACP,IAAI,EACJ,cAAc,EACd,UAAU,EAGX,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACV,gBAAgB,EAGhB,SAAS,EACT,cAAc,EAEf,MAAM,qBAAqB,CAAC;AAM7B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,sFAAsF;IACtF,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;IAC5C,kEAAkE;IAClE,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,oEAAoE;IACpE,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,qDAAqD;IACrD,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAKvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,EAAE,CAazE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,cAAc,CAiB/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,CAyBhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,cAAc,EAC1B,WAAW,EAAE,MAAM,EAAE,EACrB,QAAQ,EAAE,MAAM,GACf,aAAa,EAAE,CAsCjB;AAwDD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,MAAM,GACf,aAAa,GAAG,IAAI,CA2DtB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,cAAc,EACxB,IAAI,CAAC,EAAE,MAAM,GACZ,gBAAgB,CAgClB;AA0TD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,cAAc,EACxB,IAAI,CAAC,EAAE,MAAM,GACZ,gBAAgB,CAQlB"}