@ambiten/core 1.0.0

package/dist/lib-core/bootstrap/ambitenBootstrap.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbitenBootstrapFactory = void 0;
+const config_1 = require("../../config");
+const logger_1 = require("@ambiten/logger");
+const index_1 = require("../index");
+const __1 = require("../..");
+const redis_manager_1 = require("../../redis-manager");
+const utils_1 = require("../../utils");
+const tanancy_1 = require("../../tanancy");
+const gc_1 = require("../../gc");
+const invalidateTenantCache_1 = require("../../utils/invalidateTenantCache");
+/**
+ * AmbitenBootstrap is the main entry point for initializing
+ * and managing the Ambiten application stack when you opt for the CLI.
+ * It handles MongoDB, Redis, and GraphQL setup,
+ * along with custom hooks for post-connection logic.
+ * @example
+ *
+ * ```bash
+ * npx Ambiten-core my-project
+ * cd my-project
+ * ```
+ *
+ * This will create a new Ambiten project in the 'my-project' directory.
+ * You can then customize the configuration file and start using Ambiten in your application.
+ *
+ * ---
+ *
+ * Add flags as needed:
+ *
+ * ```bash
+ * npx Ambiten init my-app --with-graphql --multi-tenant --with-redis
+ * cd my-app
+ * ```
+ * This will create a new Ambiten project with Redis caching, GraphQL support, and multi-tenancy enabled.
+ * enabling them in the configuration file.
+ *
+ * ---
+ *
+ * You can also use AmbitenBootstrap programmatically in your application:
+ * ```ts
+ * @example
+ * import { AmbitenBootstrapFactory } from '@Ambiten/core';
+ *  async function start() {
+ *   const Ambiten = await AmbitenBootstrapFactory.create();
+ *   const db = Ambiten.getMongoClient();
+ *   await db.connect();
+ *   const graphql = await Ambiten.getGraphQL();
+ *   // You can now use the GraphQL instance to generate schema or start a server
+ *   // or perform other GraphQL related operations
+ *  graphql.generateSchema();
+ *  Ambiten.getRedisClient();
+ *  }
+ * start();
+ * ```
+ *
+ *
+  * @param {string} [configFilePathOrObject] - Optional path to a custom configuration file or a config object.
+ * If not provided, it defaults to 'Ambiten.config.json'.
+ * @returns {Promise<void>} - A promise that resolves when the initialization is complete.
+ *
+ * // Now you can use Ambiten.getMongoClient(), Ambiten.getRedisClient(), etc.
+ */
+class AmbitenBootstrap {
+    config;
+    provider;
+    model;
+    schema;
+    graphql;
+    gc;
+    logger;
+    adapter;
+    onConnectHooks = [];
+    connectCallbacks = [];
+    isConnected;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    onConnect(callback) {
+        if (!this.isConnected) {
+            callback();
+            return;
+        }
+        this.connectCallbacks.push(callback);
+    }
+    /**
+     * Initializes the Ambiten application stack.
+     */
+    async initialize(configFilePathOrObject) {
+        this.config =
+            configFilePathOrObject && typeof configFilePathOrObject === 'object'
+                ? configFilePathOrObject
+                : await (0, config_1.loadAmbitenConfig)(configFilePathOrObject);
+        this.initializeLogger();
+        await this.initializeRedis();
+        await this.initializeMongoProvider();
+        this.initializeSchema();
+        await this.initializeModel();
+        await this.initializeMultiTenancy();
+        await this.initializeGraphQL();
+        await this.runOnConnectHooks();
+        await this.initializeGarbageCollector();
+    }
+    initializeLogger() {
+        const loggerConfig = this.config.logger;
+        const defaultTransportConfigs = [
+            { type: 'console', options: {} },
+            {
+                type: 'rotating-file',
+                options: {
+                    filename: './logs/ambiten.log',
+                    frequency: 'daily',
+                    compress: false,
+                    flushInterval: 1000,
+                },
+            },
+        ];
+        this.logger = (0, logger_1.setupLogger)({
+            ...loggerConfig,
+            transports: undefined,
+            transportConfigs: loggerConfig?.transportConfigs?.length
+                ? loggerConfig.transportConfigs
+                : defaultTransportConfigs,
+        });
+        this.logger.info('Logger initialized', {
+            source: 'AmbitenBootstrap',
+        });
+    }
+    async initializeRedis() {
+        if (!this.config.features?.useRedisCache || !this.config.features.redisUri) {
+            return;
+        }
+        await redis_manager_1.redis.get(this.config.features.redisUri);
+        this.getLogger().info('Redis connected', {
+            source: 'AmbitenBootstrap'
+        });
+    }
+    async initializeMongoProvider() {
+        const resolvedDbName = this.config.connection?.options?.dbName ||
+            this.config.projectName ||
+            undefined;
+        this.provider =
+            this.config.mongoClient ??
+                this.config.provider ??
+                (0, index_1.createAmbitenClientModule)({
+                    uri: this.config.connection?.uri || 'mongodb://localhost:27017',
+                    options: {
+                        dbName: resolvedDbName,
+                        ...this.config.connection?.options,
+                    },
+                });
+        await this.provider.connect();
+        (0, utils_1.configureAmbitenContext)(this.provider);
+        if (this.logger) {
+            this.getLogger().info('MongoDB connected via AmbitenClientModule', {
+                source: 'AmbitenBootstrap'
+            });
+        }
+        else {
+            console.log((0, utils_1.colorize)('MongoDB connected via AmbitenClientModule', 'blue'));
+        }
+    }
+    initializeSchema() {
+        this.schema = new index_1.Schema(typeof this.config.schema === 'object'
+            ? this.config.schema
+            : {});
+        if (this.config.schema) {
+            this.schema.registerSchema(this.config.schema);
+            this.getLogger().info('Schema registered', { source: 'AmbitenBootstrap' });
+        }
+        else {
+            this.getLogger().warn('No schema provided, using default schema', { source: 'AmbitenBootstrap' });
+        }
+    }
+    async initializeModel() {
+        const collectionName = this.config.model?.collectionName || 'default';
+        this.model = (0, utils_1.Model)({
+            collectionName,
+            schema: this.schema,
+            provider: this.provider,
+            ctx: this.config.model?.ctx,
+            collection: this.config.model?.collection,
+            gcConfig: this.config.model?.gcConfig,
+        });
+        if (this.config.model) {
+            await this.model.registerModel({
+                ...this.config.model,
+                collectionName,
+                schema: this.schema,
+                provider: this.provider,
+            });
+            if (this.logger) {
+                this.getLogger().info(`Model registered: ${collectionName}`, {
+                    source: 'AmbitenBootstrap'
+                });
+            }
+            else {
+                console.log((0, utils_1.colorize)(`Model registered: ${collectionName}`, 'blue'));
+            }
+        }
+    }
+    async initializeMultiTenancy() {
+        if (!this.config.multiTenant?.enabled)
+            return;
+        const tenants = this.config.multiTenant.tenants || {};
+        const initOptions = this.config.multiTenant.initOptions || {};
+        await (0, tanancy_1.initMultiTenancy)(tenants, initOptions);
+        this.getLogger().info('Multi-tenancy initialized', {
+            source: 'AmbitenBootstrap',
+            tenantCount: Object.keys(tenants).length,
+            lazy: initOptions.lazy ?? false,
+        });
+    }
+    async initializeGraphQL() {
+        if (!this.config.graphql?.enabled) {
+            return;
+        }
+        this.graphql = new __1.AmbitenGraphQL({
+            useRedis: this.config.features?.useRedisCache ?? false,
+            customTypeDefs: this.config.features?.typeDefs
+                ? Array.isArray(this.config.features.typeDefs)
+                    ? this.config.features.typeDefs
+                    : [this.config.features.typeDefs]
+                : [],
+            customResolvers: this.config.features?.resolvers
+                ? Array.isArray(this.config.features.resolvers)
+                    ? this.config.features.resolvers
+                    : [this.config.features.resolvers]
+                : [],
+            provider: this.provider
+        });
+        await this.graphql.generateSchema();
+        if (this.logger) {
+            this.getLogger().info('GraphQL schema generated');
+            this.getLogger().info('GraphQL initialized');
+        }
+        else {
+            console.log((0, utils_1.colorize)('GraphQL schema generated', 'blue'));
+            console.log((0, utils_1.colorize)('GraphQL initialized', 'blue'));
+        }
+    }
+    async runOnConnectHooks() {
+        for (const hook of this.onConnectHooks) {
+            await hook();
+        }
+    }
+    async initializeGarbageCollector() {
+        if (!this.config.advanced?.garbageCollector?.enabled)
+            return;
+        this.gc = new gc_1.AmbitenGC({
+            enabled: this.config.advanced.garbageCollector.enabled ?? true,
+            cron: this.config.advanced.gcCron || '0 0 * * *',
+            logResults: this.config.advanced.garbageCollector.logResults ?? true,
+            continueOnError: true
+        });
+        console.log('✅ Garbage Collector initialized');
+    }
+    async registerMultiTenancy(options) {
+        const multiTenantConfig = this.config.multiTenant;
+        const logger = this.config.logger?.logger;
+        if (!multiTenantConfig?.enabled) {
+            logger?.warn('Multi-tenancy is not enabled.', {
+                source: 'AmbitenBootstrap',
+            });
+            return;
+        }
+        const tenants = options?.tenants ?? multiTenantConfig.tenants;
+        if (!tenants || Object.keys(tenants).length === 0) {
+            logger?.warn('Multi-tenancy is enabled but no tenants were provided.', {
+                source: 'AmbitenBootstrap',
+            });
+            return;
+        }
+        await (0, tanancy_1.initMultiTenancy)(tenants, {
+            lazy: options?.lazy ?? multiTenantConfig.initOptions?.lazy ?? true,
+            config: this.config.logger,
+        });
+        logger?.info('Multi-tenancy registered successfully.', {
+            source: 'AmbitenBootstrap',
+            tenantCount: Object.keys(tenants).length,
+        });
+    }
+    async cache(key, fetcher, options = {}) {
+        if (!redis_manager_1.redis) {
+            throw new Error('Redis is not initialized');
+        }
+        return (0, utils_1.cacheWithRedis)(redis_manager_1.redis, key, fetcher, options);
+    }
+    async invalidateCache(tenantId, namespace) {
+        if (!redis_manager_1.redis) {
+            throw new Error('No Redis client available');
+        }
+        const logger = this.config.logger?.logger;
+        if (!tenantId) {
+            throw new Error('Tenant ID is required to invalidate cache');
+        }
+        logger?.info('Invalidating cache for tenant:', {
+            source: 'AmbitenBootstrap',
+            tenantId,
+            namespace: namespace
+        });
+        await (0, invalidateTenantCache_1.invalidateTenantCache)(redis_manager_1.redis, tenantId, namespace);
+    }
+    /**
+     * Returns the Redis client if Redis is enabled in the configuration.
+     */
+    async getRedisClient() {
+        if (this.config.features?.useRedisCache && this.config.features.redisUri) {
+            await redis_manager_1.redis.get(this.config.features.redisUri);
+        }
+        return redis_manager_1.redis;
+    }
+    getMongoClient() {
+        return this.provider;
+    }
+    getModel() {
+        return this.model;
+    }
+    getSchema() {
+        return this.schema;
+    }
+    getGraphQL() {
+        if (!this.graphql) {
+            throw new Error('GraphQL is not initialized.');
+        }
+        return this.graphql;
+    }
+    getGCRunner() {
+        if (!this.gc) {
+            throw new Error('Garbage Collector is not initialized.');
+        }
+        return this.gc;
+    }
+    getLogger() {
+        return this.logger;
+    }
+    async shutdown() {
+        const logger = this.config.logger?.logger;
+        if (redis_manager_1.redis.isOpen) {
+            await redis_manager_1.redis.disconnect();
+            logger?.info('🧹 Redis connection closed', {
+                source: 'AmbitenBootstrap'
+            });
+        }
+        if (this.provider) {
+            await this.provider.close();
+            logger?.log?.('info', 'MongoDB connection closed');
+        }
+        logger?.log?.('info', 'Shutdown complete');
+    }
+}
+;
+/**
+ * Factory class to create an instance of AmbitenBootstrap.
+ * This class encapsulates the logic for initializing the Ambiten application stack,
+ * including MongoDB, Multi-Tenancy, Redis, GraphQL logger etc. setup.
+ * It can be used to create a fully configured Ambiten instance
+ * with optional configuration parameters.
+ * @example
+ * const Ambiten = await AmbitenBootstrapFactory.create();
+ * const db = Ambiten.getMongoClient();
+ * await db.connect();
+ * const graphql = await Ambiten.getGraphQL();
+ * // You can now use the GraphQL instance to generate schema or start a server
+ * // or perform other GraphQL related operations
+ * graphql.generateSchema();
+ * Ambiten.getRedisClient();
+ * // or with custom config
+ * const Ambiten = await AmbitenBootstrapFactory.create(customConfig);
+ * @param {AmbitenConfig} [config] - Optional configuration object for Ambiten.
+ * @returns {Promise<AmbitenBootstrap>} - A promise that resolves to an instance of AmbitenBootstrap.
+ */
+class AmbitenBootstrapFactory {
+    static async create(options = {}) {
+        const bootstrap = new AmbitenBootstrap(options.adapter);
+        await bootstrap.initialize(options.config);
+        return bootstrap;
+    }
+}
+exports.AmbitenBootstrapFactory = AmbitenBootstrapFactory;

