@designofadecade/server 4.0.0

package/dist/local/Local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Local.d.ts","sourceRoot":"","sources":["../../src/local/Local.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE5D,UAAU,wBAAwB;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IACvD,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,cAAc,EAAE;QACd,IAAI,EAAE;YACJ,MAAM,EAAE,MAAM,CAAC;YACf,IAAI,EAAE,MAAM,CAAC;SACd,CAAC;QACF,UAAU,EAAE,OAAO,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,UAAU,cAAc;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,iBAAiB,CACtB,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,cAAc,CAAC,EAC9D,OAAO,GAAE,wBAA6B;uBA+D7B,eAAe,OACf,cAAc,mBACH;YACd,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACzC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;SACjC;;CAkBR"}

package/dist/local/Local.js

@@ -0,0 +1,114 @@
+/**
+ * Local development utilities for Lambda handlers
+ *
+ * Provides utilities to run AWS Lambda handlers locally using a Node.js server.
+ * Converts HTTP requests to Lambda event format and responses back to HTTP.
+ *
+ * @class Local
+ * @example
+ * // Wrap your Lambda handler for local development
+ * import { handler } from './lambda/handler.js';
+ * import Local from '@designofadecade/local';
+ *
+ * const localHandler = Local.LambdaProxyRouter(handler, {
+ *     requestContext: { stage: 'dev' }
+ * });
+ *
+ * // Use with Node.js http server
+ * http.createServer((req, res) => {
+ *     localHandler.request(req, res);
+ * }).listen(3000);
+ */
+import Router from '../router/Router.js';
+import Routes from '../router/Routes.js';
+export default class Local {
+    /**
+     * Lambda proxy router for local development
+     *
+     * Creates a router that wraps AWS Lambda handlers and allows them to be
+     * run locally with a Node.js HTTP server. Automatically converts between
+     * HTTP requests and Lambda event format.
+     *
+     * @param {Function} LambdaHandler - AWS Lambda handler function
+     * @param {Object} options - Configuration options
+     * @param {Object} options.requestContext - Additional requestContext fields for Lambda event
+     * @param {Object} options.event - Additional event fields for Lambda event
+     * @returns {Object} Object with request method for handling HTTP requests
+     *
+     * @example
+     * const handler = Local.LambdaProxyRouter(
+     *     async (event) => {
+     *         return {
+     *             statusCode: 200,
+     *             body: JSON.stringify({ message: 'Hello!' })
+     *         };
+     *     },
+     *     { requestContext: { stage: 'local' } }
+     * );
+     */
+    static LambdaProxyRouter(LambdaHandler, options = {}) {
+        const router = new Router({
+            initRoutes: [
+                class LocalRoutes extends Routes {
+                    constructor(router) {
+                        super(router);
+                        this.addRoute('*', ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'], async (request) => {
+                            const lambdaOptions = request.lambdaOptions || {};
+                            const LambdaResponse = await LambdaHandler({
+                                rawPath: request.path,
+                                headers: request.headers,
+                                queryStringParameters: request.query,
+                                cookies: request.cookies,
+                                requestContext: {
+                                    http: {
+                                        method: request.method,
+                                        path: request.path,
+                                    },
+                                    authorizer: request.authorizer || null,
+                                    ...(lambdaOptions.requestContext || {}),
+                                },
+                                body: request.body ? JSON.stringify(request.body) : null,
+                                ...(lambdaOptions.event || {}),
+                            });
+                            let body = LambdaResponse.body || null;
+                            if (LambdaResponse.headers?.['content-type']?.includes('application/json') &&
+                                body) {
+                                try {
+                                    body = JSON.parse(body);
+                                }
+                                catch {
+                                    // Silently fail if body is not valid JSON
+                                }
+                            }
+                            // Note: Lambda cookies are handled via Set-Cookie headers, not separate cookies property
+                            return {
+                                status: LambdaResponse.statusCode,
+                                headers: LambdaResponse.headers,
+                                body: body,
+                                isBase64Encoded: LambdaResponse.isBase64Encoded || false,
+                            };
+                        });
+                    }
+                },
+            ],
+        });
+        return {
+            request: (req, res, requestOptions = {}) => {
+                return router.nodeJSRequest(req, res, {
+                    cors: true,
+                    lambdaOptions: {
+                        requestContext: {
+                            ...options.requestContext,
+                            ...requestOptions.requestContext,
+                        },
+                        event: {
+                            ...options.event,
+                            ...requestOptions.event,
+                        },
+                    },
+                });
+            },
+        };
+    }
+}
+//# sourceMappingURL=Local.js.map

