prostgles-server 2.0.178 → 2.0.179

package/lib/AuthHandler.d.ts

@@ -0,0 +1,148 @@
+import { AnyObject } from "prostgles-types";
+import { LocalParams, PRGLIOSocket } from "./DboBuilder";
+import { DBOFullyTyped } from "./DBSchemaBuilder";
+import { DB, DBHandlerServer, Prostgles } from "./Prostgles";
+declare type Awaitable<T> = T | Promise<T>;
+declare type AuthSocketSchema = {
+    user?: AnyObject;
+    register?: boolean;
+    login?: boolean;
+    logout?: boolean;
+    pathGuard?: boolean;
+};
+declare type ExpressReq = {
+    body?: AnyObject;
+    query?: AnyObject;
+    cookies?: AnyObject;
+    params?: AnyObject;
+    path: string;
+    originalUrl: string;
+};
+declare type ExpressRes = {
+    status: (code: number) => ({
+        json: (response: AnyObject) => any;
+    });
+    cookie: (name: string, value: string, options: AnyObject) => any;
+    sendFile: (filepath: string) => void;
+    redirect: (url: string) => void;
+};
+export declare type BasicSession = {
+    /** Must be hard to bruteforce */
+    sid: string;
+    /** UNIX millisecond timestamp */
+    expires: number;
+};
+export declare type AuthClientRequest = {
+    socket: any;
+} | {
+    httpReq: ExpressReq;
+};
+export declare type Auth<S = void> = {
+    /**
+     * Name of the cookie or socket hadnshake query param that represents the session id.
+     * Defaults to "session_id"
+     */
+    sidKeyName?: string;
+    /**
+     * Response time rounding in milliseconds to prevent timing attacks on login. Login response time should always be a multiple of this value. Defaults to 500 milliseconds
+     */
+    responseThrottle?: number;
+    expressConfig?: {
+        /**
+         * Express app instance. If provided Prostgles will attempt to set sidKeyName to user cookie
+         */
+        app: any;
+        /**
+         * Used in allowing logging in through express. Defaults to /login
+         */
+        loginRoute?: string;
+        /**
+         * Used in allowing logging out through express. Defaults to /logout
+         */
+        logoutGetPath?: string;
+        /**
+         * Options used in setting the cookie after a successful login
+         */
+        cookieOptions?: AnyObject;
+        /**
+         * If provided, any client requests to NOT these routes (or their subroutes) will be redirected to loginRoute and then redirected back to the initial route after logging in
+         */
+        publicRoutes?: string[];
+        /**
+         * False by default. If false and userRoutes are provided then the socket will request window.location.reload if the current url is on a user route.
+         */
+        disableSocketAuthGuard?: boolean;
+        /**
+         * Will be called after a GET request is authorised
+         */
+        onGetRequestOK?: (req: ExpressReq, res: ExpressRes) => any;
+        /**
+         * Name of get url parameter used in redirecting user after successful login. Defaults to returnURL
+         */
+        returnURL?: string;
+        magicLinks?: {
+            /**
+             * Will default to /magic-link
+             */
+            route?: string;
+            /**
+             * Used in creating a session/logging in using a magic link
+             */
+            check: (magicId: string, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<BasicSession | undefined>;
+        };
+    };
+    getUser: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB, client: AuthClientRequest) => Awaitable<{
+        /**
+         * User data used on server. Mainly used in http request auth
+         */
+        user: AnyObject;
+        /**
+         * User data sent to client. Mainly used in socket request auth
+         */
+        clientUser: AnyObject;
+    } | undefined>;
+    register?: (params: AnyObject, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<BasicSession> | BasicSession;
+    login?: (params: AnyObject, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<BasicSession> | BasicSession;
+    logout?: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<any>;
+    /**
+     * If provided then then session info will be saved on socket.__prglCache and reused from there
+     */
+    cacheSession?: {
+        getSession: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<BasicSession>;
+    };
+};
+export declare type ClientInfo = {
+    user?: AnyObject;
+    clientUser?: AnyObject;
+    sid?: string;
+};
+export default class AuthHandler {
+    protected opts?: Auth;
+    dbo: DBHandlerServer;
+    db: DB;
+    sidKeyName?: string;
+    returnURL?: string;
+    loginRoute?: string;
+    logoutGetPath?: string;
+    constructor(prostgles: Prostgles);
+    validateSid: (sid: string | undefined) => string;
+    matchesRoute: (route: string | undefined, clientFullRoute: string) => boolean;
+    isUserRoute: (pathname: string) => boolean;
+    private setCookieAndGoToReturnURLIFSet;
+    getUser: (clientReq: AuthClientRequest) => Promise<AnyObject | undefined>;
+    init(): Promise<void>;
+    throttledFunc: <T>(func: () => Promise<T>, throttle?: number) => Promise<T>;
+    loginThrottled: (params: AnyObject) => Promise<BasicSession>;
+    /**
+     * Will return first sid value found in : http cookie or query params
+     * Based on sid names in auth
+     * @param localParams
+     * @returns string
+     */
+    getSID(localParams: LocalParams): string | undefined;
+    getClientInfo(localParams: Pick<LocalParams, "socket" | "httpReq">): Promise<ClientInfo | undefined>;
+    isValidSocketSession: (socket: PRGLIOSocket, session: BasicSession) => boolean;
+    makeSocketAuth: (socket: PRGLIOSocket) => Promise<AuthSocketSchema>;
+}
+export {};
+//# sourceMappingURL=AuthHandler.d.ts.map

package/lib/AuthHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthHandler.d.ts","sourceRoot":"","sources":["AuthHandler.ts"],"names":[],"mappings":"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"}

package/lib/AuthHandler.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prostgles_types_1 = require("prostgles-types");
+class AuthHandler {
+    constructor(prostgles) {
+        this.validateSid = (sid) => {
+            if (!sid)
+                return undefined;
+            if (typeof sid !== "string")
+                throw "sid missing or not a string";
+            return sid;
+        };
+        this.matchesRoute = (route, clientFullRoute) => {
+            return route && clientFullRoute && (route === clientFullRoute ||
+                clientFullRoute.startsWith(route) && ["/", "?", "#"].includes(clientFullRoute.slice(-1)));
+        };
+        this.isUserRoute = (pathname) => {
+            const pubRoutes = [
+                ...this.opts?.expressConfig?.publicRoutes || [],
+            ];
+            if (this.loginRoute)
+                pubRoutes.push(this.loginRoute);
+            if (this.logoutGetPath)
+                pubRoutes.push(this.logoutGetPath);
+            return Boolean(!pubRoutes.find(publicRoute => {
+                return this.matchesRoute(publicRoute, pathname); // publicRoute === pathname || pathname.startsWith(publicRoute) && ["/", "?", "#"].includes(pathname.slice(-1));
+            }));
+        };
+        this.setCookieAndGoToReturnURLIFSet = (cookie, r) => {
+            const { sid, expires } = cookie;
+            const { res, req } = r;
+            if (sid) {
+                let maxAge = 1000 * 60 * 60 * 24; // 24 hours
+                if (expires && Number.isFinite(expires) && !isNaN(+new Date(expires))) {
+                    maxAge = (+new Date(expires) - Date.now());
+                }
+                let options = {
+                    maxAge,
+                    httpOnly: true, // The cookie only accessible by the web server
+                    //signed: true // Indicates if the cookie should be signed
+                };
+                const cookieOpts = { ...options, secure: true, sameSite: "strict", ...(this.opts?.expressConfig?.cookieOptions || {}) };
+                const cookieData = sid;
+                if (!this.sidKeyName || !this.returnURL)
+                    throw "sidKeyName or returnURL missing";
+                res.cookie(this.sidKeyName, cookieData, cookieOpts);
+                const successURL = getReturnUrl(req, this.returnURL) || "/";
+                res.redirect(successURL);
+            }
+            else {
+                throw ("no user or session");
+            }
+        };
+        this.getUser = async (clientReq) => {
+            if (!this.sidKeyName || !this.opts?.getUser)
+                throw "sidKeyName or this.opts.getUser missing";
+            const sid = "httpReq" in clientReq ? clientReq.httpReq?.cookies?.[this.sidKeyName] : clientReq.socket;
+            if (!sid)
+                return undefined;
+            try {
+                return this.throttledFunc(async () => {
+                    return this.opts.getUser(this.validateSid(sid), this.dbo, this.db, clientReq);
+                }, 50);
+            }
+            catch (err) {
+                console.error(err);
+            }
+            return undefined;
+        };
+        this.throttledFunc = (func, throttle = 500) => {
+            return new Promise(async (resolve, reject) => {
+                let interval, result, error, finished = false;
+                /**
+                 * Throttle response times to prevent timing attacks
+                 */
+                interval = setInterval(() => {
+                    if (finished) {
+                        clearInterval(interval);
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    }
+                }, throttle);
+                try {
+                    result = await func();
+                }
+                catch (err) {
+                    console.log(err);
+                    error = err;
+                }
+                finished = true;
+            });
+        };
+        this.loginThrottled = async (params) => {
+            if (!this.opts?.login)
+                throw "Auth login config missing";
+            const { responseThrottle = 500 } = this.opts;
+            return this.throttledFunc(async () => {
+                let result = await this.opts?.login?.(params, this.dbo, this.db);
+                const err = {
+                    msg: "Bad login result type. \nExpecting: undefined | null | { sid: string; expires: number } but got: " + JSON.stringify(result)
+                };
+                if (!result)
+                    throw err;
+                if (result && (typeof result.sid !== "string" || typeof result.expires !== "number") || !result && ![undefined, null].includes(result)) {
+                    throw err;
+                }
+                if (result && result.expires < Date.now()) {
+                    throw { msg: "auth.login() is returning an expired session. Can only login with a session.expires greater than Date.now()" };
+                }
+                return result;
+            }, responseThrottle);
+        };
+        this.isValidSocketSession = (socket, session) => {
+            const hasExpired = Boolean(session && session.expires <= Date.now());
+            if (this.opts?.expressConfig?.publicRoutes && !this.opts.expressConfig?.disableSocketAuthGuard) {
+                if (hasExpired) {
+                    socket.emit(prostgles_types_1.CHANNELS.AUTHGUARD, { shouldReload: true });
+                    throw "";
+                }
+            }
+            return Boolean(session && !hasExpired);
+        };
+        this.makeSocketAuth = async (socket) => {
+            if (!this.opts)
+                return {};
+            let auth = {};
+            if (this.opts.expressConfig?.publicRoutes && !this.opts.expressConfig?.disableSocketAuthGuard) {
+                auth.pathGuard = true;
+                socket.removeAllListeners(prostgles_types_1.CHANNELS.AUTHGUARD);
+                socket.on(prostgles_types_1.CHANNELS.AUTHGUARD, async (params, cb = (err, res) => { }) => {
+                    try {
+                        const { pathname } = typeof params === "string" ? JSON.parse(params) : (params || {});
+                        if (pathname && typeof pathname !== "string")
+                            console.warn("Invalid pathname provided for AuthGuardLocation: ", pathname);
+                        if (pathname && typeof pathname === "string" && this.isUserRoute(pathname) && !(await this.getClientInfo({ socket }))?.user) {
+                            cb(null, { shouldReload: true });
+                        }
+                        else {
+                            cb(null, { shouldReload: false });
+                        }
+                    }
+                    catch (err) {
+                        console.error("AUTHGUARD err: ", err);
+                        cb(err);
+                    }
+                });
+            }
+            const { register, logout } = this.opts;
+            const login = this.loginThrottled;
+            let handlers = [
+                { func: (params, dbo, db) => register?.(params, dbo, db), ch: prostgles_types_1.CHANNELS.REGISTER, name: "register" },
+                { func: (params, dbo, db) => login(params), ch: prostgles_types_1.CHANNELS.LOGIN, name: "login" },
+                { func: (params, dbo, db) => logout?.(this.getSID({ socket }), dbo, db), ch: prostgles_types_1.CHANNELS.LOGOUT, name: "logout" }
+            ].filter(h => h.func);
+            const usrData = await this.getClientInfo({ socket });
+            if (usrData) {
+                auth.user = usrData.clientUser;
+                handlers = handlers.filter(h => h.name === "logout");
+            }
+            handlers.map(({ func, ch, name }) => {
+                auth[name] = true;
+                socket.removeAllListeners(ch);
+                socket.on(ch, async (params, cb = (...callback) => { }) => {
+                    try {
+                        if (!socket)
+                            throw "socket missing??!!";
+                        const res = await func(params, this.dbo, this.db);
+                        if (name === "login" && res && res.sid) {
+                            /* TODO: Re-send schema to client */
+                        }
+                        cb(null, true);
+                    }
+                    catch (err) {
+                        console.error(name + " err", err);
+                        cb(err);
+                    }
+                });
+            });
+            return auth;
+        };
+        this.opts = prostgles.opts.auth;
+        if (prostgles.opts.auth?.expressConfig) {
+            this.returnURL = prostgles.opts.auth?.expressConfig?.returnURL || "returnURL";
+            this.loginRoute = prostgles.opts.auth?.expressConfig?.loginRoute || "/login";
+            this.logoutGetPath = prostgles.opts.auth?.expressConfig?.logoutGetPath || "/logout";
+        }
+        if (!prostgles.dbo || !prostgles.db)
+            throw "dbo or db missing";
+        this.dbo = prostgles.dbo;
+        this.db = prostgles.db;
+    }
+    async init() {
+        if (!this.opts)
+            return;
+        this.opts.sidKeyName = this.opts.sidKeyName || "session_id";
+        const { sidKeyName, login, getUser, expressConfig } = this.opts;
+        this.sidKeyName = this.opts.sidKeyName;
+        if (typeof sidKeyName !== "string" && !login) {
+            throw "Invalid auth: Provide { sidKeyName: string } ";
+        }
+        /**
+         * Why ??? Collision with socket.io ???
+         */
+        if (this.sidKeyName === "sid")
+            throw "sidKeyName cannot be 'sid' please provide another name.";
+        if (!getUser)
+            throw "getUser missing from auth config";
+        if (expressConfig) {
+            const { app, publicRoutes = [], onGetRequestOK, magicLinks } = expressConfig;
+            if (publicRoutes.find(r => typeof r !== "string" || !r)) {
+                throw "Invalid or empty string provided within publicRoutes ";
+            }
+            if (app && magicLinks) {
+                const { route = "/magic-link", check } = magicLinks;
+                if (!check)
+                    throw "Check must be defined for magicLinks";
+                app.get(`${route}/:id`, async (req, res) => {
+                    const { id } = req.params ?? {};
+                    if (typeof id !== "string" || !id) {
+                        res.status(404).json({ msg: "Invalid magic-link id. Expecting a string" });
+                    }
+                    else {
+                        try {
+                            const session = await this.throttledFunc(async () => {
+                                return check(id, this.dbo, this.db);
+                            });
+                            if (!session) {
+                                res.status(404).json({ msg: "Invalid magic-link" });
+                            }
+                            else {
+                                this.setCookieAndGoToReturnURLIFSet(session, { req, res });
+                            }
+                        }
+                        catch (e) {
+                            res.status(404).json({ msg: e });
+                        }
+                    }
+                });
+            }
+            if (app && this.loginRoute) {
+                app.post(this.loginRoute, async (req, res) => {
+                    try {
+                        const { sid, expires } = await this.loginThrottled(req.body || {}) || {};
+                        if (sid) {
+                            this.setCookieAndGoToReturnURLIFSet({ sid, expires }, { req, res });
+                        }
+                        else {
+                            throw ("no user or session");
+                        }
+                    }
+                    catch (err) {
+                        console.log(err);
+                        res.status(404).json({ err: "Invalid username or password" });
+                    }
+                });
+                if (app && this.logoutGetPath && this.opts.logout) {
+                    app.get(this.logoutGetPath, async (req, res) => {
+                        const sid = this.validateSid(req?.cookies?.[sidKeyName]);
+                        if (sid) {
+                            try {
+                                await this.throttledFunc(() => {
+                                    return this.opts.logout(req?.cookies?.[sidKeyName], this.dbo, this.db);
+                                });
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                        }
+                        res.redirect("/");
+                    });
+                }
+                if (app && Array.isArray(publicRoutes)) {
+                    /* Redirect if not logged in and requesting non public content */
+                    app.get('*', async (req, res) => {
+                        const clientReq = { httpReq: req };
+                        const getUser = this.getUser;
+                        try {
+                            const returnURL = getReturnUrl(req, this.returnURL);
+                            /**
+                             * Requesting a User route
+                             */
+                            if (this.isUserRoute(req.path)) {
+                                /* Check auth. Redirect if unauthorized */
+                                const u = await getUser(clientReq);
+                                if (!u) {
+                                    res.redirect(`${this.loginRoute}?returnURL=${encodeURIComponent(req.originalUrl)}`);
+                                    return;
+                                }
+                                /* If authorized and going to returnUrl then redirect. Otherwise serve file */
+                            }
+                            else if (returnURL && (await getUser(clientReq))) {
+                                res.redirect(returnURL);
+                                return;
+                                /** If Logged in and requesting login then redirect */
+                            }
+                            else if (this.matchesRoute(this.loginRoute, req.path) && (await getUser(clientReq))) {
+                                res.redirect("/");
+                                return;
+                            }
+                            if (onGetRequestOK) {
+                                onGetRequestOK(req, res);
+                            }
+                        }
+                        catch (error) {
+                            console.error(error);
+                            res.status(404).json({ msg: "Something went wrong", error });
+                        }
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Will return first sid value found in : http cookie or query params
+     * Based on sid names in auth
+     * @param localParams
+     * @returns string
+     */
+    getSID(localParams) {
+        if (!this.opts)
+            return undefined;
+        const { sidKeyName } = this.opts;
+        if (!sidKeyName || !localParams)
+            return undefined;
+        if (localParams.socket) {
+            const querySid = localParams.socket?.handshake?.query?.[sidKeyName];
+            let rawSid = querySid;
+            if (!rawSid) {
+                const cookie_str = localParams.socket?.handshake?.headers?.cookie;
+                const cookie = parseCookieStr(cookie_str);
+                rawSid = cookie[sidKeyName];
+            }
+            return this.validateSid(rawSid);
+        }
+        else if (localParams.httpReq) {
+            return this.validateSid(localParams.httpReq?.cookies?.[sidKeyName]);
+        }
+        else
+            throw "socket OR httpReq missing from localParams";
+        function parseCookieStr(cookie_str) {
+            if (!cookie_str || typeof cookie_str !== "string")
+                return {};
+            return cookie_str.replace(/\s/g, '').split(";").reduce((prev, current) => {
+                const [name, value] = current.split('=');
+                prev[name] = value;
+                return prev;
+            }, {});
+        }
+    }
+    async getClientInfo(localParams) {
+        if (!this.opts)
+            return {};
+        const getSession = this.opts.cacheSession?.getSession;
+        const isSocket = "socket" in localParams;
+        if (getSession && isSocket && localParams.socket?.__prglCache) {
+            const { session, user, clientUser } = localParams.socket.__prglCache;
+            const isValid = this.isValidSocketSession(localParams.socket, session);
+            if (isValid) {
+                return {
+                    sid: session.sid,
+                    user,
+                    clientUser,
+                };
+            }
+            else
+                return {};
+        }
+        const res = await this.throttledFunc(async () => {
+            const { getUser } = this.opts ?? {};
+            if (getUser && localParams && (localParams.httpReq || localParams.socket)) {
+                const sid = this.getSID(localParams);
+                const clientReq = localParams.httpReq ? { httpReq: localParams.httpReq } : { socket: localParams.socket };
+                let user, clientUser;
+                if (sid) {
+                    const res = await getUser(sid, this.dbo, this.db, clientReq);
+                    user = res?.user;
+                    clientUser = res?.clientUser;
+                }
+                if (getSession && isSocket) {
+                    const session = await getSession(sid, this.dbo, this.db);
+                    if (session?.expires && user && clientUser && localParams.socket) {
+                        localParams.socket.__prglCache = {
+                            session,
+                            user,
+                            clientUser,
+                        };
+                    }
+                }
+                if (sid) {
+                    return { sid, user, clientUser };
+                }
+            }
+            return {};
+        }, 5);
+        return res;
+    }
+}
+exports.default = AuthHandler;
+/**
+ * AUTH
+ */
+function getReturnUrl(req, name) {
+    if (req?.query?.returnURL && name) {
+        return decodeURIComponent(req?.query?.[name]);
+    }
+    return null;
+}

package/lib/AuthHandler.ts

@@ -36,7 +36,7 @@ export type BasicSession = {
 
 };
 export type AuthClientRequest = { socket: any } | { httpReq: ExpressReq }
-export type Auth<S extends DBSchema | undefined = undefined> = {
+export type Auth<S = void> = {
   /**
    * Name of the cookie or socket hadnshake query param that represents the session id. 
    * Defaults to "session_id"
@@ -136,8 +136,8 @@ export type ClientInfo = {
   sid?: string;
 }
 
-export default class AuthHandler<S extends DBSchema | undefined = undefined> {
-  protected opts?: Auth<S>;
+export default class AuthHandler {
+  protected opts?: Auth;
   dbo: DBHandlerServer;
   db: DB;
   sidKeyName?: string;

package/lib/DBEventsManager.d.ts

@@ -0,0 +1,38 @@
+import { PostgresNotifListenManager } from "./PostgresNotifListenManager";
+import { DB, PGP } from "./Prostgles";
+import { PRGLIOSocket } from "./DboBuilder";
+export declare class DBEventsManager {
+    notifies: {
+        [key: string]: {
+            socketChannel: string;
+            sockets: any[];
+            localFuncs: ((payload: string) => void)[];
+            notifMgr: PostgresNotifListenManager;
+        };
+    };
+    notice: {
+        socketChannel: string;
+        socketUnsubChannel: string;
+        sockets: any[];
+    };
+    notifManager?: PostgresNotifListenManager;
+    db_pg: DB;
+    pgp: PGP;
+    constructor(db_pg: DB, pgp: PGP);
+    private onNotif;
+    onNotice: (notice: any) => void;
+    getNotifChannelName: (channel: string) => Promise<any>;
+    addNotify(query: string, socket?: PRGLIOSocket, func?: any): Promise<{
+        socketChannel: string;
+        socketUnsubChannel: string;
+        notifChannel: string;
+        unsubscribe?: () => void;
+    }>;
+    removeNotify(channel?: string, socket?: PRGLIOSocket, func?: any): void;
+    addNotice(socket: PRGLIOSocket): {
+        socketChannel: string;
+        socketUnsubChannel: string;
+    };
+    removeNotice(socket: PRGLIOSocket): void;
+}
+//# sourceMappingURL=DBEventsManager.d.ts.map

package/lib/DBEventsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DBEventsManager.d.ts","sourceRoot":"","sources":["DBEventsManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAqB,MAAM,8BAA8B,CAAC;AAC7F,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,qBAAa,eAAe;IAE1B,QAAQ,EAAE;QACR,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,aAAa,EAAE,MAAM,CAAC;YACtB,OAAO,EAAE,GAAG,EAAE,CAAC;YACf,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,EAAE,CAAC;YAC1C,QAAQ,EAAE,0BAA0B,CAAC;SACtC,CAAA;KACF,CAAM;IAEP,MAAM,EAAE;QACN,aAAa,EAAE,MAAM,CAAC;QACtB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,OAAO,EAAE,GAAG,EAAE,CAAC;KAChB,CAIC;IAEF,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAE1C,KAAK,EAAE,EAAE,CAAC;IACV,GAAG,EAAE,GAAG,CAAA;gBACI,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG;IAK/B,OAAO,CAAC,OAAO,CAgBd;IAED,QAAQ,WAAY,GAAG,UAMtB;IAED,mBAAmB,YAAmB,MAAM,kBAG3C;IAEK,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC;QACzE,aAAa,EAAE,MAAM,CAAC;QACtB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;KAC1B,CAAC;IAmEF,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,GAAG;IAkBhE,SAAS,CAAC,MAAM,EAAE,YAAY;;;;IAiB9B,YAAY,CAAC,MAAM,EAAE,YAAY;CAIlC"}