@veloxts/router 0.2.0 → 0.2.2

package/dist/rest/index.js

@@ -0,0 +1,9 @@
+/**
+ * REST adapter exports
+ *
+ * @module rest
+ */
+// REST adapter - public API
+export { createRoutesRegistrar, generateRestRoutes, getRouteSummary, registerRestRoutes, } from './adapter.js';
+export { buildRestPath, followsNamingConvention, inferResourceName, parseNamingConvention, } from './naming.js';
+//# sourceMappingURL=index.js.map

package/dist/rest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rest/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,4BAA4B;AAC5B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,GACnB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,aAAa,CAAC"}

package/dist/rest/naming.d.ts

@@ -0,0 +1,83 @@
+/**
+ * REST naming convention parser
+ *
+ * Parses procedure names to infer HTTP methods and paths following
+ * convention-over-configuration principles.
+ *
+ * @module rest/naming
+ */
+import type { HttpMethod, ProcedureType } from '../types.js';
+/**
+ * Result of parsing a procedure name into REST route info
+ */
+export interface RestMapping {
+    /** HTTP method inferred from naming convention */
+    readonly method: HttpMethod;
+    /** Path pattern (e.g., '/', '/:id') */
+    readonly path: string;
+    /** Whether the path includes an :id parameter */
+    readonly hasIdParam: boolean;
+}
+/**
+ * Parse a procedure name into REST mapping using naming conventions
+ *
+ * @param name - Procedure name (e.g., 'getUser', 'listUsers', 'createUser')
+ * @param type - Procedure type ('query' or 'mutation')
+ * @returns REST mapping if convention matches, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * parseNamingConvention('getUser', 'query')
+ * // Returns: { method: 'GET', path: '/:id', hasIdParam: true }
+ *
+ * parseNamingConvention('listUsers', 'query')
+ * // Returns: { method: 'GET', path: '/', hasIdParam: false }
+ *
+ * parseNamingConvention('createUser', 'mutation')
+ * // Returns: { method: 'POST', path: '/', hasIdParam: false }
+ *
+ * parseNamingConvention('doSomething', 'mutation')
+ * // Returns: undefined (no convention matches)
+ * ```
+ */
+export declare function parseNamingConvention(name: string, type: ProcedureType): RestMapping | undefined;
+/**
+ * Build the full REST path from namespace and mapping
+ *
+ * @param namespace - Resource namespace (e.g., 'users')
+ * @param mapping - REST mapping from parseNamingConvention
+ * @returns Full path (e.g., '/users/:id', '/users')
+ *
+ * @example
+ * ```typescript
+ * buildRestPath('users', { method: 'GET', path: '/:id', hasIdParam: true })
+ * // Returns: '/users/:id'
+ *
+ * buildRestPath('users', { method: 'GET', path: '/', hasIdParam: false })
+ * // Returns: '/users'
+ * ```
+ */
+export declare function buildRestPath(namespace: string, mapping: RestMapping): string;
+/**
+ * Infer the resource name from a procedure name
+ *
+ * @param name - Procedure name (e.g., 'getUser', 'listUsers')
+ * @returns Resource name or undefined if cannot be inferred
+ *
+ * @example
+ * ```typescript
+ * inferResourceName('getUser')     // 'User'
+ * inferResourceName('listUsers')   // 'Users'
+ * inferResourceName('doSomething') // undefined
+ * ```
+ */
+export declare function inferResourceName(name: string): string | undefined;
+/**
+ * Check if a procedure name follows any known naming convention
+ *
+ * @param name - Procedure name to check
+ * @param type - Procedure type
+ * @returns true if the name follows a convention
+ */
+export declare function followsNamingConvention(name: string, type: ProcedureType): boolean;
+//# sourceMappingURL=naming.d.ts.map

package/dist/rest/naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../src/rest/naming.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAM7D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AA4ED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,GAAG,SAAS,CAoBhG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CAU7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQlE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAElF"}

package/dist/rest/naming.js

