@hazeljs/serverless 0.2.0-alpha.1

package/dist/adapters.test.js

@@ -0,0 +1,432 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    HazelApp: jest.fn(),
+    Container: { getInstance: jest.fn().mockReturnValue({}) },
+    Injectable: () => () => undefined,
+    HazelModule: () => () => undefined,
+    Type: null,
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const core_1 = require("@hazeljs/core");
+const lambda_adapter_1 = require("./lambda.adapter");
+const cloud_function_adapter_1 = require("./cloud-function.adapter");
+const cold_start_optimizer_1 = require("./cold-start.optimizer");
+const serverless_decorator_1 = require("./serverless.decorator");
+class MockModule {
+}
+function makeEvent(overrides = {}) {
+    return {
+        httpMethod: 'GET',
+        path: '/test',
+        headers: {},
+        queryStringParameters: null,
+        body: null,
+        isBase64Encoded: false,
+        ...overrides,
+    };
+}
+function makeContext(overrides = {}) {
+    return {
+        awsRequestId: 'req-123',
+        invokedFunctionArn: 'arn:aws:lambda:us-east-1:000:function:test',
+        functionName: 'test-fn',
+        functionVersion: '$LATEST',
+        logGroupName: '/aws/lambda/test',
+        logStreamName: '2024/01/01/test',
+        memoryLimitInMB: '512',
+        getRemainingTimeInMillis: () => 30000,
+        done: jest.fn(),
+        fail: jest.fn(),
+        succeed: jest.fn(),
+        callbackWaitsForEmptyEventLoop: true,
+        ...overrides,
+    };
+}
+describe('LambdaAdapter', () => {
+    let mockMatch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockMatch = jest.fn().mockResolvedValue(null);
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: mockMatch }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    describe('createHandler() – cold start tracking', () => {
+        it('isCold() is true before first call', () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            expect(adapter.isCold()).toBe(true);
+        });
+        it('isCold() becomes false after first handler call', async () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            await adapter.createHandler()(makeEvent(), makeContext());
+            expect(adapter.isCold()).toBe(false);
+        });
+        it('getApp() is undefined before handler is called', () => {
+            expect(new lambda_adapter_1.LambdaAdapter(MockModule).getApp()).toBeUndefined();
+        });
+        it('getApp() returns HazelApp after first call', async () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            await adapter.createHandler()(makeEvent(), makeContext());
+            expect(adapter.getApp()).toBeDefined();
+        });
+    });
+    describe('createHandler() – routing', () => {
+        it('returns 404 when route is not found', async () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            const result = await adapter.createHandler()(makeEvent({ path: '/missing' }), makeContext());
+            expect(result.statusCode).toBe(404);
+            expect(JSON.parse(result.body)).toMatchObject({ message: 'Route not found' });
+        });
+        it('calls matched route handler and returns json response', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => res.json({ ok: true }),
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(200);
+            expect(JSON.parse(result.body)).toEqual({ ok: true });
+        });
+        it('uses returned value from handler when res methods are not called', async () => {
+            mockMatch.mockResolvedValue({ handler: async () => ({ direct: 'return' }) });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(JSON.parse(result.body)).toEqual({ direct: 'return' });
+        });
+        it('respects res.status() code', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => res.status(201).json({ created: true }),
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST' }), makeContext());
+            expect(result.statusCode).toBe(201);
+        });
+        it('returns string body from res.send()', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => res.send('plain text'),
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.body).toBe('plain text');
+        });
+        it('supports res.setHeader()', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => {
+                    res.setHeader('X-Custom', 'value');
+                    res.json({});
+                },
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.headers?.['X-Custom']).toBe('value');
+        });
+        it('returns error statusCode from thrown error with statusCode property', async () => {
+            const err = Object.assign(new Error('Forbidden'), { statusCode: 403 });
+            mockMatch.mockRejectedValue(err);
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(403);
+        });
+        it('returns 500 when route handler throws without statusCode', async () => {
+            mockMatch.mockRejectedValue(new Error('Unexpected'));
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(500);
+        });
+        it('returns base64 body and isBase64Encoded when binaryMimeTypes matches and handler sends Buffer', async () => {
+            const binaryPayload = Buffer.from('fake-png-bytes');
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => {
+                    res.setHeader('Content-Type', 'image/png');
+                    res.send(binaryPayload);
+                },
+            });
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule, {
+                binaryMimeTypes: ['image/png', 'image/*'],
+            });
+            const result = await adapter.createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(200);
+            expect(result.isBase64Encoded).toBe(true);
+            expect(Buffer.from(result.body, 'base64').toString()).toBe('fake-png-bytes');
+        });
+    });
+    describe('createHandler() – request conversion', () => {
+        it('parses JSON body', async () => {
+            let capturedBody;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedBody = req.body;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST', body: '{"key":"val"}' }), makeContext());
+            expect(capturedBody).toEqual({ key: 'val' });
+        });
+        it('parses base64-encoded JSON body', async () => {
+            let capturedBody;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedBody = req.body;
+                    res.json({});
+                },
+            });
+            const b64 = Buffer.from(JSON.stringify({ encoded: true })).toString('base64');
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST', body: b64, isBase64Encoded: true }), makeContext());
+            expect(capturedBody).toEqual({ encoded: true });
+        });
+        it('returns raw string body when JSON parse fails', async () => {
+            let capturedBody;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedBody = req.body;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST', body: 'not-valid-json' }), makeContext());
+            expect(capturedBody).toBe('not-valid-json');
+        });
+        it('passes query string parameters to handler', async () => {
+            let capturedQuery;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedQuery = req.query;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ queryStringParameters: { page: '2', size: '10' } }), makeContext());
+            expect(capturedQuery).toEqual({ page: '2', size: '10' });
+        });
+        it('passes pathParameters to handler', async () => {
+            let capturedParams;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedParams = req.params;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ pathParameters: { id: '42' } }), makeContext());
+            expect(capturedParams).toEqual({ id: '42' });
+        });
+    });
+    describe('createHandler() – initialization errors', () => {
+        it('returns 500 when HazelApp constructor throws', async () => {
+            core_1.HazelApp.mockImplementationOnce(() => {
+                throw new Error('Module init failed');
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(500);
+            expect(JSON.parse(result.body).message).toBe('Module init failed');
+        });
+    });
+    describe('createHandler() – app reuse', () => {
+        it('creates HazelApp only once across multiple calls', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, res) => res.json({}),
+            });
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            const handler = adapter.createHandler();
+            await handler(makeEvent(), makeContext());
+            await handler(makeEvent(), makeContext());
+            expect(core_1.HazelApp).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('cold start optimization', () => {
+        it('calls warmUp when module has @Serverless coldStartOptimization:true', async () => {
+            let OptimizedModule = class OptimizedModule {
+            };
+            OptimizedModule = __decorate([
+                (0, serverless_decorator_1.Serverless)({ coldStartOptimization: true })
+            ], OptimizedModule);
+            mockMatch.mockResolvedValue({
+                handler: async (_r, res) => res.json({}),
+            });
+            const adapter = new lambda_adapter_1.LambdaAdapter(OptimizedModule);
+            await adapter.createHandler()(makeEvent(), makeContext());
+            expect(core_1.HazelApp).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+describe('createLambdaHandler()', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: jest.fn().mockResolvedValue(null) }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    it('returns a callable handler that produces a ServerlessResponse', async () => {
+        const handler = (0, lambda_adapter_1.createLambdaHandler)(MockModule);
+        const result = await handler(makeEvent(), makeContext());
+        expect(result).toHaveProperty('statusCode');
+        expect(result).toHaveProperty('body');
+    });
+});
+// ─── CloudFunctionAdapter ────────────────────────────────────────────────────
+function makeCloudReq(overrides = {}) {
+    return {
+        method: 'GET',
+        url: '/test',
+        path: '/test',
+        headers: { 'content-type': 'application/json' },
+        query: {},
+        ...overrides,
+    };
+}
+function makeCloudRes() {
+    const captures = {
+        headers: {},
+    };
+    const res = {
+        _captures: captures,
+        status: jest.fn().mockReturnThis(),
+        set: jest.fn().mockReturnThis(),
+        send: jest.fn().mockImplementation((b) => {
+            captures.body = b;
+        }),
+        json: jest.fn().mockImplementation((b) => {
+            captures.body = b;
+        }),
+        end: jest.fn(),
+    };
+    return res;
+}
+describe('CloudFunctionAdapter', () => {
+    let mockMatch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockMatch = jest.fn().mockResolvedValue(null);
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: mockMatch }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    describe('createHttpHandler()', () => {
+        it('calls res.status(404) when route not found', async () => {
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.status).toHaveBeenCalledWith(404);
+            expect(res.send).toHaveBeenCalled();
+        });
+        it('calls matched route and sends response', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, synRes) => synRes.json({ ok: true }),
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.send).toHaveBeenCalled();
+        });
+        it('calls res.status(500).json() on handler init error', async () => {
+            core_1.HazelApp.mockImplementationOnce(() => {
+                throw new Error('crash');
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.status).toHaveBeenCalledWith(500);
+            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ error: 'Internal Server Error' }));
+        });
+        it('normalizes string[] headers to first value', async () => {
+            let capturedHeaders;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedHeaders = req.headers;
+                    res.json({});
+                },
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq({ headers: { 'x-multi': ['alpha', 'beta'] } }), res);
+            expect(capturedHeaders?.['x-multi']).toBe('alpha');
+        });
+        it('normalizes string[] query params to first value', async () => {
+            let capturedQuery;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedQuery = req.query;
+                    res.json({});
+                },
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq({ query: { tag: ['first', 'second'] } }), res);
+            expect(capturedQuery?.tag).toBe('first');
+        });
+        it('sets headers on response from internal ServerlessResponse headers', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, synRes) => {
+                    synRes.setHeader('X-Trace', 'abc');
+                    synRes.json({});
+                },
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.set).toHaveBeenCalledWith('X-Trace', 'abc');
+        });
+        it('isCold() becomes false after first call', async () => {
+            const adapter = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule);
+            expect(adapter.isCold()).toBe(true);
+            const res = makeCloudRes();
+            await adapter.createHttpHandler()(makeCloudReq(), res);
+            expect(adapter.isCold()).toBe(false);
+        });
+        it('getApp() returns undefined before first call', () => {
+            expect(new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).getApp()).toBeUndefined();
+        });
+        it('creates HazelApp only once across multiple calls', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, res) => res.json({}),
+            });
+            const adapter = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule);
+            const handler = adapter.createHttpHandler();
+            const res1 = makeCloudRes();
+            const res2 = makeCloudRes();
+            await handler(makeCloudReq(), res1);
+            await handler(makeCloudReq(), res2);
+            expect(core_1.HazelApp).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('createEventHandler()', () => {
+        it('resolves without error for a valid event', async () => {
+            const handler = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createEventHandler();
+            await expect(handler({ data: 'payload' }, { eventType: 'pubsub', resource: 'projects/test' })).resolves.toBeUndefined();
+        });
+        it('rethrows errors from initialization', async () => {
+            core_1.HazelApp.mockImplementationOnce(() => {
+                throw new Error('init failed');
+            });
+            const handler = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createEventHandler();
+            await expect(handler({}, {})).rejects.toThrow('init failed');
+        });
+        it('isCold() becomes false after first event call', async () => {
+            const adapter = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule);
+            await adapter.createEventHandler()({}, {});
+            expect(adapter.isCold()).toBe(false);
+        });
+    });
+});
+describe('createCloudFunctionHandler()', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: jest.fn().mockResolvedValue(null) }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    it('returns a callable HTTP handler', async () => {
+        const handler = (0, cloud_function_adapter_1.createCloudFunctionHandler)(MockModule);
+        const res = makeCloudRes();
+        await handler(makeCloudReq(), res);
+        expect(res.send).toHaveBeenCalled();
+    });
+});
+describe('createCloudFunctionEventHandler()', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: jest.fn() }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    it('returns a callable event handler', async () => {
+        const handler = (0, cloud_function_adapter_1.createCloudFunctionEventHandler)(MockModule);
+        await expect(handler({ data: 'test' }, {})).resolves.toBeUndefined();
+    });
+});

