wynkjs 1.0.0

package/dist/decorators/interceptor.advanced.js

@@ -0,0 +1,228 @@
+import "reflect-metadata";
+/**
+ * Advanced Interceptors for WynkJS Framework
+ * Additional interceptors for common use cases
+ */
+/**
+ * Response Interceptor - Wraps all responses in a standard format
+ * @example
+ * @UseInterceptors(ResponseInterceptor)
+ * @Controller('/api')
+ * export class ApiController {}
+ */
+export class ResponseInterceptor {
+    async intercept(context, next) {
+        const request = context.getRequest();
+        const startTime = Date.now();
+        try {
+            const data = await next.handle();
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                statusCode: 200,
+                data,
+                meta: {
+                    timestamp: new Date().toISOString(),
+                    duration: `${duration}ms`,
+                    path: request.url,
+                    method: request.method,
+                },
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return {
+                success: false,
+                statusCode: error.statusCode || 500,
+                error: {
+                    message: error.message,
+                    code: error.code,
+                },
+                meta: {
+                    timestamp: new Date().toISOString(),
+                    duration: `${duration}ms`,
+                    path: request.url,
+                    method: request.method,
+                },
+            };
+        }
+    }
+}
+/**
+ * Error Handling Interceptor - Catches and transforms errors
+ * @example
+ * @UseInterceptors(ErrorHandlingInterceptor)
+ * @Get()
+ * async getData() {}
+ */
+export class ErrorHandlingInterceptor {
+    async intercept(context, next) {
+        try {
+            return await next.handle();
+        }
+        catch (error) {
+            console.error(`❌ Error in ${context.getRequest().method} ${context.getRequest().url}:`, error);
+            // Transform error to a consistent format
+            throw {
+                statusCode: error.statusCode || 500,
+                message: error.message || "Internal server error",
+                error: error.name || "Error",
+                timestamp: new Date().toISOString(),
+            };
+        }
+    }
+}
+/**
+ * Compression Interceptor - Simulates response compression metadata
+ * @example
+ * @UseInterceptors(CompressionInterceptor)
+ * @Get()
+ * async getLargeData() {}
+ */
+export class CompressionInterceptor {
+    threshold;
+    constructor(threshold = 1024) {
+        this.threshold = threshold;
+    }
+    async intercept(context, next) {
+        const data = await next.handle();
+        const dataSize = JSON.stringify(data).length;
+        if (dataSize > this.threshold) {
+            // In a real implementation, you'd compress the data here
+            console.log(`📦 Response size: ${dataSize} bytes (compression recommended)`);
+        }
+        return data;
+    }
+}
+/**
+ * Rate Limit Interceptor - Basic rate limiting
+ * @example
+ * @UseInterceptors(new RateLimitInterceptor(100, 60000))
+ * @Post()
+ * async create() {}
+ */
+export class RateLimitInterceptor {
+    maxRequests;
+    windowMs;
+    requests = new Map();
+    constructor(maxRequests = 100, windowMs = 60000) {
+        this.maxRequests = maxRequests;
+        this.windowMs = windowMs;
+    }
+    async intercept(context, next) {
+        const request = context.getRequest();
+        const clientIp = request.headers?.get?.("x-forwarded-for") || "unknown";
+        const now = Date.now();
+        // Get or create request history for this IP
+        let history = this.requests.get(clientIp) || [];
+        // Filter out old requests outside the window
+        history = history.filter((timestamp) => now - timestamp < this.windowMs);
+        // Check if rate limit exceeded
+        if (history.length >= this.maxRequests) {
+            throw {
+                statusCode: 429,
+                message: "Too many requests",
+                error: "Rate limit exceeded",
+            };
+        }
+        // Add current request
+        history.push(now);
+        this.requests.set(clientIp, history);
+        return next.handle();
+    }
+}
+/**
+ * CORS Interceptor - Add CORS headers to responses
+ * @example
+ * @UseInterceptors(CorsInterceptor)
+ * @Controller('/api')
+ * export class ApiController {}
+ */
+export class CorsInterceptor {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async intercept(context, next) {
+        const response = context.getResponse();
+        const origin = this.options.origin || "*";
+        const methods = this.options.methods || [
+            "GET",
+            "POST",
+            "PUT",
+            "DELETE",
+            "PATCH",
+        ];
+        // Set CORS headers
+        if (response.headers) {
+            response.headers.set("Access-Control-Allow-Origin", Array.isArray(origin) ? origin[0] : origin);
+            response.headers.set("Access-Control-Allow-Methods", methods.join(", "));
+            response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+            if (this.options.credentials) {
+                response.headers.set("Access-Control-Allow-Credentials", "true");
+            }
+        }
+        return next.handle();
+    }
+}
+/**
+ * Sanitize Interceptor - Sanitizes response data
+ * @example
+ * @UseInterceptors(SanitizeInterceptor)
+ * @Get('/users')
+ * async getUsers() {}
+ */
+export class SanitizeInterceptor {
+    fieldsToRemove;
+    constructor(fieldsToRemove = ["password", "secret", "token"]) {
+        this.fieldsToRemove = fieldsToRemove;
+    }
+    async intercept(context, next) {
+        const data = await next.handle();
+        return this.sanitize(data);
+    }
+    sanitize(data) {
+        if (Array.isArray(data)) {
+            return data.map((item) => this.sanitize(item));
+        }
+        if (data && typeof data === "object") {
+            const sanitized = {};
+            for (const key in data) {
+                if (!this.fieldsToRemove.includes(key)) {
+                    sanitized[key] = this.sanitize(data[key]);
+                }
+            }
+            return sanitized;
+        }
+        return data;
+    }
+}
+/**
+ * Pagination Interceptor - Adds pagination metadata
+ * @example
+ * @UseInterceptors(PaginationInterceptor)
+ * @Get('/users')
+ * async getUsers(@Query('page') page: number, @Query('limit') limit: number) {}
+ */
+export class PaginationInterceptor {
+    async intercept(context, next) {
+        const request = context.getRequest();
+        const url = new URL(request.url, `http://${request.headers?.get?.("host")}`);
+        const page = parseInt(url.searchParams.get("page") || "1");
+        const limit = parseInt(url.searchParams.get("limit") || "10");
+        const data = await next.handle();
+        // If data is an array, add pagination
+        if (Array.isArray(data)) {
+            return {
+                items: data,
+                pagination: {
+                    page,
+                    limit,
+                    total: data.length,
+                    hasMore: data.length >= limit,
+                },
+            };
+        }
+        return data;
+    }
+}