package/dist/lib-core/bootstrap/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ambitenBootstrap';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib-core/bootstrap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib-core/bootstrap/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/lib-core/bootstrap/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ambitenBootstrap"), exports);

package/dist/lib-core/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ambitenClient';
+export * from './ambitenModelFactory';
+export * from './ambitenSchema';
+export * from './bootstrap';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib-core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib-core/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/lib-core/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ambitenClient"), exports);
+tslib_1.__exportStar(require("./ambitenModelFactory"), exports);
+tslib_1.__exportStar(require("./ambitenSchema"), exports);
+tslib_1.__exportStar(require("./bootstrap"), exports);

package/dist/middleware/authorization/auth.d.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from "express-serve-static-core";
+declare module "express-serve-static-core" {
+    interface Request {
+        user: {
+            _id: string;
+            role: string;
+            tenantId: string;
+        };
+    }
+}
+/**
+ *  Middleware to authorize access to routes based on user roles.
+ *  This middleware checks if the request contains a valid JWT token,
+ * @param roles - An array of roles that are allowed to access the route.
+ * @returns
+ */
+export declare function authorize(roles: string[]): (req: Request, res: Response, next: NextFunction) => Response | {
+    _id: string;
+    role: string;
+    tenantId: string;
+} | undefined;
+//# sourceMappingURL=auth.d.ts.map