package/dist/local/Local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Local.js","sourceRoot":"","sources":["../../src/local/Local.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,MAAM,MAAM,qBAAqB,CAAC;AACzC,OAAO,MAAM,MAAM,qBAAqB,CAAC;AAkCzC,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,iBAAiB,CACtB,aAA8D,EAC9D,UAAoC,EAAE;QAEtC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC;YACxB,UAAU,EAAE;gBACV,MAAM,WAAY,SAAQ,MAAM;oBAC9B,YAAY,MAAc;wBACxB,KAAK,CAAC,MAAM,CAAC,CAAC;wBAEd,IAAI,CAAC,QAAQ,CACX,GAAG,EACH,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAC5D,KAAK,EAAE,OAAsB,EAA2B,EAAE;4BACxD,MAAM,aAAa,GAChB,OAAO,CAAC,aAGP,IAAI,EAAE,CAAC;4BAEX,MAAM,cAAc,GAAmB,MAAM,aAAa,CAAC;gCACzD,OAAO,EAAE,OAAO,CAAC,IAAI;gCACrB,OAAO,EAAE,OAAO,CAAC,OAAO;gCACxB,qBAAqB,EAAE,OAAO,CAAC,KAAK;gCACpC,OAAO,EAAE,OAAO,CAAC,OAAO;gCACxB,cAAc,EAAE;oCACd,IAAI,EAAE;wCACJ,MAAM,EAAE,OAAO,CAAC,MAAM;wCACtB,IAAI,EAAE,OAAO,CAAC,IAAI;qCACnB;oCACD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI;oCACtC,GAAG,CAAC,aAAa,CAAC,cAAc,IAAI,EAAE,CAAC;iCACxC;gCACD,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI;gCACxD,GAAG,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE,CAAC;6BAC/B,CAAC,CAAC;4BAEH,IAAI,IAAI,GAAG,cAAc,CAAC,IAAI,IAAI,IAAI,CAAC;4BACvC,IACE,cAAc,CAAC,OAAO,EAAE,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,kBAAkB,CAAC;gCACtE,IAAI,EACJ,CAAC;gCACD,IAAI,CAAC;oCACH,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gCAC1B,CAAC;gCAAC,MAAM,CAAC;oCACP,0CAA0C;gCAC5C,CAAC;4BACH,CAAC;4BAED,yFAAyF;4BACzF,OAAO;gCACL,MAAM,EAAE,cAAc,CAAC,UAAU;gCACjC,OAAO,EAAE,cAAc,CAAC,OAAO;gCAC/B,IAAI,EAAE,IAAI;gCACV,eAAe,EAAE,cAAc,CAAC,eAAe,IAAI,KAAK;6BACzD,CAAC;wBACJ,CAAC,CACF,CAAC;oBACJ,CAAC;iBACF;aACF;SACF,CAAC,CAAC;QAEH,OAAO;YACL,OAAO,EAAE,CACP,GAAoB,EACpB,GAAmB,EACnB,iBAGI,EAAE,EACN,EAAE;gBACF,OAAO,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE;oBACpC,IAAI,EAAE,IAAI;oBACV,aAAa,EAAE;wBACb,cAAc,EAAE;4BACd,GAAG,OAAO,CAAC,cAAc;4BACzB,GAAG,cAAc,CAAC,cAAc;yBACjC;wBACD,KAAK,EAAE;4BACL,GAAG,OAAO,CAAC,KAAK;4BAChB,GAAG,cAAc,CAAC,KAAK;yBACxB;qBACF;iBACF,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC;CACF"}

package/dist/logger/Logger.d.ts