package/dist/decorators/interceptor.decorators.d.ts

@@ -0,0 +1,91 @@
+import "reflect-metadata";
+import { ExecutionContext } from "./guard.decorators";
+/**
+ * Interceptor Decorators and Interfaces for WynkJS Framework
+ * Interceptors for request/response transformation
+ */
+/**
+ * Call handler interface for interceptors
+ */
+export interface CallHandler<T = any> {
+    handle(): Promise<T>;
+}
+/**
+ * WynkInterceptor interface - All interceptors must implement this
+ */
+export interface WynkInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Promise<any>;
+}
+/**
+ * @UseInterceptors decorator - Apply interceptors to routes or controllers
+ * @param interceptors Interceptor classes to apply
+ * @example
+ * @UseInterceptors(LoggingInterceptor, TransformInterceptor)
+ * @Controller('/users')
+ * export class UserController {}
+ *
+ * @Get()
+ * @UseInterceptors(CacheInterceptor)
+ * findAll() {}
+ */
+export declare function UseInterceptors(...interceptors: (Function | WynkInterceptor)[]): MethodDecorator & ClassDecorator;
+/**
+ * Helper function to execute interceptors
+ */
+export declare function executeInterceptors(interceptors: (Function | WynkInterceptor)[], context: ExecutionContext, handler: () => Promise<any>): Promise<any>;
+/**
+ * Common interceptor utilities
+ */
+/**
+ * Transform interceptor decorator - Wraps response in a specific structure
+ * @param transformFn Transformation function
+ * @example
+ * @UseInterceptors(TransformInterceptor)
+ * @Get()
+ * async getData() {
+ *   return { data: 'value' };
+ * }
+ * // Response: { data: { data: 'value' }, statusCode: 200 }
+ */
+export declare class TransformInterceptor implements WynkInterceptor {
+    private transformFn?;
+    constructor(transformFn?: ((data: any) => any) | undefined);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<any>;
+}
+/**
+ * Timeout interceptor - Adds timeout to requests
+ * @param timeout Timeout in milliseconds
+ * @example
+ * @UseInterceptors(new TimeoutInterceptor(5000))
+ * @Get()
+ * async getData() {}
+ */
+export declare class TimeoutInterceptor implements WynkInterceptor {
+    private timeout;
+    constructor(timeout?: number);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<any>;
+}
+/**
+ * Cache interceptor - Caches responses
+ * @example
+ * @UseInterceptors(CacheInterceptor)
+ * @Get()
+ * async getData() {}
+ */
+export declare class CacheInterceptor implements WynkInterceptor {
+    private cache;
+    private ttl;
+    constructor(ttl?: number);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<any>;
+}
+/**
+ * Logging interceptor - Logs requests and responses
+ * @example
+ * @UseInterceptors(LoggingInterceptor)
+ * @Controller()
+ * export class AppController {}
+ */
+export declare class LoggingInterceptor implements WynkInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Promise<any>;
+}
+//# sourceMappingURL=interceptor.decorators.d.ts.map