package/dist/middleware/authorization/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/middleware/authorization/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAI5E,OAAO,QAAQ,2BAA2B,CAAC;IAC1C,UAAU,OAAO;QAChB,IAAI,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KACtD;CACD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAChC,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY;SAWc,MAAM;UAAQ,MAAM;cAAY,MAAM;cAkB3G"}

package/dist/middleware/authorization/auth.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorize = authorize;
+const AuthUtils_1 = require("../../utils/AuthUtils");
+/**
+ *  Middleware to authorize access to routes based on user roles.
+ *  This middleware checks if the request contains a valid JWT token,
+ * @param roles - An array of roles that are allowed to access the route.
+ * @returns
+ */
+function authorize(roles) {
+    return (req, res, next) => {
+        let token;
+        const authHeader = req.headers?.authorization || req.headers.Authorization;
+        if (typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
+            token = authHeader.split(' ')[1];
+        }
+        if (!token) {
+            return res.status(401).json({ error: "Access token required" });
+        }
+        try {
+            const decoded = AuthUtils_1.AuthService.verifyToken(token);
+            console.info(`Decoded token: ${JSON.stringify(decoded)}`);
+            if (!decoded) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+            if (!roles.includes(decoded.role)) {
+                return res.status(403).json({ error: "Access Denied" });
+            }
+            return decoded;
+            next();
+        }
+        catch {
+            res.status(401).json({ error: "Unauthorized" });
+        }
+    };
+}