@@ -0,0 +1,164 @@
+/**
+ * REST naming convention parser
+ *
+ * Parses procedure names to infer HTTP methods and paths following
+ * convention-over-configuration principles.
+ *
+ * @module rest/naming
+ */
+// ============================================================================
+// Naming Patterns
+// ============================================================================
+/**
+ * MVP (v0.1.0) naming patterns - GET and POST only
+ *
+ * Pattern matching is done by prefix:
+ * - get<Resource>    -> GET /:id    (single resource)
+ * - list<Resources>  -> GET /       (collection)
+ * - find<Resource>   -> GET /       (search/filter)
+ * - create<Resource> -> POST /      (create new)
+ * - add<Resource>    -> POST /      (alias for create)
+ *
+ * v1.1+ will add:
+ * - update<Resource> -> PUT /:id
+ * - delete<Resource> -> DELETE /:id
+ */
+const MVP_NAMING_PATTERNS = [
+    // GET with ID - single resource retrieval
+    {
+        pattern: /^get([A-Z][a-zA-Z]*)$/,
+        method: 'GET',
+        hasIdParam: true,
+        procedureType: 'query',
+    },
+    // GET without ID - list/collection
+    {
+        pattern: /^list([A-Z][a-zA-Z]*)$/,
+        method: 'GET',
+        hasIdParam: false,
+        procedureType: 'query',
+    },
+    // GET without ID - search/find
+    {
+        pattern: /^find([A-Z][a-zA-Z]*)$/,
+        method: 'GET',
+        hasIdParam: false,
+        procedureType: 'query',
+    },
+    // POST - create resource
+    {
+        pattern: /^create([A-Z][a-zA-Z]*)$/,
+        method: 'POST',
+        hasIdParam: false,
+        procedureType: 'mutation',
+    },
+    // POST - add resource (alias)
+    {
+        pattern: /^add([A-Z][a-zA-Z]*)$/,
+        method: 'POST',
+        hasIdParam: false,
+        procedureType: 'mutation',
+    },
+];
+// ============================================================================
+// Parsing Functions
+// ============================================================================
+/**
+ * Parse a procedure name into REST mapping using naming conventions
+ *
+ * @param name - Procedure name (e.g., 'getUser', 'listUsers', 'createUser')
+ * @param type - Procedure type ('query' or 'mutation')
+ * @returns REST mapping if convention matches, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * parseNamingConvention('getUser', 'query')
+ * // Returns: { method: 'GET', path: '/:id', hasIdParam: true }
+ *
+ * parseNamingConvention('listUsers', 'query')
+ * // Returns: { method: 'GET', path: '/', hasIdParam: false }
+ *
+ * parseNamingConvention('createUser', 'mutation')
+ * // Returns: { method: 'POST', path: '/', hasIdParam: false }
+ *
+ * parseNamingConvention('doSomething', 'mutation')
+ * // Returns: undefined (no convention matches)
+ * ```
+ */
+export function parseNamingConvention(name, type) {
+    for (const pattern of MVP_NAMING_PATTERNS) {
+        // Check if procedure type matches
+        if (pattern.procedureType !== type) {
+            continue;
+        }
+        // Check if name matches pattern
+        const match = pattern.pattern.exec(name);
+        if (match) {
+            return {
+                method: pattern.method,
+                path: pattern.hasIdParam ? '/:id' : '/',
+                hasIdParam: pattern.hasIdParam,
+            };
+        }
+    }
+    // No convention matched
+    return undefined;
+}
+/**
+ * Build the full REST path from namespace and mapping
+ *
+ * @param namespace - Resource namespace (e.g., 'users')
+ * @param mapping - REST mapping from parseNamingConvention
+ * @returns Full path (e.g., '/users/:id', '/users')
+ *
+ * @example
+ * ```typescript
+ * buildRestPath('users', { method: 'GET', path: '/:id', hasIdParam: true })
+ * // Returns: '/users/:id'
+ *
+ * buildRestPath('users', { method: 'GET', path: '/', hasIdParam: false })
+ * // Returns: '/users'
+ * ```
+ */
+export function buildRestPath(namespace, mapping) {
+    const basePath = `/${namespace}`;
+    // If path is just '/', return the base path without trailing slash
+    if (mapping.path === '/') {
+        return basePath;
+    }
+    // Otherwise append the path (e.g., '/:id')
+    return `${basePath}${mapping.path}`;
+}
+/**
+ * Infer the resource name from a procedure name
+ *
+ * @param name - Procedure name (e.g., 'getUser', 'listUsers')
+ * @returns Resource name or undefined if cannot be inferred
+ *
+ * @example
+ * ```typescript
+ * inferResourceName('getUser')     // 'User'
+ * inferResourceName('listUsers')   // 'Users'
+ * inferResourceName('doSomething') // undefined
+ * ```
+ */
+export function inferResourceName(name) {
+    for (const pattern of MVP_NAMING_PATTERNS) {
+        const match = pattern.pattern.exec(name);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a procedure name follows any known naming convention
+ *
+ * @param name - Procedure name to check
+ * @param type - Procedure type
+ * @returns true if the name follows a convention
+ */
+export function followsNamingConvention(name, type) {
+    return parseNamingConvention(name, type) !== undefined;
+}
+//# sourceMappingURL=naming.js.map

package/dist/rest/naming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.js","sourceRoot":"","sources":["../../src/rest/naming.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkCH,+EAA+E;AAC/E,kBAAkB;AAClB,+EAA+E;AAE/E;;;;;;;;;;;;;GAaG;AACH,MAAM,mBAAmB,GAA6B;IACpD,0CAA0C;IAC1C;QACE,OAAO,EAAE,uBAAuB;QAChC,MAAM,EAAE,KAAK;QACb,UAAU,EAAE,IAAI;QAChB,aAAa,EAAE,OAAO;KACvB;IACD,mCAAmC;IACnC;QACE,OAAO,EAAE,wBAAwB;QACjC,MAAM,EAAE,KAAK;QACb,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,OAAO;KACvB;IACD,+BAA+B;IAC/B;QACE,OAAO,EAAE,wBAAwB;QACjC,MAAM,EAAE,KAAK;QACb,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,OAAO;KACvB;IACD,yBAAyB;IACzB;QACE,OAAO,EAAE,0BAA0B;QACnC,MAAM,EAAE,MAAM;QACd,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,UAAU;KAC1B;IACD,8BAA8B;IAC9B;QACE,OAAO,EAAE,uBAAuB;QAChC,MAAM,EAAE,MAAM;QACd,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,UAAU;KAC1B;CACO,CAAC;AAEX,+EAA+E;AAC/E,oBAAoB;AACpB,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY,EAAE,IAAmB;IACrE,KAAK,MAAM,OAAO,IAAI,mBAAmB,EAAE,CAAC;QAC1C,kCAAkC;QAClC,IAAI,OAAO,CAAC,aAAa,KAAK,IAAI,EAAE,CAAC;YACnC,SAAS;QACX,CAAC;QAED,gCAAgC;QAChC,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,KAAK,EAAE,CAAC;YACV,OAAO;gBACL,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG;gBACvC,UAAU,EAAE,OAAO,CAAC,UAAU;aAC/B,CAAC;QACJ,CAAC;IACH,CAAC;IAED,wBAAwB;IACxB,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,aAAa,CAAC,SAAiB,EAAE,OAAoB;IACnE,MAAM,QAAQ,GAAG,IAAI,SAAS,EAAE,CAAC;IAEjC,mEAAmE;IACnE,IAAI,OAAO,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;QACzB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,2CAA2C;IAC3C,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,KAAK,MAAM,OAAO,IAAI,mBAAmB,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAY,EAAE,IAAmB;IACvE,OAAO,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,SAAS,CAAC;AACzD,CAAC"}

package/dist/trpc/adapter.d.ts

@@ -0,0 +1,182 @@
+/**
+ * tRPC adapter for procedure collections
+ *
+ * Converts VeloxTS procedure definitions into tRPC routers, enabling type-safe
+ * API calls between frontend and backend.
+ *
+ * @module trpc/adapter
+ */
+import type { AnyRouter as TRPCAnyRouter } from '@trpc/server';
+import { TRPCError } from '@trpc/server';
+import type { BaseContext } from '@veloxts/core';
+import type { FastifyInstance } from 'fastify';
+/**
+ * Re-exported AnyRouter type from tRPC
+ *
+ * This allows consumers to use AnyRouter without directly importing @trpc/server,
+ * which helps avoid TypeScript compilation memory issues with tRPC v11.7+.
+ */
+export type AnyRouter = TRPCAnyRouter;
+import type { ProcedureCollection } from '../types.js';
+declare const baseTRPC: import("@trpc/server").TRPCRootObject<BaseContext, object, import("@trpc/server").TRPCRuntimeConfigOptions<BaseContext, object>, {
+    ctx: BaseContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}>;
+/**
+ * Type for a created tRPC instance
+ *
+ * Using typeof on a concrete instance avoids the "cannot be named" error
+ * that occurs with generic type inference in tRPC v11.7+
+ */
+export type TRPCInstance<_TContext extends BaseContext = BaseContext> = typeof baseTRPC;
+/**
+ * Create a tRPC instance with VeloxTS context
+ *
+ * This initializes tRPC with the BaseContext type, allowing procedures
+ * to access request context and plugin-provided features.
+ *
+ * @returns tRPC instance with context
+ *
+ * @example
+ * ```typescript
+ * const t = createTRPC();
+ *
+ * const router = t.router({
+ *   hello: t.procedure.query(() => 'Hello World'),
+ * });
+ * ```
+ */
+export declare function createTRPC(): TRPCInstance;
+/**
+ * Build a tRPC router from a single procedure collection
+ *
+ * Converts all procedures in a collection to tRPC procedures,
+ * preserving type information for client inference.
+ *
+ * @param t - tRPC instance
+ * @param collection - Procedure collection to convert
+ * @returns tRPC router
+ *
+ * @example
+ * ```typescript
+ * const t = createTRPC();
+ * const userRouter = buildTRPCRouter(t, userProcedures);
+ *
+ * // Router has typed procedures:
+ * // userRouter.getUser({ id: '123' })
+ * ```
+ */
+export declare function buildTRPCRouter(t: TRPCInstance<BaseContext>, collection: ProcedureCollection): AnyRouter;
+/**
+ * Create a namespaced app router from multiple procedure collections
+ *
+ * Each collection becomes a nested router under its namespace.
+ *
+ * @param t - tRPC instance
+ * @param collections - Array of procedure collections
+ * @returns Merged app router
+ *
+ * @example
+ * ```typescript
+ * const t = createTRPC();
+ * const appRouter = createAppRouter(t, [
+ *   userProcedures,    // namespace: 'users'
+ *   postProcedures,    // namespace: 'posts'
+ * ]);
+ *
+ * // Usage:
+ * // appRouter.users.getUser({ id: '123' })
+ * // appRouter.posts.listPosts({ page: 1 })
+ *
+ * // Export type for client
+ * export type AppRouter = typeof appRouter;
+ * ```
+ */
+export declare function createAppRouter(t: TRPCInstance<BaseContext>, collections: ProcedureCollection[]): AnyRouter;
+/**
+ * Helper type to infer the AppRouter type
+ */
+export type InferAppRouter = AnyRouter;
+/**
+ * Create a tRPC context factory for Fastify
+ *
+ * This factory creates the context for each tRPC request,
+ * pulling from the Fastify request's decorated context.
+ *
+ * @template TContext - Context type
+ * @returns Context factory function
+ *
+ * @example
+ * ```typescript
+ * import { fastifyTRPCPlugin } from '@trpc/server/adapters/fastify';
+ *
+ * await server.register(fastifyTRPCPlugin, {
+ *   prefix: '/trpc',
+ *   trpcOptions: {
+ *     router: appRouter,
+ *     createContext: createTRPCContextFactory(),
+ *   },
+ * });
+ * ```
+ */
+export declare function createTRPCContextFactory(): ({ req }: {
+    req: {
+        context?: BaseContext;
+    };
+}) => BaseContext;
+/**
+ * Convert a VeloxTS error to a tRPC error
+ *
+ * Maps VeloxTS error codes to appropriate tRPC error codes.
+ *
+ * @param error - Error to convert
+ * @param defaultCode - Default tRPC code if mapping not found
+ * @returns TRPCError
+ */
+export declare function veloxErrorToTRPCError(error: Error & {
+    statusCode?: number;
+    code?: string;
+}, defaultCode?: TRPCError['code']): TRPCError;
+/**
+ * Type guard for tRPC errors with VeloxTS cause
+ *
+ * Use this when handling errors that may have been converted from VeloxTS errors
+ * using veloxErrorToTRPCError().
+ */
+export declare function isVeloxTRPCError(error: TRPCError): error is TRPCError & {
+    cause: string;
+};
+/**
+ * Options for tRPC plugin registration
+ */
+export interface TRPCPluginOptions {
+    /** URL prefix for tRPC routes (default: '/trpc') */
+    prefix?: string;
+    /** tRPC router created with createAppRouter */
+    router: AnyRouter;
+}
+/**
+ * Register tRPC plugin with Fastify server
+ *
+ * This is a convenience wrapper around fastifyTRPCPlugin that handles
+ * the context factory automatically.
+ *
+ * @param server - Fastify server instance
+ * @param options - tRPC plugin options
+ *
+ * @example
+ * ```typescript
+ * const app = await createVeloxApp({ port: 3210 });
+ * const appRouter = createAppRouter(t, [userProcedures]);
+ *
+ * await registerTRPCPlugin(app.server, {
+ *   prefix: '/trpc',
+ *   router: appRouter,
+ * });
+ * ```
+ */
+export declare function registerTRPCPlugin(server: FastifyInstance, options: TRPCPluginOptions): Promise<void>;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/trpc/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAY,SAAS,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC;AAEtC,OAAO,KAAK,EAAqB,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQ1E,QAAA,MAAM,QAAQ;;;;;EAA2C,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,SAAS,SAAS,WAAW,GAAG,WAAW,IAAI,OAAO,QAAQ,CAAC;AAExF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,IAAI,YAAY,CAIzC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,EAC5B,UAAU,EAAE,mBAAmB,GAC9B,SAAS,CAWX;AA2ID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,EAC5B,WAAW,EAAE,mBAAmB,EAAE,GACjC,SAAS,CAQX;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,CAAC;AAMvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,KAC9B,SAAS;IAAE,GAAG,EAAE;QAAE,OAAO,CAAC,EAAE,WAAW,CAAA;KAAE,CAAA;CAAE,KAAG,WAAW,CAWlE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACrD,WAAW,GAAE,SAAS,CAAC,MAAM,CAA2B,GACvD,SAAS,CAqBX;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,IAAI,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAEzF;AAMD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,MAAM,EAAE,SAAS,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC,CAWf"}