package/dist/decorators/interceptor.decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor.decorators.d.ts","sourceRoot":"","sources":["../../core/decorators/interceptor.decorators.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG;IAClC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,GAAG,YAAY,EAAE,CAAC,QAAQ,GAAG,eAAe,CAAC,EAAE,GAC9C,eAAe,GAAG,cAAc,CA4BlC;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,CAAC,QAAQ,GAAG,eAAe,CAAC,EAAE,EAC5C,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAC1B,OAAO,CAAC,GAAG,CAAC,CA+Bd;AAED;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,qBAAa,oBAAqB,YAAW,eAAe;IAC9C,OAAO,CAAC,WAAW,CAAC;gBAAZ,WAAW,CAAC,GAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,aAAA;IAE9C,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;CAa5E;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAmB,YAAW,eAAe;IAC5C,OAAO,CAAC,OAAO;gBAAP,OAAO,GAAE,MAAa;IAEpC,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;CAQ5E;AAED;;;;;;GAMG;AACH,qBAAa,gBAAiB,YAAW,eAAe;IACtD,OAAO,CAAC,KAAK,CAAuD;IACpE,OAAO,CAAC,GAAG,CAAS;gBAER,GAAG,GAAE,MAAc;IAIzB,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;CAgB5E;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,eAAe;IAClD,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;CAqB5E"}

package/dist/decorators/interceptor.decorators.js