package/dist/middleware/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rbac/rbacMiddleware';
+export * from './rbac/rbacTypes';
+export * from './authorization/auth';
+//# sourceMappingURL=index.d.ts.map

package/dist/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/middleware/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAA"}

package/dist/middleware/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./rbac/rbacMiddleware"), exports);
+tslib_1.__exportStar(require("./rbac/rbacTypes"), exports);
+tslib_1.__exportStar(require("./authorization/auth"), exports);

package/dist/middleware/rbac/rbacMiddleware.d.ts

@@ -0,0 +1,103 @@
+import { Role, Permission } from './rbacTypes';
+declare module "express-serve-static-core" {
+    interface Request {
+        user: {
+            _id: string;
+            role: string;
+            tenantId: string;
+        };
+        isAdmin: boolean;
+        isUser: boolean;
+    }
+}
+/**
+ * Check if a user has a specific permission
+ * @param role The role of the user
+ * @param permission The permission to check
+ * @returns A promise that resolves to true if the user has the permission, false otherwise
+ * @example
+ * const hasPermission = await checkPermission('admin', 'createUser');
+ * if (hasPermission) {
+ * // User has permission to create a user
+ * } else {
+ * // User does not have permission to create a user
+ * }
+ */
+export declare function checkPermission(role: Role, permission: Permission): Promise<boolean>;
+/**
+ * Get cached data for a specific role and key
+ * @param role The role or tenant object
+ * @param key The key to retrieve from the cache
+ * @return {Promise<any>} A promise that resolves to the cached data or null if not found
+ * This function retrieves cached data from Redis based on the provided role and key.
+ * It constructs a unique cache key using the role and key, checks if the data exists in the cache,
+ * and returns the parsed data if found. If the data is not found, it logs a cache miss and returns null.
+ * @throws {Error} If there is an issue with the Redis operation
+ * @example
+ * // Get cached permissions for role 'admin'
+ * const cachedPermissions = await getCachedData('admin', 'permissions');
+ * if (cachedPermissions) {
+ *   console.log('Cached permissions:', cachedPermissions);
+ * } else {
+ *  console.log('No cached permissions found');
+ * }
+ */
+export declare function getCachedData(role: string | string[] | {
+    tenantId: string;
+}, key: string): Promise<any>;
+export declare function setCachedData(role: string | string[] | {
+    tenantId: string;
+}, key: string, data: any, ttl: number): Promise<void>;
+/**
+ * Invalidate the cache for a specific tenant and role
+ * @param tenantId The ID of the tenant
+ * @param role The role to invalidate cache for
+ * @return {Promise<void>}
+ * This function removes the cached permissions for the specified tenant and role.
+ * It is useful when permissions change and you want to ensure the cache reflects the latest state.
+ * It logs the invalidation action and deletes the cache entry from Redis.
+ * This is particularly important in multi-tenant applications where each tenant may have different permissions.
+ * @throws {Error} If there is an issue with the Redis operation
+ * @example
+ * // Invalidate cache for tenant 'tenant123' with role 'admin'
+ * await invalidateTenantCache('tenant123', 'admin');
+ */
+export declare function invalidateTenantCache(tenantId: string, role: string): Promise<void>;
+/**
+ * Middleware to enforce RBAC (Role-Based Access Control) on GraphQL resolvers
+ * @param resolver The original resolver function
+ * @param permission The required permission for the action
+ * @returns A wrapped resolver function that checks permissions
+ * @throws {Error} If the user does not have the required permission
+ * @example
+ * // Wrap a resolver with RBAC enforcement
+ * const securedResolver = enforceRBAC(originalResolver, 'createUser');
+ *
+ * // Use the secured resolver in your GraphQL schema
+ * const resolvers = {
+ *   Mutation: {
+ *     createUser: securedResolver,
+ * 	}, };
+ *
+ * In this example, the `enforceRBAC` function wraps the `originalResolver` and checks if the user has the 'createUser' permission before allowing access to the resolver. If the user lacks the required permission, an error is thrown, preventing unauthorized access.
+ * * This middleware is essential for implementing fine-grained access control in GraphQL APIs, ensuring that only authorized users can perform specific actions based on their roles and permissions.
+ * @remarks This function is designed to be used in GraphQL resolvers to enforce role-based access control (RBAC). It checks if the user has the necessary permissions before allowing access to the resolver function. If the user lacks the required permission, an error is thrown, preventing unauthorized access.
+ * * @see {@link checkPermission} for checking user permissions
+ * * @see {@link Role} and {@link Permission} for role and permission types
+ * * @see {@link rolePermissions} for the mapping of roles to permissions
+ * * @see {@link getCachedData} and {@link setCachedData} for caching permissions
+ */
+export declare function enforceRBAC(resolver: Function, permission: Permission): (parent: any, args: any, context: any, info: any) => Promise<any>;
+/**
+ * Get the RBAC action from a wrapped resolver
+ * @param resolver The wrapped resolver function
+ * @returns The RBAC action
+ */
+export declare function getRBACAction(resolver: Function): any;
+/**
+ * Get the original resolver function from a wrapped resolver
+ * @param resolver The wrapped resolver function
+ * @returns The original resolver function
+ */
+export declare function getOriginalResolver(resolver: Function): any;
+//# sourceMappingURL=rbacMiddleware.d.ts.map

package/dist/middleware/rbac/rbacMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rbacMiddleware.d.ts","sourceRoot":"","sources":["../../../src/middleware/rbac/rbacMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAmB,MAAM,aAAa,CAAC;AAmBhE,OAAO,QAAQ,2BAA2B,CAAC;IAC1C,UAAU,OAAO;QAChB,IAAI,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QACtD,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,OAAO,CAAC;KAChB;CACD;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAmC1F;AAGD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC9C,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,GAAG,CAAC,CAed;AAED,wBAAsB,aAAa,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC9C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,GAAG,EACT,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAezF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,YACtC,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,kBAsBtE;AAGD;;;;GAIG;AAEH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,OAE/C;AAGD;;;;GAIG;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,OAErD"}