@@ -0,0 +1,365 @@
+/**
+ * Structured logger for AWS Lambda with CloudWatch Logs
+ *
+ * @module Logger
+ * @description Provides JSON-formatted logging for better CloudWatch Insights queries
+ * with configurable log levels and structured context support. Automatically captures
+ * AWS Lambda request IDs and properly serializes Error objects.
+ *
+ * Best Practices for CloudWatch Alarms:
+ * - Add a `code` field to log entries (e.g., 'DB_CONNECTION_ERROR') for alarm filtering
+ * - Add a `source` field to track where logs originated (e.g., 'UserService.login')
+ * - Use consistent error codes across your application
+ * - Create CloudWatch metric filters based on specific codes
+ *
+ * Features:
+ * ✅ JSON-formatted logs for CloudWatch Insights
+ * ✅ Automatic error serialization (message, name, stack)
+ * ✅ AWS Lambda context (request ID, X-Ray trace ID, function name, version)
+ * ✅ Environment metadata (stage/environment tracking)
+ * ✅ Cold start detection (Lambda performance monitoring)
+ * ✅ Sensitive data redaction (passwords, tokens, API keys, etc.)
+ * ✅ Performance timing helpers (duration tracking)
+ * ✅ Error codes for alarm creation
+ * ✅ Source tracking for debugging
+ *
+ * @example
+ * import { logger } from './Logger';
+ *
+ * logger.info('User action completed', {
+ *   source: 'UserController.login',
+ *   userId: '123',
+ *   action: 'login'
+ * });
+ *
+ * // Error objects are automatically serialized with message, name, and stack
+ * // Use 'code' field for CloudWatch alarms
+ * try {
+ *   await riskyOperation();
+ * } catch (err) {
+ *   logger.error('Operation failed', {
+ *     code: 'PAYMENT_PROCESSING_ERROR', // For CloudWatch alarm filtering
+ *     source: 'PaymentService.processPayment', // For debugging
+ *     error: err
+ *   });
+ * }
+ *
+ * // Performance timing
+ * const timer = logger.startTimer();
+ * await expensiveOperation();
+ * timer.end('expensiveOperation', { source: 'MyService.process' });
+ *
+ * // Sensitive data is automatically redacted
+ * logger.info('User logged in', {
+ *   username: 'john',
+ *   password: 'secret123' // Automatically redacted as [REDACTED]
+ * });
+ */
+/**
+ * Log level enumeration
+ * Lower values indicate higher priority
+ *
+ * Log Level Guidelines:
+ *
+ * ERROR (0) - Critical failures requiring immediate attention
+ * - Application crashes or unrecoverable errors
+ * - Failed database connections or critical service failures
+ * - Data corruption or loss scenarios
+ * - Security violations or authentication failures
+ * - Use when: The application cannot continue normal operation
+ *
+ * WARN (1) - Potentially harmful situations that don't stop execution
+ * - Deprecated API usage or configuration issues
+ * - Rate limiting being approached
+ * - Retryable failures (e.g., temporary network issues)
+ * - Resource constraints (low memory, disk space)
+ * - Use when: Something unexpected happened but the app can continue
+ *
+ * INFO (2) - Informational messages highlighting application progress
+ * - Application startup/shutdown events
+ * - Successful business operations (user login, order placed)
+ * - Configuration loaded successfully
+ * - API request/response summaries
+ * - Use when: Tracking normal application flow and important milestones
+ *
+ * DEBUG (3) - Detailed diagnostic information for troubleshooting
+ * - Variable values and state changes
+ * - Cache hits/misses
+ * - Detailed request/response payloads
+ * - Function entry/exit points
+ * - Use when: Debugging issues in development or production
+ */
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+/**
+ * String representations of log levels
+ */
+export type LogLevelString = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
+/**
+ * Context object that can be attached to log entries
+ */
+export type LogContext = Record<string, unknown>;
+/**
+ * Structured logger class for AWS Lambda with CloudWatch Logs integration
+ *
+ * @class Logger
+ * @description Outputs JSON-formatted logs for optimal CloudWatch Insights querying.
+ * Log level can be configured via LOG_LEVEL environment variable.
+ *
+ * @example
+ * const logger = new Logger();
+ * logger.info('Processing started', { requestId: '12345' });
+ * logger.error('Failed to process', { error: 'Connection timeout', retries: 3 });
+ */
+export declare class Logger {
+    private readonly level;
+    private readonly sensitiveKeys;
+    private isColdStart;
+    private readonly maxLogSize;
+    /**
+     * Creates a new Logger instance
+     * Reads LOG_LEVEL from environment variable (defaults to INFO)
+     */
+    constructor();
+    /**
+     * Determines if a message at the given level should be logged
+     *
+     * @param level - The log level to check
+     * @returns True if the message should be logged
+     * @private
+     */
+    private shouldLog;
+    /**
+     * Serializes an Error object for CloudWatch
+     * Extracts message, name, and stack trace for better CloudWatch Insights queries
+     *
+     * @param error - The error to serialize
+     * @returns Serialized error object
+     * @private
+     */
+    private serializeError;
+    /**
+     * Redacts sensitive data from log context for security/compliance
+     * Handles circular references and prevents infinite recursion
+     *
+     * @param obj - The object to redact
+     * @param seen - WeakSet to track visited objects (prevents circular references)
+     * @param depth - Current recursion depth (prevents stack overflow)
+     * @returns Redacted object
+     * @private
+     */
+    private redactSensitiveData;
+    /**
+     * Processes context to handle special types (Errors) for CloudWatch compatibility
+     *
+     * @param context - The context object to process
+     * @returns Processed context
+     * @private
+     */
+    private processContext;
+    /**
+     * Safely stringifies an object, handling BigInt, circular refs, and other edge cases
+     *
+     * @param obj - The object to stringify
+     * @returns JSON string
+     * @private
+     */
+    private safeStringify;
+    /**
+     * Outputs a structured log entry to stdout optimized for CloudWatch Logs
+     * Handles CloudWatch's 256KB log size limit
+     *
+     * @param level - The log level string
+     * @param message - The log message
+     * @param context - Additional context data to include in the log entry
+     * @private
+     */
+    private log;
+    /**
+     * Logs an error message
+     *
+     * @param message - The error message
+     * @param context - Additional context data (error details, stack traces, etc.)
+     *
+     * @example
+     * // Pass Error objects directly - they'll be serialized automatically
+     * try {
+     *   await connectToDatabase();
+     * } catch (err) {
+     *   logger.error('Database connection failed', {
+     *     code: 'DB_CONNECTION_ERROR', // For CloudWatch alarms
+     *     source: 'DatabaseService.connect', // Track where error occurred
+     *     error: err, // Error object is automatically serialized
+     *     database: 'users',
+     *     retry: 3
+     *   });
+     * }
+     *
+     * @example
+     * // CloudWatch Alarm can filter on code field:
+     * // fields @timestamp, message, code
+     * // | filter code = "DB_CONNECTION_ERROR"
+     */
+    error(message: string, context?: LogContext): void;
+    /**
+     * Logs a warning message
+     *
+     * @param message - The warning message
+     * @param context - Additional context data
+     *
+     * @example
+     * logger.warn('Rate limit approaching', {
+     *   code: 'RATE_LIMIT_WARNING',
+     *   source: 'ApiGateway.checkRateLimit',
+     *   current: 95,
+     *   limit: 100,
+     *   timeWindow: '1m'
+     * });
+     */
+    warn(message: string, context?: LogContext): void;
+    /**
+     * Logs an informational message
+     *
+     * @param message - The info message
+     * @param context - Additional context data
+     *
+     * @example
+     * logger.info('Request processed successfully', {
+     *   source: 'ApiHandler.processRequest',
+     *   requestId: 'req-123',
+     *   duration: 245,
+     *   statusCode: 200
+     * });
+     */
+    info(message: string, context?: LogContext): void;
+    /**
+     * Logs a debug message
+     *
+     * @param message - The debug message
+     * @param context - Additional context data
+     *
+     * @example
+     * logger.debug('Cache lookup', {
+     *   key: 'user:123',
+     *   hit: true,
+     *   ttl: 3600
+     * });
+     */
+    debug(message: string, context?: LogContext): void;
+    /**
+     * Gets the current log level
+     *
+     * @returns The current log level
+     */
+    getLevel(): LogLevel;
+    /**
+     * Gets the current log level as a string
+     *
+     * @returns The current log level string
+     */
+    getLevelString(): LogLevelString;
+    /**
+     * Logs operation performance metrics
+     * Helper method for tracking duration of operations
+     *
+     * @param operation - Name of the operation
+     * @param durationMs - Duration in milliseconds
+     * @param context - Additional context data
+     *
+     * @example
+     * const start = Date.now();
+     * await processPayment();
+     * logger.performance('processPayment', Date.now() - start, {
+     *   source: 'PaymentService.process',
+     *   paymentId: '12345',
+     *   amount: 99.99
+     * });
+     *
+     * @example
+     * // CloudWatch Insights - Track slow operations:
+     * // fields @timestamp, message, duration, source
+     * // | filter duration > 1000
+     * // | sort duration desc
+     */
+    performance(operation: string, durationMs: number, context?: LogContext): void;
+    /**
+     * Creates a performance timing wrapper
+     * Returns start function that returns end function for measuring duration
+     *
+     * @returns Object with start method that returns end method
+     *
+     * @example
+     * const timer = logger.startTimer();
+     * await someAsyncOperation();
+     * timer.end('someAsyncOperation', { source: 'MyService.method', userId: '123' });
+     */
+    startTimer(): {
+        /**
+         * Ends the timer and logs performance
+         * @param operation - Name of the operation
+         * @param context - Additional context
+         */
+        end: (operation: string, context?: LogContext) => void;
+    };
+}
+/**
+ * Singleton logger instance
+ * Use this for all logging throughout the application
+ *
+ * Environment Variables:
+ * - LOG_LEVEL: Set log level (ERROR, WARN, INFO, DEBUG) - defaults to INFO
+ * - ENVIRONMENT or STAGE: Environment name (dev/staging/prod) - auto-included in logs
+ * - AWS_REQUEST_ID: Lambda request ID - auto-captured
+ * - _X_AMZN_TRACE_ID: X-Ray trace ID - auto-captured
+ * - AWS_LAMBDA_FUNCTION_NAME: Function name - auto-captured
+ * - AWS_LAMBDA_FUNCTION_VERSION: Function version - auto-captured
+ *
+ * @example
+ * import { logger } from './Logger';
+ *
+ * logger.info('Application started', { source: 'App.main' });
+ *
+ * logger.error('Failed to load config', {
+ *   code: 'CONFIG_LOAD_ERROR',
+ *   source: 'ConfigService.load',
+ *   error: err
+ * });
+ *
+ * // Performance tracking
+ * const timer = logger.startTimer();
+ * await processData();
+ * timer.end('processData', { source: 'DataProcessor.process', recordCount: 100 });
+ *
+ * // CloudWatch Insights query examples:
+ *
+ * // Find specific error codes:
+ * // fields @timestamp, message, code, source
+ * // | filter code = "DB_CONNECTION_ERROR"
+ * // | sort @timestamp desc
+ *
+ * // Track errors by source:
+ * // fields @timestamp, message, source
+ * // | filter source like /UserService/
+ * // | stats count() by source
+ *
+ * // Monitor cold starts:
+ * // fields @timestamp, message, coldStart, duration
+ * // | filter coldStart = true
+ * // | stats count() as coldStartCount
+ *
+ * // Track slow operations:
+ * // fields @timestamp, message, duration, source
+ * // | filter duration > 1000
+ * // | sort duration desc
+ * // | limit 20
+ */
+export declare const logger: Logger;
+/**
+ * Default export for convenience
+ */
+export default logger;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/logger/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../src/logger/Logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAoCjD;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IAEjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CA0B5B;IACF,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IAErC;;;OAGG;;IAMH;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAIjB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAQtB;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAsD3B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAkBtB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAkBrB;;;;;;;;OAQG;IACH,OAAO,CAAC,GAAG;IA+EX;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI;IAMlD;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI;IAMjD;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI;IAMjD;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI;IAMlD;;;;OAIG;IACH,QAAQ,IAAI,QAAQ;IAIpB;;;;OAIG;IACH,cAAc,IAAI,cAAc;IAKhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI;IAO9E;;;;;;;;;;OAUG;IACH,UAAU;QAGN;;;;WAIG;yBACc,MAAM,YAAY,UAAU;;CAKlD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,MAAM,QAAe,CAAC;AAEnC;;GAEG;AACH,eAAe,MAAM,CAAC"}