@@ -0,0 +1,163 @@
+import "reflect-metadata";
+/**
+ * @UseInterceptors decorator - Apply interceptors to routes or controllers
+ * @param interceptors Interceptor classes to apply
+ * @example
+ * @UseInterceptors(LoggingInterceptor, TransformInterceptor)
+ * @Controller('/users')
+ * export class UserController {}
+ *
+ * @Get()
+ * @UseInterceptors(CacheInterceptor)
+ * findAll() {}
+ */
+export function UseInterceptors(...interceptors) {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey && descriptor) {
+            // Method decorator
+            const existing = Reflect.getMetadata("interceptors", target, propertyKey) || [];
+            Reflect.defineMetadata("interceptors", [...existing, ...interceptors], target, propertyKey);
+            return descriptor;
+        }
+        else {
+            // Class decorator
+            const existing = Reflect.getMetadata("interceptors", target) || [];
+            Reflect.defineMetadata("interceptors", [...existing, ...interceptors], target);
+            return target;
+        }
+    };
+}
+/**
+ * Helper function to execute interceptors
+ */
+export async function executeInterceptors(interceptors, context, handler) {
+    // Build interceptor chain from last to first
+    let next = {
+        handle: async () => handler(),
+    };
+    // Apply interceptors in reverse order
+    for (let i = interceptors.length - 1; i >= 0; i--) {
+        const interceptor = interceptors[i];
+        const currentNext = next;
+        let interceptorInstance;
+        if (typeof interceptor === "function") {
+            interceptorInstance = new interceptor();
+        }
+        else {
+            interceptorInstance = interceptor;
+        }
+        if (!interceptorInstance.intercept) {
+            throw new Error(`Interceptor must implement WynkInterceptor interface`);
+        }
+        // Create new call handler that wraps the previous one
+        next = {
+            handle: async () => {
+                return interceptorInstance.intercept(context, currentNext);
+            },
+        };
+    }
+    return next.handle();
+}
+/**
+ * Common interceptor utilities
+ */
+/**
+ * Transform interceptor decorator - Wraps response in a specific structure
+ * @param transformFn Transformation function
+ * @example
+ * @UseInterceptors(TransformInterceptor)
+ * @Get()
+ * async getData() {
+ *   return { data: 'value' };
+ * }
+ * // Response: { data: { data: 'value' }, statusCode: 200 }
+ */
+export class TransformInterceptor {
+    transformFn;
+    constructor(transformFn) {
+        this.transformFn = transformFn;
+    }
+    async intercept(context, next) {
+        const data = await next.handle();
+        if (this.transformFn) {
+            return this.transformFn(data);
+        }
+        return {
+            data,
+            statusCode: context.getResponse().status || 200,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}
+/**
+ * Timeout interceptor - Adds timeout to requests
+ * @param timeout Timeout in milliseconds
+ * @example
+ * @UseInterceptors(new TimeoutInterceptor(5000))
+ * @Get()
+ * async getData() {}
+ */
+export class TimeoutInterceptor {
+    timeout;
+    constructor(timeout = 5000) {
+        this.timeout = timeout;
+    }
+    async intercept(context, next) {
+        return Promise.race([
+            next.handle(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), this.timeout)),
+        ]);
+    }
+}
+/**
+ * Cache interceptor - Caches responses
+ * @example
+ * @UseInterceptors(CacheInterceptor)
+ * @Get()
+ * async getData() {}
+ */
+export class CacheInterceptor {
+    cache = new Map();
+    ttl;
+    constructor(ttl = 60000) {
+        this.ttl = ttl;
+    }
+    async intercept(context, next) {
+        const request = context.getRequest();
+        const cacheKey = `${request.method}:${request.url}`;
+        // Check cache
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.ttl) {
+            return cached.data;
+        }
+        // Execute handler and cache result
+        const data = await next.handle();
+        this.cache.set(cacheKey, { data, timestamp: Date.now() });
+        return data;
+    }
+}
+/**
+ * Logging interceptor - Logs requests and responses
+ * @example
+ * @UseInterceptors(LoggingInterceptor)
+ * @Controller()
+ * export class AppController {}
+ */
+export class LoggingInterceptor {
+    async intercept(context, next) {
+        const request = context.getRequest();
+        const startTime = Date.now();
+        console.log(`📥 ${request.method} ${request.url} - Started`);
+        try {
+            const data = await next.handle();
+            const duration = Date.now() - startTime;
+            console.log(`📤 ${request.method} ${request.url} - Completed in ${duration}ms`);
+            return data;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            console.log(`❌ ${request.method} ${request.url} - Failed in ${duration}ms`);
+            throw error;
+        }
+    }
+}

package/dist/decorators/param.decorators.d.ts