package/dist/cloud-function.adapter.d.ts

@@ -0,0 +1,109 @@
+import { HazelApp } from '@hazeljs/core';
+import { Type } from '@hazeljs/core';
+/**
+ * Google Cloud Function Request
+ */
+export interface CloudFunctionRequest {
+    method: string;
+    url: string;
+    path: string;
+    headers: Record<string, string | string[]>;
+    query: Record<string, string | string[]>;
+    body?: unknown;
+    rawBody?: Buffer;
+}
+/**
+ * Google Cloud Function Response
+ */
+export interface CloudFunctionResponse {
+    status(code: number): CloudFunctionResponse;
+    set(field: string, value: string): CloudFunctionResponse;
+    send(body: unknown): void;
+    json(body: unknown): void;
+    end(): void;
+}
+/**
+ * Options for createCloudFunctionHandler
+ */
+export interface CloudFunctionHandlerOptions {
+    /** Called after the HazelJS app is initialized. */
+    onInit?: (app: HazelApp) => Promise<void>;
+    /** Called when the handler throws. */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Cloud Function adapter for HazelJS
+ */
+export declare class CloudFunctionAdapter {
+    private moduleClass;
+    private options;
+    private app?;
+    private optimizer;
+    private isColdStart;
+    constructor(moduleClass: Type<unknown>, options?: CloudFunctionHandlerOptions);
+    /**
+     * Initialize the HazelJS application
+     */
+    private initialize;
+    /**
+     * Create Cloud Function HTTP handler
+     */
+    createHttpHandler(): (req: CloudFunctionRequest, res: CloudFunctionResponse) => Promise<void>;
+    /**
+     * Create Cloud Function event handler (for Pub/Sub, Storage, etc.).
+     * Stub: initializes the app and logs the event but does not route to user-defined handlers.
+     * Implement custom event handling in your module or a separate entrypoint and invoke it from here.
+     */
+    createEventHandler(): (event: unknown, context: unknown) => Promise<void>;
+    /**
+     * Convert Cloud Function request to internal format
+     */
+    private convertCloudFunctionRequest;
+    /**
+     * Normalize headers (convert string[] to string)
+     */
+    private normalizeHeaders;
+    /**
+     * Normalize query parameters
+     */
+    private normalizeQuery;
+    /**
+     * Process request through HazelJS router
+     */
+    private processRequest;
+    /**
+     * Get application instance
+     */
+    getApp(): HazelApp | undefined;
+    /**
+     * Check if this is a cold start
+     */
+    isCold(): boolean;
+}
+/**
+ * Create a Cloud Function HTTP handler for a HazelJS module
+ *
+ * @example
+ * ```typescript
+ * // index.ts
+ * import { createCloudFunctionHandler } from '@hazeljs/core';
+ * import { AppModule } from './app.module';
+ *
+ * export const handler = createCloudFunctionHandler(AppModule);
+ * ```
+ */
+export declare function createCloudFunctionHandler(moduleClass: Type<unknown>, options?: CloudFunctionHandlerOptions): (req: CloudFunctionRequest, res: CloudFunctionResponse) => Promise<void>;
+/**
+ * Create a Cloud Function event handler for a HazelJS module
+ *
+ * @example
+ * ```typescript
+ * // index.ts
+ * import { createCloudFunctionEventHandler } from '@hazeljs/core';
+ * import { AppModule } from './app.module';
+ *
+ * export const handler = createCloudFunctionEventHandler(AppModule);
+ * ```
+ */
+export declare function createCloudFunctionEventHandler(moduleClass: Type<unknown>, options?: CloudFunctionHandlerOptions): (event: unknown, context: unknown) => Promise<void>;
+//# sourceMappingURL=cloud-function.adapter.d.ts.map

package/dist/cloud-function.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-function.adapter.d.ts","sourceRoot":"","sources":["../src/cloud-function.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKrC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACzC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAAC;IAC5C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAC;IACzD,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,GAAG,IAAI,IAAI,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,mDAAmD;IACnD,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,sCAAsC;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,OAAO;IANjB,OAAO,CAAC,GAAG,CAAC,CAAW;IACvB,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,WAAW,CAAQ;gBAGjB,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,GAAE,2BAAgC;IAKnD;;OAEG;YACW,UAAU;IAyBxB;;OAEG;IACH,iBAAiB,KACD,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,KAAG,OAAO,CAAC,IAAI,CAAC;IAsCrF;;;;OAIG;IACH,kBAAkB,KACF,OAAO,OAAO,EAAE,SAAS,OAAO,KAAG,OAAO,CAAC,IAAI,CAAC;IA0BhE;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAoBnC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;YACW,cAAc;IA+G5B;;OAEG;IACH,MAAM,IAAI,QAAQ,GAAG,SAAS;IAI9B;;OAEG;IACH,MAAM,IAAI,OAAO;CAGlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,2BAA2B,GACpC,CAAC,GAAG,EAAE,oBAAoB,EAAE,GAAG,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAG1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,2BAA2B,GACpC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAGrD"}