win-portal-auth-sdk 1.4.1 → 1.5.1

package/dist/middleware/express.middleware.js

@@ -6,12 +6,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearAuthCache = exports.requireAuth = exports.getAuth = exports.authMiddleware = void 0;
-const client_1 = require("../client");
+const auth_service_1 = require("./shared/auth-service");
+const token_extractor_1 = require("./shared/token-extractor");
+const user_cache_1 = require("./shared/user-cache");
 // Import Express type augmentation
 require("./express.types");
-const userCache = new Map();
 /**
- * Create Express/NestJS middleware
+ * Create Express middleware
  *
  * @example
  * ```typescript
@@ -31,103 +32,29 @@ const userCache = new Map();
  * ```
  */
 function authMiddleware(config) {
-    const client = new client_1.AuthClient({
-        baseURL: config.baseURL,
-        apiKey: config.apiKey,
-        apiKeyHeader: config.apiKeyHeader,
-    });
-    const cacheTimeout = (config.cacheTimeout || 300) * 1000; // Convert to ms
-    const tokenStrategy = config.tokenStrategy || 'bearer';
-    const cookieName = config.cookieName || 'access_token';
-    const excludePaths = config.excludePaths || [];
+    const authService = new auth_service_1.AuthService(config);
     return async (req, res, next) => {
         // No type assertion needed - req already has user/token from Express.Request augmentation
         // Check if path is excluded
-        const shouldSkip = excludePaths.some((pattern) => {
-            if (typeof pattern === 'string') {
-                return req.path === pattern;
-            }
-            return pattern.test(req.path);
-        });
-        if (shouldSkip) {
+        if ((0, token_extractor_1.shouldExcludePath)(req.path, config.excludePaths)) {
             req.user = null;
             req.token = null;
             return next();
         }
-        // Extract token
-        let token = null;
-        if (config.tokenExtractor) {
-            token = config.tokenExtractor(req);
-        }
-        else if (tokenStrategy === 'bearer') {
-            const authHeader = req.headers.authorization;
-            if (authHeader && authHeader.startsWith('Bearer ')) {
-                token = authHeader.substring(7);
-            }
-        }
-        else if (tokenStrategy === 'cookie') {
-            token = req.cookies?.[cookieName] || null;
-        }
-        // No token found
-        if (!token) {
-            if (config.optional) {
-                req.user = null;
-                req.token = null;
-                return next();
-            }
-            return res.status(401).json({
-                statusCode: 401,
-                message: 'Authentication required',
-                error: 'Unauthorized',
-            });
-        }
-        try {
-            // Check cache first
-            const cached = userCache.get(token);
-            if (cached && Date.now() - cached.timestamp < cacheTimeout) {
-                req.user = cached.user;
-                req.token = token;
-                return next();
-            }
-            // Fetch user profile from API
-            client.setToken(token);
-            const user = await client.auth.profile();
-            // Update cache
-            userCache.set(token, {
-                user,
-                timestamp: Date.now(),
-            });
-            // Clean up old cache entries (simple cleanup)
-            if (userCache.size > 1000) {
-                const now = Date.now();
-                const entries = Array.from(userCache.entries());
-                for (const [key, entry] of entries) {
-                    if (now - entry.timestamp > cacheTimeout) {
-                        userCache.delete(key);
-                    }
-                }
-            }
-            // Attach user to request
-            req.user = user;
-            req.token = token;
-            next();
-        }
-        catch (error) {
-            // Clear cache on error
-            userCache.delete(token);
-            if (config.optional) {
-                req.user = null;
-                req.token = null;
-                return next();
-            }
-            const status = error.response?.status || 401;
-            const message = error.response?.data?.message || 'Authentication failed';
-            return res.status(status).json({
-                statusCode: status,
-                message,
+        // Authenticate request
+        const result = await authService.authenticate(req);
+        // Handle error
+        if (result.error) {
+            return res.status(result.error.status).json({
+                statusCode: result.error.status,
+                message: result.error.message,
                 error: 'Unauthorized',
             });
         }
+        // Attach user and token to request
+        req.user = result.user;
+        req.token = result.token;
+        next();
     };
 }
 exports.authMiddleware = authMiddleware;
@@ -176,10 +103,10 @@ exports.requireAuth = requireAuth;
  */
 function clearAuthCache(token) {
     if (token) {
-        userCache.delete(token);
+        user_cache_1.userCache.delete(token);
     }
     else {
-        userCache.clear();
+        user_cache_1.userCache.clear();
     }
 }
 exports.clearAuthCache = clearAuthCache;

package/dist/middleware/nestjs.guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nestjs.guard.d.ts","sourceRoot":"","sources":["../../src/middleware/nestjs.guard.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,gBAAgB,EAAe,MAAM,SAAS,CAAC;AAWxD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;;6BAY3C,GAAG,GAAG,QAAQ,OAAO,CAAC;;EAgEpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;;6BAYnD,GAAG,GAAG,QAAQ,OAAO,CAAC;;EAyDpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,QAMhD"}
+{"version":3,"file":"nestjs.guard.d.ts","sourceRoot":"","sources":["../../src/middleware/nestjs.guard.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAI3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;;6BAO3C,GAAG,GAAG,QAAQ,OAAO,CAAC;;EAoBpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;;6BAOnD,GAAG,GAAG,QAAQ,OAAO,CAAC;;EAepD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,QAMhD"}

package/dist/middleware/nestjs.guard.js

@@ -6,8 +6,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearNestAuthCache = exports.createOptionalAuthGuard = exports.createAuthGuard = void 0;
-const client_1 = require("../client");
-const userCache = new Map();
+const auth_service_1 = require("./shared/auth-service");
+const user_cache_1 = require("./shared/user-cache");
 /**
  * NestJS Auth Guard
  *
@@ -30,69 +30,23 @@ const userCache = new Map();
  * ```
  */
 function createAuthGuard(config) {
-    const client = new client_1.AuthClient({
-        baseURL: config.baseURL,
-        apiKey: config.apiKey,
-        apiKeyHeader: config.apiKeyHeader,
+    const authService = new auth_service_1.AuthService({
+        ...config,
+        optional: false,
     });
-    const cacheTimeout = (config.cacheTimeout || 300) * 1000;
-    const tokenStrategy = config.tokenStrategy || 'bearer';
-    const cookieName = config.cookieName || 'access_token';
     class AuthGuard {
         async canActivate(context) {
             const request = context.switchToHttp().getRequest();
-            // Extract token
-            let token = null;
-            if (config.tokenExtractor) {
-                token = config.tokenExtractor(request);
-            }
-            else if (tokenStrategy === 'bearer') {
-                const authHeader = request.headers.authorization;
-                if (authHeader && authHeader.startsWith('Bearer ')) {
-                    token = authHeader.substring(7);
-                }
-            }
-            else if (tokenStrategy === 'cookie') {
-                token = request.cookies?.[cookieName] || null;
-            }
-            if (!token) {
-                return false;
-            }
-            try {
-                // Check cache first
-                const cached = userCache.get(token);
-                if (cached && Date.now() - cached.timestamp < cacheTimeout) {
-                    request.user = cached.user;
-                    request.token = token;
-                    return true;
-                }
-                // Fetch user profile
-                client.setToken(token);
-                const user = await client.auth.profile();
-                // Update cache
-                userCache.set(token, {
-                    user,
-                    timestamp: Date.now(),
-                });
-                // Clean up old cache entries
-                if (userCache.size > 1000) {
-                    const now = Date.now();
-                    const entries = Array.from(userCache.entries());
-                    for (const [key, entry] of entries) {
-                        if (now - entry.timestamp > cacheTimeout) {
-                            userCache.delete(key);
-                        }
-                    }
-                }
-                // Attach user to request
-                request.user = user;
-                request.token = token;
-                return true;
-            }
-            catch (error) {
-                userCache.delete(token);
+            // Authenticate request
+            const result = await authService.authenticate(request);
+            // Return false if authentication failed
+            if (result.error || !result.user || !result.token) {
                 return false;
             }
+            // Attach user and token to request
+            request.user = result.user;
+            request.token = result.token;
+            return true;
         }
     }
     return AuthGuard;
@@ -112,63 +66,19 @@ exports.createAuthGuard = createAuthGuard;
  * ```
  */
 function createOptionalAuthGuard(config) {
-    const client = new client_1.AuthClient({
-        baseURL: config.baseURL,
-        apiKey: config.apiKey,
-        apiKeyHeader: config.apiKeyHeader,
+    const authService = new auth_service_1.AuthService({
+        ...config,
+        optional: true,
     });
-    const cacheTimeout = (config.cacheTimeout || 300) * 1000;
-    const tokenStrategy = config.tokenStrategy || 'bearer';
-    const cookieName = config.cookieName || 'access_token';
     class OptionalAuthGuard {
         async canActivate(context) {
             const request = context.switchToHttp().getRequest();
-            // Extract token
-            let token = null;
-            if (config.tokenExtractor) {
-                token = config.tokenExtractor(request);
-            }
-            else if (tokenStrategy === 'bearer') {
-                const authHeader = request.headers.authorization;
-                if (authHeader && authHeader.startsWith('Bearer ')) {
-                    token = authHeader.substring(7);
-                }
-            }
-            else if (tokenStrategy === 'cookie') {
-                token = request.cookies?.[cookieName] || null;
-            }
-            if (!token) {
-                request.user = null;
-                request.token = null;
-                return true; // Allow access even without token
-            }
-            try {
-                // Check cache first
-                const cached = userCache.get(token);
-                if (cached && Date.now() - cached.timestamp < cacheTimeout) {
-                    request.user = cached.user;
-                    request.token = token;
-                    return true;
-                }
-                // Fetch user profile
-                client.setToken(token);
-                const user = await client.auth.profile();
-                // Update cache
-                userCache.set(token, {
-                    user,
-                    timestamp: Date.now(),
-                });
-                // Attach user to request
-                request.user = user;
-                request.token = token;
-                return true;
-            }
-            catch (error) {
-                userCache.delete(token);
-                request.user = null;
-                request.token = null;
-                return true; // Allow access even on error
-            }
+            // Authenticate request (optional mode - always allows access)
+            const result = await authService.authenticate(request);
+            // Attach user and token to request (may be null)
+            request.user = result.user;
+            request.token = result.token;
+            return true; // Always allow access
         }
     }
     return OptionalAuthGuard;
@@ -179,10 +89,10 @@ exports.createOptionalAuthGuard = createOptionalAuthGuard;
  */
 function clearNestAuthCache(token) {
     if (token) {
-        userCache.delete(token);
+        user_cache_1.userCache.delete(token);
     }
     else {
-        userCache.clear();
+        user_cache_1.userCache.clear();
     }
 }
 exports.clearNestAuthCache = clearNestAuthCache;

package/dist/middleware/shared/auth-service.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Auth Service - Shared authentication logic for Express and NestJS
+ *
+ * Centralized authentication service to avoid code duplication
+ */
+import { AuthClient } from '../../client';
+import { User } from '../../types';
+import { MiddlewareConfig } from '../types';
+/**
+ * Authentication result
+ */
+export interface AuthResult {
+    user: User | null;
+    token: string | null;
+    error?: {
+        status: number;
+        message: string;
+    };
+}
+/**
+ * Authentication service
+ */
+export declare class AuthService {
+    private client;
+    private config;
+    constructor(config: MiddlewareConfig);
+    /**
+     * Authenticate request
+     */
+    authenticate(req: any): Promise<AuthResult>;
+    /**
+     * Get client instance (for advanced usage)
+     */
+    getClient(): AuthClient;
+}
+//# sourceMappingURL=auth-service.d.ts.map

package/dist/middleware/shared/auth-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-service.d.ts","sourceRoot":"","sources":["../../../src/middleware/shared/auth-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI5C;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE;QACN,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAmB;gBAErB,MAAM,EAAE,gBAAgB;IASpC;;OAEG;IACG,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAyEjD;;OAEG;IACH,SAAS,IAAI,UAAU;CAGxB"}

package/dist/middleware/shared/auth-service.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Auth Service - Shared authentication logic for Express and NestJS
+ *
+ * Centralized authentication service to avoid code duplication
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const client_1 = require("../../client");
+const user_cache_1 = require("./user-cache");
+const token_extractor_1 = require("./token-extractor");
+/**
+ * Authentication service
+ */
+class AuthService {
+    constructor(config) {
+        this.config = config;
+        this.client = new client_1.AuthClient({
+            baseURL: config.baseURL,
+            apiKey: config.apiKey,
+            apiKeyHeader: config.apiKeyHeader,
+        });
+    }
+    /**
+     * Authenticate request
+     */
+    async authenticate(req) {
+        // Extract token
+        const token = (0, token_extractor_1.extractToken)(req, this.config);
+        // No token found
+        if (!token) {
+            if (this.config.optional) {
+                return {
+                    user: null,
+                    token: null,
+                };
+            }
+            return {
+                user: null,
+                token: null,
+                error: {
+                    status: 401,
+                    message: 'Authentication required',
+                },
+            };
+        }
+        try {
+            const cacheTimeout = (this.config.cacheTimeout || 300) * 1000;
+            // Check cache first
+            const cachedUser = user_cache_1.userCache.get(token, cacheTimeout);
+            if (cachedUser) {
+                // Cleanup cache if needed
+                user_cache_1.userCache.cleanupIfNeeded(1000, cacheTimeout);
+                return {
+                    user: cachedUser,
+                    token,
+                };
+            }
+            // Fetch user profile from API
+            this.client.setToken(token);
+            const user = await this.client.auth.profile();
+            // Update cache
+            user_cache_1.userCache.set(token, user);
+            user_cache_1.userCache.cleanupIfNeeded(1000, cacheTimeout);
+            return {
+                user,
+                token,
+            };
+        }
+        catch (error) {
+            // Clear cache on error
+            user_cache_1.userCache.delete(token);
+            if (this.config.optional) {
+                return {
+                    user: null,
+                    token: null,
+                };
+            }
+            const status = error.response?.status || 401;
+            const message = error.response?.data?.message || 'Authentication failed';
+            return {
+                user: null,
+                token: null,
+                error: {
+                    status,
+                    message,
+                },
+            };
+        }
+    }
+    /**
+     * Get client instance (for advanced usage)
+     */
+    getClient() {
+        return this.client;
+    }
+}
+exports.AuthService = AuthService;

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

@@ -0,0 +1,7 @@
+/**
+ * Shared utilities exports
+ */
+export * from './user-cache';
+export * from './token-extractor';
+export * from './auth-service';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/middleware/shared/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC"}

package/dist/middleware/shared/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Shared utilities exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./user-cache"), exports);
+__exportStar(require("./token-extractor"), exports);
+__exportStar(require("./auth-service"), exports);

package/dist/middleware/shared/token-extractor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Token Extractor - Shared token extraction logic for Express and NestJS
+ *
+ * Centralized token extraction to avoid code duplication
+ */
+import { MiddlewareConfig } from '../types';
+/**
+ * Extract token from request
+ */
+export declare function extractToken(req: any, config: MiddlewareConfig): string | null;
+/**
+ * Check if path should be excluded
+ */
+export declare function shouldExcludePath(path: string, excludePaths?: (string | RegExp)[]): boolean;
+//# sourceMappingURL=token-extractor.d.ts.map

package/dist/middleware/shared/token-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-extractor.d.ts","sourceRoot":"","sources":["../../../src/middleware/shared/token-extractor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAqB9E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,OAAO,CAW3F"}

package/dist/middleware/shared/token-extractor.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Token Extractor - Shared token extraction logic for Express and NestJS
+ *
+ * Centralized token extraction to avoid code duplication
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldExcludePath = exports.extractToken = void 0;
+/**
+ * Extract token from request
+ */
+function extractToken(req, config) {
+    // Custom extractor takes priority
+    if (config.tokenExtractor) {
+        return config.tokenExtractor(req);
+    }
+    const tokenStrategy = config.tokenStrategy || 'bearer';
+    const cookieName = config.cookieName || 'access_token';
+    if (tokenStrategy === 'bearer') {
+        const authHeader = req.headers?.authorization || req.headers?.Authorization;
+        if (authHeader && typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
+            return authHeader.substring(7);
+        }
+    }
+    else if (tokenStrategy === 'cookie') {
+        // Support both Express (req.cookies) and NestJS (req.cookies)
+        const cookies = req.cookies || {};
+        return cookies[cookieName] || null;
+    }
+    return null;
+}
+exports.extractToken = extractToken;
+/**
+ * Check if path should be excluded
+ */
+function shouldExcludePath(path, excludePaths) {
+    if (!excludePaths || excludePaths.length === 0) {
+        return false;
+    }
+    return excludePaths.some((pattern) => {
+        if (typeof pattern === 'string') {
+            return path === pattern;
+        }
+        return pattern.test(path);
+    });
+}
+exports.shouldExcludePath = shouldExcludePath;

package/dist/middleware/shared/user-cache.d.ts

@@ -0,0 +1,51 @@
+/**
+ * User Cache - Shared cache management for Express and NestJS
+ *
+ * Centralized cache implementation to avoid code duplication
+ */
+import { User } from '../../types';
+/**
+ * Cache entry structure
+ */
+export interface CacheEntry {
+    user: User;
+    timestamp: number;
+}
+/**
+ * User cache manager
+ */
+declare class UserCacheManager {
+    private cache;
+    private defaultTimeout;
+    /**
+     * Get cached user
+     */
+    get(token: string, timeout?: number): User | null;
+    /**
+     * Set cached user
+     */
+    set(token: string, user: User): void;
+    /**
+     * Delete cached user
+     */
+    delete(token: string): void;
+    /**
+     * Clear all cache
+     */
+    clear(): void;
+    /**
+     * Clean up old entries
+     */
+    cleanup(timeout?: number): void;
+    /**
+     * Cleanup when cache size exceeds limit
+     */
+    cleanupIfNeeded(maxSize?: number, timeout?: number): void;
+    /**
+     * Get cache size
+     */
+    size(): number;
+}
+export declare const userCache: UserCacheManager;
+export {};
+//# sourceMappingURL=user-cache.d.ts.map

package/dist/middleware/shared/user-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-cache.d.ts","sourceRoot":"","sources":["../../../src/middleware/shared/user-cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,cAAM,gBAAgB;IACpB,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,cAAc,CAAsB;IAE5C;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,MAA4B,GAAG,IAAI,GAAG,IAAI;IAetE;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI;IAOpC;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI3B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,OAAO,CAAC,OAAO,GAAE,MAA4B,GAAG,IAAI;IAWpD;;OAEG;IACH,eAAe,CAAC,OAAO,GAAE,MAAa,EAAE,OAAO,GAAE,MAA4B,GAAG,IAAI;IAMpF;;OAEG;IACH,IAAI,IAAI,MAAM;CAGf;AAGD,eAAO,MAAM,SAAS,kBAAyB,CAAC"}