@@ -0,0 +1,144 @@
+import "reflect-metadata";
+/**
+ * Parameter Decorators for ElysiaJS Framework
+ * Extract data from request context
+ */
+export type ParamType = "body" | "param" | "query" | "headers" | "request" | "response" | "context" | "user" | "file" | "files";
+export interface ParamMetadata {
+    index: number;
+    type: ParamType;
+    data?: string;
+    pipes?: any[];
+}
+/**
+ * @Body decorator - Extracts request body
+ * @param property Optional property name to extract from body
+ * @param pipes Optional validation/transformation pipes
+ * @example
+ * @Post()
+ * create(@Body() dto: CreateDto) {}
+ *
+ * @Post()
+ * update(@Body('name') name: string) {}
+ */
+export declare function Body(property?: string, ...pipes: any[]): ParameterDecorator;
+/**
+ * @Param decorator - Extracts route parameters
+ * @param property Optional parameter name
+ * @param pipes Optional validation/transformation pipes
+ * @example
+ * @Get('/:id')
+ * findOne(@Param('id') id: string) {}
+ *
+ * @Get('/:id')
+ * findOne(@Param() params: any) {}
+ */
+export declare function Param(property?: string, ...pipes: any[]): ParameterDecorator;
+/**
+ * @Query decorator - Extracts query parameters
+ * @param property Optional query parameter name
+ * @param pipes Optional validation/transformation pipes
+ * @example
+ * @Get()
+ * findAll(@Query('page') page: number) {}
+ *
+ * @Get()
+ * findAll(@Query() query: QueryDto) {}
+ */
+export declare function Query(property?: string, ...pipes: any[]): ParameterDecorator;
+/**
+ * @Headers decorator - Extracts request headers
+ * @param property Optional header name
+ * @example
+ * @Get()
+ * getData(@Headers('authorization') auth: string) {}
+ *
+ * @Get()
+ * getData(@Headers() headers: any) {}
+ */
+export declare function Headers(property?: string): ParameterDecorator;
+/**
+ * @Req decorator - Injects full request object
+ * @example
+ * @Get()
+ * getData(@Req() request: Request) {}
+ */
+export declare function Req(): ParameterDecorator;
+/**
+ * @Request decorator - Alias for @Req
+ */
+export declare const Request: typeof Req;
+/**
+ * @Res decorator - Injects response object
+ * @example
+ * @Get()
+ * getData(@Res() response: Response) {}
+ */
+export declare function Res(): ParameterDecorator;
+/**
+ * @Response decorator - Alias for @Res
+ */
+export declare const Response: typeof Res;
+/**
+ * @Context decorator - Injects full Elysia context
+ * @example
+ * @Get()
+ * getData(@Context() ctx: any) {}
+ */
+export declare function Context(): ParameterDecorator;
+/**
+ * @User decorator - Extracts user from context (after authentication)
+ * @param property Optional user property to extract
+ * @example
+ * @Get('/profile')
+ * @UseGuards(AuthGuard)
+ * getProfile(@User() user: UserEntity) {}
+ *
+ * @Get('/profile')
+ * getProfile(@User('id') userId: string) {}
+ */
+export declare function User(property?: string): ParameterDecorator;
+/**
+ * @UploadedFile decorator - Extracts uploaded file
+ * @example
+ * @Post('/upload')
+ * uploadFile(@UploadedFile() file: File) {}
+ */
+export declare function UploadedFile(): ParameterDecorator;
+/**
+ * @UploadedFiles decorator - Extracts multiple uploaded files
+ * @example
+ * @Post('/upload-multiple')
+ * uploadFiles(@UploadedFiles() files: File[]) {}
+ */
+export declare function UploadedFiles(): ParameterDecorator;
+/**
+ * @Ip decorator - Extracts client IP address
+ * @example
+ * @Get()
+ * getData(@Ip() ip: string) {}
+ */
+export declare function Ip(): ParameterDecorator;
+/**
+ * @Session decorator - Extracts session data
+ * @param property Optional session property name
+ * @example
+ * @Get()
+ * getData(@Session() session: any) {}
+ *
+ * @Get()
+ * getData(@Session('userId') userId: string) {}
+ */
+export declare function Session(property?: string): ParameterDecorator;
+/**
+ * @HostParam decorator - Extracts subdomain parameters
+ * @param property Host parameter name
+ * @example
+ * @Controller({ host: ':account.example.com' })
+ * export class AccountController {
+ *   @Get()
+ *   getData(@HostParam('account') account: string) {}
+ * }
+ */
+export declare function HostParam(property: string): ParameterDecorator;
+//# sourceMappingURL=param.decorators.d.ts.map

package/dist/decorators/param.decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"param.decorators.d.ts","sourceRoot":"","sources":["../../core/decorators/param.decorators.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B;;;GAGG;AAEH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,OAAO,GACP,OAAO,GACP,SAAS,GACT,SAAS,GACT,UAAU,GACV,SAAS,GACT,MAAM,GACN,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;CACf;AA2BD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,kBAAkB,CAE3E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,kBAAkB,CAE5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,kBAAkB,CAE5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,IAAI,kBAAkB,CAExC;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,YAAM,CAAC;AAE3B;;;;;GAKG;AACH,wBAAgB,GAAG,IAAI,kBAAkB,CAExC;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,YAAM,CAAC;AAE5B;;;;;GAKG;AACH,wBAAgB,OAAO,IAAI,kBAAkB,CAE5C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,kBAAkB,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,EAAE,IAAI,kBAAkB,CAmBvC;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAmB7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAmB9D"}