@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/users.js

@@ -0,0 +1,802 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { createHash, createPassword, parseArangoId, parseChar, parseEmail, parsePassword, parsePhone, parseUsername } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { DateTime } from 'luxon';
+import Stripe from 'stripe';
+import { parseUser } from '../adapters/userAdapter.js';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError, logException } from '../utils/analyticsUtils.js';
+import { getDocId, getLimit, selectReactionCountByType, useDb } from '../utils/arangodbUtils.js';
+import { detectLanguage } from '../utils/languageDetection.js';
+import { getSession, setSession } from '../utils/sessionUtils.js';
+import { sendEmail } from './email.js';
+import { sendSms } from './sms.js';
+const eventCategory = 'users';
+const STRIPE_API_VERSION = '2025-12-15.clover';
+export var UserAccess = /*#__PURE__*/ function(UserAccess) {
+    UserAccess[UserAccess["DEACTIVATED"] = 0] = "DEACTIVATED";
+    UserAccess[UserAccess["ACTIVE"] = 1] = "ACTIVE";
+    UserAccess[UserAccess["PREMIUM"] = 2] = "PREMIUM";
+    UserAccess[UserAccess["CONTENT_ADMIN"] = 3] = "CONTENT_ADMIN";
+    UserAccess[UserAccess["ADMIN"] = 4] = "ADMIN";
+    return UserAccess;
+}({});
+export const createToken = (userId, username = '', userAccess = 0, expiresInMinutes = 15)=>{
+    const now = DateTime.local();
+    const sessionExpires = now.plus({
+        minutes: expiresInMinutes
+    });
+    const iat = Math.floor(now.toSeconds());
+    const exp = Math.floor(sessionExpires.toSeconds());
+    const token = setSession({
+        exp,
+        iat,
+        userAccess,
+        userId,
+        username
+    });
+    return {
+        expires: sessionExpires.toMillis(),
+        issued: now.toMillis(),
+        token,
+        userId,
+        username
+    };
+};
+export const getUserOptional = (fields = [])=>fields.reduce((selects, field)=>{
+        if (field.includes('Count')) {
+            return selectReactionCountByType('users', 'u', field, selects);
+        }
+        return selects;
+    }, {
+        objects: [],
+        queries: []
+    });
+export const parseUserOptions = (options = {})=>{
+    const { from = 0, to = 30 } = options;
+    const limit = getLimit(from, to);
+    return {
+        ...options,
+        limit
+    };
+};
+export const addUser = async (context, user)=>{
+    const action = 'addUser';
+    const { databaseName, languageContext } = context;
+    const { confirm: _confirm, ...newUser } = user;
+    const { email, password, phone, username, userId, _key, _id, ...insertUser } = parseUser(newUser);
+    const hasPassword = !!password;
+    const hasUsername = !!username || !!phone || !!email;
+    if (!hasPassword || !hasUsername) {
+        logException({
+            action,
+            category: eventCategory,
+            params: {
+                username
+            },
+            value: ErrorTypes.INVALID_ARGUMENTS
+        }, context);
+        return null;
+    }
+    const hashId = username || phone || email;
+    const salt = createHash(`${hashId}${password}`, '');
+    const encryptedPassword = createPassword(password, salt);
+    const filters = [];
+    if (username) {
+        filters.push(`u.username == "${username}"`);
+    }
+    if (email) {
+        filters.push(`u.email == "${email}"`);
+    }
+    if (phone) {
+        filters.push(`u.phone == ${phone}`);
+    }
+    const checkQuery = `FOR u IN users
+    FILTER ${filters.join(' || ')}
+    LIMIT 1
+    RETURN u`;
+    try {
+        const existingUsers = await useDb(databaseName).query(checkQuery).then((cursor)=>cursor.all());
+        if (existingUsers.length) {
+            throw logException({
+                action,
+                category: eventCategory,
+                params: {
+                    email,
+                    phone,
+                    username
+                },
+                value: ErrorTypes.EXISTING_ITEM
+            }, context);
+        }
+    } catch (error) {
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                email,
+                phone,
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    }
+    const phoneCountryCode = phone?.replace(/\D/g, '').substring(0, 3);
+    const locale = detectLanguage({
+        ...languageContext,
+        phoneCountryCode: phoneCountryCode || '',
+        userPreference: insertUser.locale || 'en'
+    });
+    const verifiedEmailCode = Math.floor(100000 + Math.random() * 900000);
+    const verifiedSmsCode = Math.floor(100000 + Math.random() * 900000);
+    const insert = {
+        ...insertUser,
+        _key: createHash(username),
+        added: Date.now(),
+        email,
+        locale,
+        modified: Date.now(),
+        password: encryptedPassword,
+        phone,
+        salt,
+        userAccess: 1,
+        username,
+        verifiedEmail: false,
+        verifiedEmailCode,
+        verifiedPhone: false,
+        verifiedSmsCode
+    };
+    const insertQuery = aql`INSERT ${insert} IN users RETURN NEW`;
+    return await useDb(databaseName).query(insertQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+export const updateUser = async (context, user)=>{
+    const action = 'updateUser';
+    const { databaseName } = context;
+    const updatedUser = parseUser(user);
+    const { _key, _id, tags = [], ...update } = updatedUser;
+    const { id } = updatedUser;
+    const userQuery = aql`LET u = DOCUMENT(${id})
+    UPDATE u WITH ${update} IN users
+    RETURN NEW`;
+    try {
+        const database = useDb(databaseName);
+        const updatedUser = await database.query(userQuery).then((cursor)=>cursor.next());
+        const tagCollection = database.collection('isTagged');
+        await Promise.all(tags.map(({ id: tagDocId, name })=>{
+            const tagQuery = aql`FOR it IN isTagged
+        FILTER it._from == ${tagDocId} && it._to == ${id} && it.name == ${name}
+        LIMIT 1
+        RETURN it`;
+            return database.query(tagQuery).then((cursor)=>cursor.next()).then((tagEdge)=>{
+                if (!!tagEdge) {
+                    return tagEdge;
+                }
+                const edge = {
+                    _from: tagDocId,
+                    _key: createHash(`isTagged-${tagDocId}-${id}`),
+                    _to: id,
+                    added: Date.now(),
+                    name
+                };
+                return tagCollection.save(edge, {
+                    returnNew: true
+                }).then(()=>edge);
+            });
+        }));
+        return updatedUser;
+    } catch (error) {
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                user
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    }
+};
+export const forgotPassword = async (context, { email, phone, username })=>{
+    const action = 'forgotPassword';
+    const { databaseName } = context;
+    const aqlQuery = aql`FOR u IN users
+    FILTER u.email == ${email} || u.phone == ${phone} || u.username == ${username}
+    LIMIT 1
+    RETURN u`;
+    try {
+        return await useDb(databaseName).query(aqlQuery).then(async (cursor)=>{
+            const user = cursor.next();
+            if (user) {
+                const { email, phone, verifiedEmail, verifiedPhone } = user;
+                const codeExpires = 1000 * 60 * 15; // 15 minutes
+                const code = Math.floor(100000 + Math.random() * 900000);
+                const userDocId = getDocId('users', user);
+                let update;
+                if (email && verifiedEmail) {
+                    sendEmail({
+                        context,
+                        text: `Your code is ${code}`
+                    });
+                    update = {
+                        verifiedEmailCode: code,
+                        verifiedEmailExpires: codeExpires
+                    };
+                }
+                if (phone && verifiedPhone) {
+                    sendSms({
+                        context,
+                        text: `Your code is ${code}`
+                    });
+                    update = {
+                        verifiedPhoneExpires: codeExpires,
+                        verifiedSmsCode: code
+                    };
+                }
+                if (update.verifiedEmailCode || update.verifiedSmsCode) {
+                    const updateQuery = aql`UPDATE ${userDocId} WITH ${update} IN users`;
+                    await useDb(databaseName).query(updateQuery);
+                    return true;
+                }
+                return false;
+            }
+            return false;
+        });
+    } catch (error) {
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                email,
+                phone,
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return false;
+    }
+};
+export const resetPassword = async (context, { code, password, type, username })=>{
+    const action = 'resetPassword';
+    const { databaseName } = context;
+    const formatPassword = parsePassword(password);
+    const aqlQuery = aql`FOR u IN users
+    FILTER u.username == ${username}
+    LIMIT 1
+    RETURN u`;
+    try {
+        return await useDb(databaseName).query(aqlQuery).then(async (cursor)=>{
+            const user = cursor.next();
+            if (user) {
+                const { _id: userDocId, salt, verifiedEmailCode, verifiedEmailExpires = 0, verifiedSmsCode, verifiedPhoneExpires = 0 } = user;
+                const now = Date.now();
+                let update;
+                switch(type){
+                    case 'email':
+                        if (code === verifiedEmailCode && verifiedEmailExpires > now) {
+                            const password = createPassword(formatPassword, salt);
+                            update = {
+                                password
+                            };
+                        }
+                        break;
+                    case 'phone':
+                        if (code === verifiedSmsCode && verifiedPhoneExpires > now) {
+                            const password = createPassword(formatPassword, salt);
+                            update = {
+                                password
+                            };
+                        }
+                        break;
+                    default:
+                        return false;
+                }
+                if (update) {
+                    const updateQuery = aql`UPDATE ${userDocId} WITH ${update} IN users`;
+                    await useDb(databaseName).query(updateQuery);
+                    return true;
+                }
+            }
+            return false;
+        });
+    } catch (error) {
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return false;
+    }
+};
+export const confirmCode = async (context, { code, type, value })=>{
+    const action = 'confirmCode';
+    const { databaseName } = context;
+    const isSms = type === 'sms';
+    const formattedValue = isSms ? parsePhone(value) : parseEmail(value);
+    const filterByType = isSms ? `FILTER u.phone == "${formattedValue}" && u.verifiedSmsCode == ${code}` : `FILTER u.email == "${formattedValue}" && u.verifiedEmailCode == ${code}`;
+    const aqlQuery = `FOR u IN users
+    ${filterByType}
+    LIMIT 1
+    RETURN u`;
+    try {
+        return await useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).then((user)=>{
+            if (user) {
+                const updatedUser = isSms ? {
+                    verifiedPhone: true,
+                    verifiedSmsCode: 0
+                } : {
+                    verifiedEmail: true,
+                    verifiedEmailCode: 0
+                };
+                const aqlQuery = aql`UPDATE ${user._key} WITH ${updatedUser} IN users`;
+                return useDb(databaseName).query(aqlQuery).then(()=>true).catch((error)=>{
+                    logError({
+                        action,
+                        category: eventCategory,
+                        params: {
+                            code,
+                            type,
+                            value: formattedValue
+                        },
+                        value: ErrorTypes.DATABASE_ERROR
+                    }, error, context);
+                    return false;
+                });
+            }
+            return false;
+        });
+    } catch (error) {
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                code,
+                type,
+                value: formattedValue
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return false;
+    }
+};
+export const deleteUser = (context, user)=>{
+    const action = 'deleteUser';
+    const { databaseName } = context;
+    const { id } = parseUser(user);
+    const aqlQuery = aql`LET u = DOCUMENT(${id})
+    REMOVE u IN users
+    RETURN OLD`;
+    const stripeClient = new Stripe(Config.get('stripe.token'), {
+        apiVersion: STRIPE_API_VERSION,
+        typescript: true
+    });
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).then((deletedUser)=>stripeClient.customers.del(deletedUser?.stripeCustomerId).then(()=>stripeClient.accounts.del(deletedUser?.stripeAccountId)).then(()=>deletedUser)).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            params: {
+                id
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const deactivateUser = (context, user)=>{
+    const action = 'delete';
+    const { databaseName } = context;
+    const { id } = parseUser(user);
+    const updated = {
+        userAccess: 0
+    };
+    const aqlQuery = aql`UPDATE ${id} WITH ${updated} IN users LIMIT 1 RETURN NEW`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                id
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+export const getDisplayName = (user)=>{
+    const { first, last, name = '', username = '' } = user;
+    const fullname = [
+        first,
+        last
+    ].join(' ').trim();
+    if (name) {
+        return name;
+    } else if (fullname !== '') {
+        return fullname;
+    } else if (username) {
+        return username;
+    }
+    return 'Unknown';
+};
+export const getSessionUser = (context)=>{
+    const action = 'getSessionUser';
+    const { databaseName, fields, session: { userId: sessionId, username } = {} } = context;
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    const formatSessionId = parseArangoId(`users/${sessionId}`);
+    const aqlQuery = `LET u = DOCUMENT("${formatSessionId}")
+  ${selectQueries.join('\n')}
+  RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                userId: sessionId,
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+export const getUser = (context, user)=>{
+    const action = 'getUser';
+    const { email, id, phone, userId, username } = parseUser(user);
+    const { databaseName, fields } = context;
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    let aqlQuery = '';
+    if (id) {
+        aqlQuery = `LET u = DOCUMENT("${id}")
+    ${selectQueries.join('\n')}
+    FILTER u.userAccess > 0
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    } else if (username) {
+        aqlQuery = `FOR u IN users
+    FILTER u.username == "${username}"
+    ${selectQueries.join('\n')}
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    } else if (email) {
+        aqlQuery = `FOR u IN users
+    FILTER u.email == "${email}"
+    ${selectQueries.join('\n')}
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    } else if (phone) {
+        aqlQuery = `FOR u IN users
+    FILTER u.phone == "${phone}"
+    ${selectQueries.join('\n')}
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    }
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).then((user)=>user).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            params: {
+                id,
+                userId,
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const getUsers = (context, options)=>{
+    const action = 'getUserList';
+    const { databaseName, fields } = context;
+    const { limit, username } = parseUserOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    const filterBy = [
+        'u.userAccess > 0'
+    ];
+    if (username) {
+        filterBy.push(`CONTAINS(u.username, "${parseUsername(username)}")`);
+    }
+    const aqlQuery = `FOR u IN users
+    FILTER ${filterBy.join(' && ')}
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT u.username
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getUsersByReactions = (context, { reactions = [], username }, options)=>{
+    const action = 'getUsersByReactions';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const formatReactions = reactions.map((reactionName)=>parseChar(reactionName, 32).toLowerCase());
+    const { limit } = parseUserOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    const formatSessionId = `users/${sessionId}`;
+    const formatUsername = parseUsername(username);
+    const filterBy = [
+        'u.userAccess > 0',
+        `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`
+    ];
+    if (username) {
+        filterBy.push(`CONTAINS(u.username, "${formatUsername}")`);
+    }
+    const aqlQuery = `FOR u, r IN OUTBOUND "${formatSessionId}" hasReaction
+    OPTIONS {vertexCollections: "users"}
+    ${selectQueries.join('\n')}
+    FILTER ${filterBy.join(' && ')}
+    ${limit.aql}
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getUsersByTags = (context, { tags, username }, options)=>{
+    const action = 'getUsersByTags';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const formatTags = tags?.reduce((list, tagName)=>{
+        if (tagName) {
+            list.push(parseChar(tagName, 32).toLowerCase());
+        }
+        return list;
+    }, []);
+    const { limit } = parseUserOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    const formatUsername = parseUsername(username);
+    const filterBy = [
+        `u._key != "${sessionId}"`,
+        'u.userAccess > 0'
+    ];
+    if (username) {
+        filterBy.push(`CONTAINS(u.username, "${formatUsername}")`);
+    }
+    const aqlQuery = `FOR t IN tags
+    FILTER POSITION(${JSON.stringify(formatTags)}, LOWER(t.name))
+    FOR u, it IN OUTBOUND t isTagged
+    OPTIONS {bfs: true, uniqueVertices: "global", vertexCollections: "users"}
+    ${selectQueries.join('\n')}
+    FILTER ${filterBy.join(' && ')}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getUsersByLatest = (context, { username }, options)=>{
+    const action = 'getUsersByLatest';
+    const { databaseName, fields, session: { userId } = {} } = context;
+    const { limit } = parseUserOptions(options);
+    const filter = [
+        'u._id != session._id',
+        'u.userAccess > 0'
+    ];
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    if (username) {
+        filter.push(`CONTAINS(u.username, "${parseUsername(username)}")`);
+    }
+    // Get data from database
+    const aqlQuery = `FOR u IN users
+    LET session = DOCUMENT("users/${userId}")
+    FILTER ${filter.join(' && ')}
+    ${selectQueries.join('\n')}
+    LET distance = DISTANCE(u.latitude || 0, u.longitude || 0, session.latitude || 0, session.longitude || 0)
+    ${limit.aql}
+    SORT distance ASC, u.added DESC
+    RETURN MERGE(u, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getUsersByConnection = (context, { userId }, options)=>{
+    const action = 'getUsersByConnection';
+    const { databaseName, fields } = context;
+    const { limit, username } = parseUserOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+    const formatUserId = parseArangoId(`users/${userId}`);
+    const filterBy = [
+        'u.userAccess > 0'
+    ];
+    if (username) {
+        filterBy.push(`CONTAINS(u.username, "${parseUsername(username)}")`);
+    }
+    const aqlQuery = `FOR cu IN users
+    LET session = DOCUMENT("${formatUserId}")
+    FOR u, connection IN OUTBOUND cu hasConnection
+    OPTIONS {bfs: true, uniqueVertices: "global", vertexCollections: "users"}
+    ${selectQueries.join('\n')}
+    FILTER ${filterBy.join(' && ')}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const refreshSession = ({ expires, token })=>{
+    try {
+        const { userId, username, userAccess } = getSession(token);
+        return createToken(userId, username, userAccess, expires);
+    } catch (error) {
+        throw error; // Re-throw the error from getSession
+    }
+};
+export const signIn = async (context, args)=>{
+    const action = 'signIn';
+    const { databaseName } = context;
+    const { email, expires, password, phone, username } = args;
+    const formatEmail = parseEmail(email);
+    const formatUsername = parseUsername(username);
+    const formatPassword = parsePassword(password);
+    const formatPhone = parsePhone(phone);
+    const formatExpires = parseNum(expires) || 15;
+    if (!formatUsername && !formatEmail && !formatPhone || !formatPassword) {
+        throw logException({
+            action,
+            category: eventCategory,
+            params: {
+                username
+            },
+            value: ErrorTypes.INVALID_ARGUMENTS
+        }, context);
+    }
+    const filters = [];
+    if (formatEmail) {
+        filters.push(`u.email == "${formatEmail}"`);
+    }
+    if (formatPhone) {
+        filters.push(`u.phone == ${formatPhone}`);
+    }
+    if (formatUsername) {
+        filters.push(`u.username == "${formatUsername}"`);
+    }
+    const checkQuery = `FOR u IN users
+    FILTER ${filters.join(' || ')}
+    LIMIT 1
+    RETURN u`;
+    let checkUser;
+    try {
+        checkUser = await useDb(databaseName).query(checkQuery).then((cursor)=>cursor.next());
+    } catch (error) {
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                username: formatUsername
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    }
+    if (!checkUser) {
+        throw logException({
+            action,
+            category: eventCategory,
+            params: {
+                username
+            },
+            value: ErrorTypes.INVALID_AUTHENTICATION
+        }, context);
+    }
+    const { _key: userId, password: validPassword, salt, userAccess } = checkUser;
+    const authPassword = createPassword(formatPassword, salt);
+    console.log({
+        createPassword,
+        authPassword,
+        validPassword,
+        formatPassword,
+        salt
+    });
+    if (validPassword !== authPassword) {
+        throw logException({
+            action,
+            category: eventCategory,
+            params: {
+                userAccess,
+                userId,
+                username
+            },
+            value: ErrorTypes.INVALID_AUTHENTICATION
+        }, context);
+    }
+    try {
+        const token = createToken(userId || '', username || '', userAccess, formatExpires);
+        return token;
+    } catch (error) {
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                userId,
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    }
+};
+export const signOut = async (context)=>{
+    const action = 'signOut';
+    const { databaseName, session: { userId: sessionId, username } = {} } = context;
+    const userDocId = `users/${sessionId}`;
+    const update = {
+        lastOnline: Date.now(),
+        sessionId: null
+    };
+    const sessionQuery = aql`LET u = DOCUMENT(${userDocId})
+    UPDATE u WITH ${update} IN users
+    LIMIT 1
+    RETURN NEW`;
+    try {
+        await useDb(databaseName).query(sessionQuery).then((cursor)=>cursor.next());
+    } catch (error) {
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                userId: sessionId,
+                username
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return false;
+    }
+    return true;
+};
+export const getActiveUserCount = (context)=>{
+    const action = 'getActiveUserCount';
+    const { databaseName } = context;
+    const countQuery = aql`LET docs = (
+    FOR u IN users
+    FILTER u.active == true
+    RETURN u
+  )
+  RETURN LENGTH(docs)`;
+    return useDb(databaseName).query(countQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+export const getUserByToken = (context, token)=>{
+    const action = 'getUserByToken';
+    const { databaseName } = context;
+    const { userId } = getSession(token);
+    const userDocId = parseArangoId(`users/${userId}`);
+    const aqlQuery = aql`LET u = DOCUMENT("${userDocId}") RETURN u`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            params: {
+                userId
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/users.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseNum} from '@nlabs/utils/parsers/numbers';\nimport {\n  createHash,\n  createPassword,\n  parseArangoId,\n  parseChar,\n  parseEmail,\n  parsePassword,\n  parsePhone,\n  parseUsername\n} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {DateTime} from 'luxon';\nimport Stripe from 'stripe';\n\nimport {parseUser} from '../adapters/userAdapter.js';\nimport {Config} from '../config.js';\nimport {ErrorTypes, type SessionError} from '../types/error.types.js';\nimport {logError, logException} from '../utils/analyticsUtils.js';\nimport {getDocId, getLimit, selectReactionCountByType, useDb} from '../utils/arangodbUtils.js';\nimport {detectLanguage} from '../utils/languageDetection.js';\nimport {getSession, setSession, type SessionToken} from '../utils/sessionUtils.js';\nimport {sendEmail} from './email.js';\nimport {sendSms} from './sms.js';\n\nimport type {AqlQuery} from 'arangojs/aql';\nimport type {EdgeCollection} from 'arangojs/collections';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {UserInput, UserType} from '../types/users.types.js';\n\nconst eventCategory = 'users';\nconst STRIPE_API_VERSION = '2025-12-15.clover';\n\nexport interface UserOptions {\n  readonly from?: number;\n  readonly to?: number;\n  readonly username?: string;\n}\n\nexport enum UserAccess {\n  DEACTIVATED = 0,\n  ACTIVE = 1,\n  PREMIUM = 2,\n  CONTENT_ADMIN = 3,\n  ADMIN = 4\n}\n\nexport const createToken = (\n  userId: string,\n  username: string = '',\n  userAccess: number = 0,\n  expiresInMinutes: number = 15\n): SessionToken => {\n  const now: DateTime = DateTime.local();\n  const sessionExpires: DateTime = now.plus({minutes: expiresInMinutes});\n  const iat: number = Math.floor(now.toSeconds());\n  const exp: number = Math.floor(sessionExpires.toSeconds());\n  const token = setSession({\n    exp,\n    iat,\n    userAccess,\n    userId,\n    username\n  });\n\n  return {\n    expires: sessionExpires.toMillis(),\n    issued: now.toMillis(),\n    token,\n    userId,\n    username\n  };\n};\n\ninterface SelectAccumulator {\n  objects: string[];\n  queries: string[];\n}\n\nexport const getUserOptional = (fields: string[] = []): SelectAccumulator =>\n  fields.reduce((selects: SelectAccumulator, field: string) => {\n    if(field.includes('Count')) {\n      return selectReactionCountByType('users', 'u', field, selects);\n    }\n\n    return selects;\n  }, {objects: [], queries: []});\n\nexport const parseUserOptions = (options: UserOptions = {}) => {\n  const {\n    from = 0,\n    to = 30\n  } = options;\n  const limit = getLimit(from, to);\n\n  return {\n    ...options,\n    limit\n  };\n};\n\nexport const addUser = async (context: ApiContext, user: UserInput): Promise<UserType | null> => {\n  const action = 'addUser';\n  const {databaseName, languageContext} = context;\n  const {confirm: _confirm, ...newUser} = user;\n  const {email, password, phone, username, userId, _key, _id, ...insertUser} = parseUser(newUser);\n  const hasPassword = !!password;\n  const hasUsername = !!username || !!phone || !!email;\n\n  if(!hasPassword || !hasUsername) {\n    logException({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n\n    return null;\n  }\n\n  const hashId = username || phone || email;\n  const salt: string = createHash(`${hashId}${password}`, '');\n  const encryptedPassword = createPassword(password, salt);\n  const filters: string[] = [];\n\n  if(username) {\n    filters.push(`u.username == \"${username}\"`);\n  }\n\n  if(email) {\n    filters.push(`u.email == \"${email}\"`);\n  }\n\n  if(phone) {\n    filters.push(`u.phone == ${phone}`);\n  }\n\n  const checkQuery: string = `FOR u IN users\n    FILTER ${filters.join(' || ')}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    const existingUsers = await useDb(databaseName).query(checkQuery).then((cursor) => cursor.all());\n\n    if(existingUsers.length) {\n      throw logException({\n        action,\n        category: eventCategory,\n        params: {\n          email,\n          phone,\n          username\n        },\n        value: ErrorTypes.EXISTING_ITEM\n      }, context);\n    }\n  } catch(error) {\n    throw logError({\n      action,\n      category: eventCategory,\n      params: {email, phone, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n\n  const phoneCountryCode = phone?.replace(/\\D/g, '').substring(0, 3);\n  const locale = detectLanguage({\n    ...languageContext,\n    phoneCountryCode: phoneCountryCode || '',\n    userPreference: insertUser.locale || 'en'\n  });\n  const verifiedEmailCode: number = Math.floor(100000 + (Math.random() * 900000));\n  const verifiedSmsCode: number = Math.floor(100000 + (Math.random() * 900000));\n\n  const insert: UserType = {\n    ...insertUser,\n    _key: createHash(username),\n    added: Date.now(),\n    email,\n    locale,\n    modified: Date.now(),\n    password: encryptedPassword,\n    phone,\n    salt,\n    userAccess: 1,\n    username,\n    verifiedEmail: false,\n    verifiedEmailCode,\n    verifiedPhone: false,\n    verifiedSmsCode\n  };\n\n  const insertQuery: AqlQuery = aql`INSERT ${insert} IN users RETURN NEW`;\n\n  return await useDb(databaseName).query(insertQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        params: {username},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};\n\nexport const updateUser = async (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'updateUser';\n  const {databaseName} = context;\n  const updatedUser = parseUser(user);\n  const {_key, _id, tags = [], ...update} = updatedUser;\n  const {id} = updatedUser;\n\n  const userQuery: AqlQuery = aql`LET u = DOCUMENT(${id})\n    UPDATE u WITH ${update} IN users\n    RETURN NEW`;\n  try {\n    const database = useDb(databaseName);\n    const updatedUser = await database.query(userQuery).then((cursor) => cursor.next());\n    const tagCollection: EdgeCollection = database.collection('isTagged');\n\n    await Promise.all(tags.map(({id: tagDocId, name}) => {\n      const tagQuery: AqlQuery = aql`FOR it IN isTagged\n        FILTER it._from == ${tagDocId} && it._to == ${id} && it.name == ${name}\n        LIMIT 1\n        RETURN it`;\n\n      return database.query(tagQuery)\n        .then((cursor) => cursor.next())\n        .then((tagEdge) => {\n          if(!!tagEdge) {\n            return tagEdge;\n          }\n\n          const edge = {\n            _from: tagDocId,\n            _key: createHash(`isTagged-${tagDocId}-${id}`),\n            _to: id,\n            added: Date.now(),\n            name\n          };\n\n          return tagCollection.save(edge, {returnNew: true}).then(() => edge);\n        });\n    }));\n\n    return updatedUser;\n  } catch(error) {\n    throw logError({\n      action,\n      category: eventCategory,\n      params: {user},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n};\n\nexport const forgotPassword = async (context: ApiContext, {email, phone, username}): Promise<boolean> => {\n  const action = 'forgotPassword';\n  const {databaseName} = context;\n  const aqlQuery: AqlQuery = aql`FOR u IN users\n    FILTER u.email == ${email} || u.phone == ${phone} || u.username == ${username}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    return await useDb(databaseName).query(aqlQuery)\n      .then(async (cursor) => {\n        const user = cursor.next();\n\n        if(user) {\n          const {email, phone, verifiedEmail, verifiedPhone} = user as UserType;\n          const codeExpires = 1000 * 60 * 15; // 15 minutes\n          const code = Math.floor(100000 + (Math.random() * 900000));\n          const userDocId = getDocId('users', user);\n          let update;\n\n          if(email && verifiedEmail) {\n            sendEmail({\n              context,\n              text: `Your code is ${code}`\n            });\n            update = {verifiedEmailCode: code, verifiedEmailExpires: codeExpires};\n          }\n\n          if(phone && verifiedPhone) {\n            sendSms({\n              context,\n              text: `Your code is ${code}`\n            });\n            update = {verifiedPhoneExpires: codeExpires, verifiedSmsCode: code};\n          }\n\n          if(update.verifiedEmailCode || update.verifiedSmsCode) {\n            const updateQuery: AqlQuery = aql`UPDATE ${userDocId} WITH ${update} IN users`;\n\n            await useDb(databaseName).query(updateQuery);\n\n            return true;\n          }\n\n          return false;\n        }\n\n        return false;\n      });\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {email, phone, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n};\n\nexport const resetPassword = async (\n  context: ApiContext,\n  {\n    code,\n    password,\n    type,\n    username\n  }: {\n    code: number;\n    password: string;\n    type: 'phone' | 'email';\n    username: string;\n  }\n): Promise<boolean> => {\n  const action = 'resetPassword';\n  const {databaseName} = context;\n  const formatPassword: string = parsePassword(password);\n  const aqlQuery: AqlQuery = aql`FOR u IN users\n    FILTER u.username == ${username}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    return await useDb(databaseName).query(aqlQuery)\n      .then(async (cursor) => {\n        const user = cursor.next();\n\n        if(user) {\n          const {\n            _id: userDocId,\n            salt,\n            verifiedEmailCode,\n            verifiedEmailExpires = 0,\n            verifiedSmsCode,\n            verifiedPhoneExpires = 0\n          } = user as UserType;\n          const now = Date.now();\n          let update;\n\n          switch(type) {\n            case 'email':\n              if(code === verifiedEmailCode && verifiedEmailExpires > now) {\n                const password: string = createPassword(formatPassword, salt);\n                update = {password};\n              }\n              break;\n            case 'phone':\n              if(code === verifiedSmsCode && verifiedPhoneExpires > now) {\n                const password: string = createPassword(formatPassword, salt);\n                update = {password};\n              }\n              break;\n            default:\n              return false;\n          }\n\n          if(update) {\n            const updateQuery: AqlQuery = aql`UPDATE ${userDocId} WITH ${update} IN users`;\n\n            await useDb(databaseName).query(updateQuery);\n\n            return true;\n          }\n        }\n\n        return false;\n      });\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n};\n\nexport const confirmCode = async (\n  context: ApiContext,\n  {\n    code,\n    type,\n    value\n  }: {\n    code: number;\n    type: 'sms' | 'email';\n    value: string;\n  }\n): Promise<boolean> => {\n  const action = 'confirmCode';\n  const {databaseName} = context;\n  const isSms = type === 'sms';\n  const formattedValue = isSms ? parsePhone(value) : parseEmail(value);\n  const filterByType = isSms\n    ? `FILTER u.phone == \"${formattedValue}\" && u.verifiedSmsCode == ${code}`\n    : `FILTER u.email == \"${formattedValue}\" && u.verifiedEmailCode == ${code}`;\n  const aqlQuery: string = `FOR u IN users\n    ${filterByType}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    return await useDb(databaseName).query(aqlQuery)\n      .then((cursor) => cursor.next())\n      .then((user) => {\n        if(user) {\n          const updatedUser = isSms\n            ? {verifiedPhone: true, verifiedSmsCode: 0}\n            : {verifiedEmail: true, verifiedEmailCode: 0};\n          const aqlQuery: AqlQuery = aql`UPDATE ${user._key} WITH ${updatedUser} IN users`;\n\n          return useDb(databaseName).query(aqlQuery)\n            .then(() => true)\n            .catch((error: Error) => {\n              logError({\n                action,\n                category: eventCategory,\n                params: {code, type, value: formattedValue},\n                value: ErrorTypes.DATABASE_ERROR\n              }, error, context);\n\n              return false;\n            });\n        }\n\n        return false;\n      });\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {code, type, value: formattedValue},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n};\n\nexport const deleteUser = (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'deleteUser';\n  const {databaseName} = context;\n  const {id} = parseUser(user);\n\n  const aqlQuery: AqlQuery = aql`LET u = DOCUMENT(${id})\n    REMOVE u IN users\n    RETURN OLD`;\n\n  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion: STRIPE_API_VERSION, typescript: true});\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .then((deletedUser) => stripeClient.customers.del(deletedUser?.stripeCustomerId)\n      .then(() => stripeClient.accounts.del(deletedUser?.stripeAccountId))\n      .then(() => deletedUser))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {id},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const deactivateUser = (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'delete';\n  const {databaseName} = context;\n  const {id} = parseUser(user);\n  const updated: UserType = {\n    userAccess: 0\n  };\n  const aqlQuery: AqlQuery = aql`UPDATE ${id} WITH ${updated} IN users LIMIT 1 RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw logError({\n      action,\n      category: eventCategory,\n      params: {id},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  });\n};\n\nexport const getDisplayName = (user: UserType): string => {\n  const {first, last, name = '', username = ''} = user;\n  const fullname = ([first, last]).join(' ').trim();\n\n  if(name) {\n    return name;\n  } else if(fullname !== '') {\n    return fullname;\n  } else if(username) {\n    return username;\n  }\n\n  return 'Unknown';\n};\n\nexport const getSessionUser = (context: ApiContext): Promise<UserType> => {\n  const action = 'getSessionUser';\n  const {databaseName, fields, session: {userId: sessionId, username} = {}} = context;\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const formatSessionId = parseArangoId(`users/${sessionId}`);\n\n  const aqlQuery: string = `LET u = DOCUMENT(\"${formatSessionId}\")\n  ${selectQueries.join('\\n')}\n  RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.next() as unknown as UserType)\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        params: {userId: sessionId, username},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};\n\nexport const getUser = (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'getUser';\n  const {email, id, phone, userId, username} = parseUser(user);\n  const {databaseName, fields} = context;\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  let aqlQuery: string = '';\n\n  if(id) {\n    aqlQuery = `LET u = DOCUMENT(\"${id}\")\n    ${selectQueries.join('\\n')}\n    FILTER u.userAccess > 0\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n  } else if(username) {\n    aqlQuery = `FOR u IN users\n    FILTER u.username == \"${username}\"\n    ${selectQueries.join('\\n')}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n  } else if(email) {\n    aqlQuery = `FOR u IN users\n    FILTER u.email == \"${email}\"\n    ${selectQueries.join('\\n')}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n  } else if(phone) {\n    aqlQuery = `FOR u IN users\n    FILTER u.phone == \"${phone}\"\n    ${selectQueries.join('\\n')}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n  }\n\n  return useDb(databaseName)\n    .query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .then((user) => user)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {id, userId, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getUsers = (context: ApiContext, options?: UserOptions): Promise<UserType[]> => {\n  const action = 'getUserList';\n  const {databaseName, fields} = context;\n  const {limit, username} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const filterBy: string[] = ['u.userAccess > 0'];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\n  const aqlQuery: string = `FOR u IN users\n    FILTER ${filterBy.join(' && ')}\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT u.username\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByReactions = (\n  context: ApiContext,\n  {reactions = [], username}: {reactions?: string[]; username?: string},\n  options?: UserOptions\n): Promise<UserType[]> => {\n  const action = 'getUsersByReactions';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const formatReactions: string[] = reactions.map((reactionName: string) => parseChar(reactionName, 32).toLowerCase());\n  const {limit} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatUsername: string = parseUsername(username);\n  const filterBy: string[] = [\n    'u.userAccess > 0',\n    `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`\n  ];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${formatUsername}\")`);\n  }\n\n  const aqlQuery: string = `FOR u, r IN OUTBOUND \"${formatSessionId}\" hasReaction\n    OPTIONS {vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByTags = (\n  context: ApiContext,\n  {tags, username},\n  options?: UserOptions\n): Promise<UserType[]> => {\n  const action = 'getUsersByTags';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const formatTags: string[] = tags?.reduce((list: string[], tagName: string) => {\n    if(tagName) {\n      list.push(parseChar(tagName, 32).toLowerCase());\n    }\n\n    return list;\n  }, []);\n  const {limit} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const formatUsername: string = parseUsername(username);\n  const filterBy: string[] = [\n    `u._key != \"${sessionId}\"`,\n    'u.userAccess > 0'\n  ];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${formatUsername}\")`);\n  }\n\n  const aqlQuery: string = `FOR t IN tags\n    FILTER POSITION(${JSON.stringify(formatTags)}, LOWER(t.name))\n    FOR u, it IN OUTBOUND t isTagged\n    OPTIONS {bfs: true, uniqueVertices: \"global\", vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByLatest = (context: ApiContext, {username}, options?: UserOptions): Promise<UserType[]> => {\n  const action = 'getUsersByLatest';\n  const {databaseName, fields, session: {userId} = {}} = context;\n  const {limit} = parseUserOptions(options);\n  const filter = [\n    'u._id != session._id',\n    'u.userAccess > 0'\n  ];\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  if(username) {\n    filter.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\n  // Get data from database\n  const aqlQuery: string = `FOR u IN users\n    LET session = DOCUMENT(\"users/${userId}\")\n    FILTER ${filter.join(' && ')}\n    ${selectQueries.join('\\n')}\n    LET distance = DISTANCE(u.latitude || 0, u.longitude || 0, session.latitude || 0, session.longitude || 0)\n    ${limit.aql}\n    SORT distance ASC, u.added DESC\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByConnection = (\n  context: ApiContext,\n  {userId}: UserType,\n  options?: UserOptions\n): Promise<UserType[]> => {\n  const action = 'getUsersByConnection';\n  const {databaseName, fields} = context;\n  const {limit, username} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const formatUserId: string = parseArangoId(`users/${userId}`);\n  const filterBy: string[] = [\n    'u.userAccess > 0'\n  ];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\n  const aqlQuery: string = `FOR cu IN users\n    LET session = DOCUMENT(\"${formatUserId}\")\n    FOR u, connection IN OUTBOUND cu hasConnection\n    OPTIONS {bfs: true, uniqueVertices: \"global\", vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const refreshSession = ({expires, token}): SessionToken | SessionError => {\n  try {\n    const {userId, username, userAccess} = getSession(token);\n    return createToken(userId, username, userAccess, expires);\n  } catch(error) {\n    throw error; // Re-throw the error from getSession\n  }\n};\n\nexport const signIn = async (context: ApiContext, args): Promise<SessionToken | null> => {\n  const action = 'signIn';\n  const {databaseName} = context;\n  const {email, expires, password, phone, username} = args;\n  const formatEmail: string = parseEmail(email);\n  const formatUsername: string = parseUsername(username);\n  const formatPassword: string = parsePassword(password);\n  const formatPhone: string = parsePhone(phone);\n  const formatExpires: number = parseNum(expires) || 15;\n\n  if((!formatUsername && !formatEmail && !formatPhone) || !formatPassword) {\n    throw logException({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n  }\n\n  const filters: string[] = [];\n\n  if(formatEmail) {\n    filters.push(`u.email == \"${formatEmail}\"`);\n  }\n\n  if(formatPhone) {\n    filters.push(`u.phone == ${formatPhone}`);\n  }\n\n  if(formatUsername) {\n    filters.push(`u.username == \"${formatUsername}\"`);\n  }\n\n  const checkQuery: string = `FOR u IN users\n    FILTER ${filters.join(' || ')}\n    LIMIT 1\n    RETURN u`;\n\n  let checkUser: UserType;\n\n  try {\n    checkUser = await useDb(databaseName).query(checkQuery).then((cursor) => cursor.next());\n  } catch(error) {\n    throw logError({\n      action,\n      category: eventCategory,\n      params: {username: formatUsername},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n\n  if(!checkUser) {\n    throw logException({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.INVALID_AUTHENTICATION\n    }, context);\n  }\n\n  const {_key: userId, password: validPassword, salt, userAccess} = checkUser as UserType;\n  const authPassword: string = createPassword(formatPassword, salt);\n\n  console.log({\n    createPassword,\n    authPassword,\n    validPassword,\n    formatPassword,\n    salt\n  });\n\n  if(validPassword !== authPassword) {\n    throw logException({\n      action,\n      category: eventCategory,\n      params: {userAccess, userId, username},\n      value: ErrorTypes.INVALID_AUTHENTICATION\n    }, context);\n  }\n\n  try {\n    const token = createToken(userId || '', username || '', userAccess, formatExpires);\n\n    return token;\n  } catch(error) {\n    throw logError({\n      action,\n      category: eventCategory,\n      params: {userId, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n};\n\nexport const signOut = async (context: ApiContext): Promise<boolean> => {\n  const action = 'signOut';\n  const {databaseName, session: {userId: sessionId, username} = {}} = context;\n  const userDocId: string = `users/${sessionId}`;\n\n  const update = {\n    lastOnline: Date.now(),\n    sessionId: null\n  };\n  const sessionQuery: AqlQuery = aql`LET u = DOCUMENT(${userDocId})\n    UPDATE u WITH ${update} IN users\n    LIMIT 1\n    RETURN NEW`;\n\n  try {\n    await useDb(databaseName).query(sessionQuery).then((cursor) => cursor.next());\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {userId: sessionId, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n\n  return true;\n};\n\nexport const getActiveUserCount = (context: ApiContext): Promise<number> => {\n  const action = 'getActiveUserCount';\n  const {databaseName} = context;\n  const countQuery: AqlQuery = aql`LET docs = (\n    FOR u IN users\n    FILTER u.active == true\n    RETURN u\n  )\n  RETURN LENGTH(docs)`;\n\n  return useDb(databaseName).query(countQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};\n\nexport const getUserByToken = (context: ApiContext, token: string): Promise<UserType> => {\n  const action = 'getUserByToken';\n  const {databaseName} = context;\n  const {userId} = getSession(token);\n  const userDocId = parseArangoId(`users/${userId}`);\n  const aqlQuery: AqlQuery = aql`LET u = DOCUMENT(\"${userDocId}\") RETURN u`;\n\n  return useDb(databaseName)\n    .query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        params: {userId},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};"],"names":["parseNum","createHash","createPassword","parseArangoId","parseChar","parseEmail","parsePassword","parsePhone","parseUsername","aql","DateTime","Stripe","parseUser","Config","ErrorTypes","logError","logException","getDocId","getLimit","selectReactionCountByType","useDb","detectLanguage","getSession","setSession","sendEmail","sendSms","eventCategory","STRIPE_API_VERSION","UserAccess","createToken","userId","username","userAccess","expiresInMinutes","now","local","sessionExpires","plus","minutes","iat","Math","floor","toSeconds","exp","token","expires","toMillis","issued","getUserOptional","fields","reduce","selects","field","includes","objects","queries","parseUserOptions","options","from","to","limit","addUser","context","user","action","databaseName","languageContext","confirm","_confirm","newUser","email","password","phone","_key","_id","insertUser","hasPassword","hasUsername","category","params","value","INVALID_ARGUMENTS","hashId","salt","encryptedPassword","filters","push","checkQuery","join","existingUsers","query","then","cursor","all","length","EXISTING_ITEM","error","DATABASE_ERROR","phoneCountryCode","replace","substring","locale","userPreference","verifiedEmailCode","random","verifiedSmsCode","insert","added","Date","modified","verifiedEmail","verifiedPhone","insertQuery","next","catch","updateUser","updatedUser","tags","update","id","userQuery","database","tagCollection","collection","Promise","map","tagDocId","name","tagQuery","tagEdge","edge","_from","_to","save","returnNew","forgotPassword","aqlQuery","codeExpires","code","userDocId","text","verifiedEmailExpires","verifiedPhoneExpires","updateQuery","resetPassword","type","formatPassword","confirmCode","isSms","formattedValue","filterByType","deleteUser","stripeClient","get","apiVersion","typescript","deletedUser","customers","del","stripeCustomerId","accounts","stripeAccountId","deactivateUser","updated","getDisplayName","first","last","fullname","trim","getSessionUser","session","sessionId","selectObjects","selectQueries","formatSessionId","getUser","getUsers","filterBy","getUsersByReactions","reactions","formatReactions","reactionName","toLowerCase","formatUsername","JSON","stringify","getUsersByTags","formatTags","list","tagName","getUsersByLatest","filter","getUsersByConnection","formatUserId","refreshSession","signIn","args","formatEmail","formatPhone","formatExpires","checkUser","INVALID_AUTHENTICATION","validPassword","authPassword","console","log","signOut","lastOnline","sessionQuery","getActiveUserCount","countQuery","getUserByToken"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,QAAQ,QAAO,+BAA+B;AACtD,SACEC,UAAU,EACVC,cAAc,EACdC,aAAa,EACbC,SAAS,EACTC,UAAU,EACVC,aAAa,EACbC,UAAU,EACVC,aAAa,QACR,+BAA+B;AACtC,SAAQC,GAAG,QAAO,WAAW;AAC7B,SAAQC,QAAQ,QAAO,QAAQ;AAC/B,OAAOC,YAAY,SAAS;AAE5B,SAAQC,SAAS,QAAO,6BAA6B;AACrD,SAAQC,MAAM,QAAO,eAAe;AACpC,SAAQC,UAAU,QAA0B,0BAA0B;AACtE,SAAQC,QAAQ,EAAEC,YAAY,QAAO,6BAA6B;AAClE,SAAQC,QAAQ,EAAEC,QAAQ,EAAEC,yBAAyB,EAAEC,KAAK,QAAO,4BAA4B;AAC/F,SAAQC,cAAc,QAAO,gCAAgC;AAC7D,SAAQC,UAAU,EAAEC,UAAU,QAA0B,2BAA2B;AACnF,SAAQC,SAAS,QAAO,aAAa;AACrC,SAAQC,OAAO,QAAO,WAAW;AAOjC,MAAMC,gBAAgB;AACtB,MAAMC,qBAAqB;AAQ3B,OAAO,IAAA,AAAKC,oCAAAA;;;;;;WAAAA;MAMX;AAED,OAAO,MAAMC,cAAc,CACzBC,QACAC,WAAmB,EAAE,EACrBC,aAAqB,CAAC,EACtBC,mBAA2B,EAAE;IAE7B,MAAMC,MAAgBxB,SAASyB,KAAK;IACpC,MAAMC,iBAA2BF,IAAIG,IAAI,CAAC;QAACC,SAASL;IAAgB;IACpE,MAAMM,MAAcC,KAAKC,KAAK,CAACP,IAAIQ,SAAS;IAC5C,MAAMC,MAAcH,KAAKC,KAAK,CAACL,eAAeM,SAAS;IACvD,MAAME,QAAQrB,WAAW;QACvBoB;QACAJ;QACAP;QACAF;QACAC;IACF;IAEA,OAAO;QACLc,SAAST,eAAeU,QAAQ;QAChCC,QAAQb,IAAIY,QAAQ;QACpBF;QACAd;QACAC;IACF;AACF,EAAE;AAOF,OAAO,MAAMiB,kBAAkB,CAACC,SAAmB,EAAE,GACnDA,OAAOC,MAAM,CAAC,CAACC,SAA4BC;QACzC,IAAGA,MAAMC,QAAQ,CAAC,UAAU;YAC1B,OAAOlC,0BAA0B,SAAS,KAAKiC,OAAOD;QACxD;QAEA,OAAOA;IACT,GAAG;QAACG,SAAS,EAAE;QAAEC,SAAS,EAAE;IAAA,GAAG;AAEjC,OAAO,MAAMC,mBAAmB,CAACC,UAAuB,CAAC,CAAC;IACxD,MAAM,EACJC,OAAO,CAAC,EACRC,KAAK,EAAE,EACR,GAAGF;IACJ,MAAMG,QAAQ1C,SAASwC,MAAMC;IAE7B,OAAO;QACL,GAAGF,OAAO;QACVG;IACF;AACF,EAAE;AAEF,OAAO,MAAMC,UAAU,OAAOC,SAAqBC;IACjD,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAEC,eAAe,EAAC,GAAGJ;IACxC,MAAM,EAACK,SAASC,QAAQ,EAAE,GAAGC,SAAQ,GAAGN;IACxC,MAAM,EAACO,KAAK,EAAEC,QAAQ,EAAEC,KAAK,EAAEzC,QAAQ,EAAED,MAAM,EAAE2C,IAAI,EAAEC,GAAG,EAAE,GAAGC,YAAW,GAAG/D,UAAUyD;IACvF,MAAMO,cAAc,CAAC,CAACL;IACtB,MAAMM,cAAc,CAAC,CAAC9C,YAAY,CAAC,CAACyC,SAAS,CAAC,CAACF;IAE/C,IAAG,CAACM,eAAe,CAACC,aAAa;QAC/B7D,aAAa;YACXgD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChD;YAAQ;YACjBiD,OAAOlE,WAAWmE,iBAAiB;QACrC,GAAGnB;QAEH,OAAO;IACT;IAEA,MAAMoB,SAASnD,YAAYyC,SAASF;IACpC,MAAMa,OAAelF,WAAW,GAAGiF,SAASX,UAAU,EAAE;IACxD,MAAMa,oBAAoBlF,eAAeqE,UAAUY;IACnD,MAAME,UAAoB,EAAE;IAE5B,IAAGtD,UAAU;QACXsD,QAAQC,IAAI,CAAC,CAAC,eAAe,EAAEvD,SAAS,CAAC,CAAC;IAC5C;IAEA,IAAGuC,OAAO;QACRe,QAAQC,IAAI,CAAC,CAAC,YAAY,EAAEhB,MAAM,CAAC,CAAC;IACtC;IAEA,IAAGE,OAAO;QACRa,QAAQC,IAAI,CAAC,CAAC,WAAW,EAAEd,OAAO;IACpC;IAEA,MAAMe,aAAqB,CAAC;WACnB,EAAEF,QAAQG,IAAI,CAAC,QAAQ;;YAEtB,CAAC;IAEX,IAAI;QACF,MAAMC,gBAAgB,MAAMrE,MAAM6C,cAAcyB,KAAK,CAACH,YAAYI,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG;QAE7F,IAAGJ,cAAcK,MAAM,EAAE;YACvB,MAAM9E,aAAa;gBACjBgD;gBACAc,UAAUpD;gBACVqD,QAAQ;oBACNT;oBACAE;oBACAzC;gBACF;gBACAiD,OAAOlE,WAAWiF,aAAa;YACjC,GAAGjC;QACL;IACF,EAAE,OAAMkC,OAAO;QACb,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACT;gBAAOE;gBAAOzC;YAAQ;YAC/BiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;IAEA,MAAMoC,mBAAmB1B,OAAO2B,QAAQ,OAAO,IAAIC,UAAU,GAAG;IAChE,MAAMC,SAAShF,eAAe;QAC5B,GAAG6C,eAAe;QAClBgC,kBAAkBA,oBAAoB;QACtCI,gBAAgB3B,WAAW0B,MAAM,IAAI;IACvC;IACA,MAAME,oBAA4B/D,KAAKC,KAAK,CAAC,SAAUD,KAAKgE,MAAM,KAAK;IACvE,MAAMC,kBAA0BjE,KAAKC,KAAK,CAAC,SAAUD,KAAKgE,MAAM,KAAK;IAErE,MAAME,SAAmB;QACvB,GAAG/B,UAAU;QACbF,MAAMxE,WAAW8B;QACjB4E,OAAOC,KAAK1E,GAAG;QACfoC;QACA+B;QACAQ,UAAUD,KAAK1E,GAAG;QAClBqC,UAAUa;QACVZ;QACAW;QACAnD,YAAY;QACZD;QACA+E,eAAe;QACfP;QACAQ,eAAe;QACfN;IACF;IAEA,MAAMO,cAAwBvG,GAAG,CAAC,OAAO,EAAEiG,OAAO,oBAAoB,CAAC;IAEvE,OAAO,MAAMtF,MAAM6C,cAAcyB,KAAK,CAACsB,aACpCrB,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BC,KAAK,CAAC,CAAClB;QACN,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChD;YAAQ;YACjBiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACJ,EAAE;AAEF,OAAO,MAAMqD,aAAa,OAAOrD,SAAqBC;IACpD,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAMsD,cAAcxG,UAAUmD;IAC9B,MAAM,EAACU,IAAI,EAAEC,GAAG,EAAE2C,OAAO,EAAE,EAAE,GAAGC,QAAO,GAAGF;IAC1C,MAAM,EAACG,EAAE,EAAC,GAAGH;IAEb,MAAMI,YAAsB/G,GAAG,CAAC,iBAAiB,EAAE8G,GAAG;kBACtC,EAAED,OAAO;cACb,CAAC;IACb,IAAI;QACF,MAAMG,WAAWrG,MAAM6C;QACvB,MAAMmD,cAAc,MAAMK,SAAS/B,KAAK,CAAC8B,WAAW7B,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI;QAChF,MAAMS,gBAAgCD,SAASE,UAAU,CAAC;QAE1D,MAAMC,QAAQ/B,GAAG,CAACwB,KAAKQ,GAAG,CAAC,CAAC,EAACN,IAAIO,QAAQ,EAAEC,IAAI,EAAC;YAC9C,MAAMC,WAAqBvH,GAAG,CAAC;2BACV,EAAEqH,SAAS,cAAc,EAAEP,GAAG,eAAe,EAAEQ,KAAK;;iBAE9D,CAAC;YAEZ,OAAON,SAAS/B,KAAK,CAACsC,UACnBrC,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BtB,IAAI,CAAC,CAACsC;gBACL,IAAG,CAAC,CAACA,SAAS;oBACZ,OAAOA;gBACT;gBAEA,MAAMC,OAAO;oBACXC,OAAOL;oBACPrD,MAAMxE,WAAW,CAAC,SAAS,EAAE6H,SAAS,CAAC,EAAEP,IAAI;oBAC7Ca,KAAKb;oBACLZ,OAAOC,KAAK1E,GAAG;oBACf6F;gBACF;gBAEA,OAAOL,cAAcW,IAAI,CAACH,MAAM;oBAACI,WAAW;gBAAI,GAAG3C,IAAI,CAAC,IAAMuC;YAChE;QACJ;QAEA,OAAOd;IACT,EAAE,OAAMpB,OAAO;QACb,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChB;YAAI;YACbiB,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACF,EAAE;AAEF,OAAO,MAAMyE,iBAAiB,OAAOzE,SAAqB,EAACQ,KAAK,EAAEE,KAAK,EAAEzC,QAAQ,EAAC;IAChF,MAAMiC,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM0E,WAAqB/H,GAAG,CAAC;sBACX,EAAE6D,MAAM,eAAe,EAAEE,MAAM,kBAAkB,EAAEzC,SAAS;;YAEtE,CAAC;IAEX,IAAI;QACF,OAAO,MAAMX,MAAM6C,cAAcyB,KAAK,CAAC8C,UACpC7C,IAAI,CAAC,OAAOC;YACX,MAAM7B,OAAO6B,OAAOqB,IAAI;YAExB,IAAGlD,MAAM;gBACP,MAAM,EAACO,KAAK,EAAEE,KAAK,EAAEsC,aAAa,EAAEC,aAAa,EAAC,GAAGhD;gBACrD,MAAM0E,cAAc,OAAO,KAAK,IAAI,aAAa;gBACjD,MAAMC,OAAOlG,KAAKC,KAAK,CAAC,SAAUD,KAAKgE,MAAM,KAAK;gBAClD,MAAMmC,YAAY1H,SAAS,SAAS8C;gBACpC,IAAIuD;gBAEJ,IAAGhD,SAASwC,eAAe;oBACzBtF,UAAU;wBACRsC;wBACA8E,MAAM,CAAC,aAAa,EAAEF,MAAM;oBAC9B;oBACApB,SAAS;wBAACf,mBAAmBmC;wBAAMG,sBAAsBJ;oBAAW;gBACtE;gBAEA,IAAGjE,SAASuC,eAAe;oBACzBtF,QAAQ;wBACNqC;wBACA8E,MAAM,CAAC,aAAa,EAAEF,MAAM;oBAC9B;oBACApB,SAAS;wBAACwB,sBAAsBL;wBAAahC,iBAAiBiC;oBAAI;gBACpE;gBAEA,IAAGpB,OAAOf,iBAAiB,IAAIe,OAAOb,eAAe,EAAE;oBACrD,MAAMsC,cAAwBtI,GAAG,CAAC,OAAO,EAAEkI,UAAU,MAAM,EAAErB,OAAO,SAAS,CAAC;oBAE9E,MAAMlG,MAAM6C,cAAcyB,KAAK,CAACqD;oBAEhC,OAAO;gBACT;gBAEA,OAAO;YACT;YAEA,OAAO;QACT;IACJ,EAAE,OAAM/C,OAAO;QACbjF,SAAS;YACPiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACT;gBAAOE;gBAAOzC;YAAQ;YAC/BiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO;IACT;AACF,EAAE;AAEF,OAAO,MAAMkF,gBAAgB,OAC3BlF,SACA,EACE4E,IAAI,EACJnE,QAAQ,EACR0E,IAAI,EACJlH,QAAQ,EAMT;IAED,MAAMiC,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAMoF,iBAAyB5I,cAAciE;IAC7C,MAAMiE,WAAqB/H,GAAG,CAAC;yBACR,EAAEsB,SAAS;;YAExB,CAAC;IAEX,IAAI;QACF,OAAO,MAAMX,MAAM6C,cAAcyB,KAAK,CAAC8C,UACpC7C,IAAI,CAAC,OAAOC;YACX,MAAM7B,OAAO6B,OAAOqB,IAAI;YAExB,IAAGlD,MAAM;gBACP,MAAM,EACJW,KAAKiE,SAAS,EACdxD,IAAI,EACJoB,iBAAiB,EACjBsC,uBAAuB,CAAC,EACxBpC,eAAe,EACfqC,uBAAuB,CAAC,EACzB,GAAG/E;gBACJ,MAAM7B,MAAM0E,KAAK1E,GAAG;gBACpB,IAAIoF;gBAEJ,OAAO2B;oBACL,KAAK;wBACH,IAAGP,SAASnC,qBAAqBsC,uBAAuB3G,KAAK;4BAC3D,MAAMqC,WAAmBrE,eAAegJ,gBAAgB/D;4BACxDmC,SAAS;gCAAC/C;4BAAQ;wBACpB;wBACA;oBACF,KAAK;wBACH,IAAGmE,SAASjC,mBAAmBqC,uBAAuB5G,KAAK;4BACzD,MAAMqC,WAAmBrE,eAAegJ,gBAAgB/D;4BACxDmC,SAAS;gCAAC/C;4BAAQ;wBACpB;wBACA;oBACF;wBACE,OAAO;gBACX;gBAEA,IAAG+C,QAAQ;oBACT,MAAMyB,cAAwBtI,GAAG,CAAC,OAAO,EAAEkI,UAAU,MAAM,EAAErB,OAAO,SAAS,CAAC;oBAE9E,MAAMlG,MAAM6C,cAAcyB,KAAK,CAACqD;oBAEhC,OAAO;gBACT;YACF;YAEA,OAAO;QACT;IACJ,EAAE,OAAM/C,OAAO;QACbjF,SAAS;YACPiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChD;YAAQ;YACjBiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO;IACT;AACF,EAAE;AAEF,OAAO,MAAMqF,cAAc,OACzBrF,SACA,EACE4E,IAAI,EACJO,IAAI,EACJjE,KAAK,EAKN;IAED,MAAMhB,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAMsF,QAAQH,SAAS;IACvB,MAAMI,iBAAiBD,QAAQ7I,WAAWyE,SAAS3E,WAAW2E;IAC9D,MAAMsE,eAAeF,QACjB,CAAC,mBAAmB,EAAEC,eAAe,0BAA0B,EAAEX,MAAM,GACvE,CAAC,mBAAmB,EAAEW,eAAe,4BAA4B,EAAEX,MAAM;IAC7E,MAAMF,WAAmB,CAAC;IACxB,EAAEc,aAAa;;YAEP,CAAC;IAEX,IAAI;QACF,OAAO,MAAMlI,MAAM6C,cAAcyB,KAAK,CAAC8C,UACpC7C,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BtB,IAAI,CAAC,CAAC5B;YACL,IAAGA,MAAM;gBACP,MAAMqD,cAAcgC,QAChB;oBAACrC,eAAe;oBAAMN,iBAAiB;gBAAC,IACxC;oBAACK,eAAe;oBAAMP,mBAAmB;gBAAC;gBAC9C,MAAMiC,WAAqB/H,GAAG,CAAC,OAAO,EAAEsD,KAAKU,IAAI,CAAC,MAAM,EAAE2C,YAAY,SAAS,CAAC;gBAEhF,OAAOhG,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,IAAM,MACXuB,KAAK,CAAC,CAAClB;oBACNjF,SAAS;wBACPiD;wBACAc,UAAUpD;wBACVqD,QAAQ;4BAAC2D;4BAAMO;4BAAMjE,OAAOqE;wBAAc;wBAC1CrE,OAAOlE,WAAWmF,cAAc;oBAClC,GAAGD,OAAOlC;oBAEV,OAAO;gBACT;YACJ;YAEA,OAAO;QACT;IACJ,EAAE,OAAMkC,OAAO;QACbjF,SAAS;YACPiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAC2D;gBAAMO;gBAAMjE,OAAOqE;YAAc;YAC1CrE,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO;IACT;AACF,EAAE;AAEF,OAAO,MAAMyF,aAAa,CAACzF,SAAqBC;IAC9C,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM,EAACyD,EAAE,EAAC,GAAG3G,UAAUmD;IAEvB,MAAMyE,WAAqB/H,GAAG,CAAC,iBAAiB,EAAE8G,GAAG;;cAEzC,CAAC;IAEb,MAAMiC,eAAe,IAAI7I,OAAOE,OAAO4I,GAAG,CAAC,iBAAiB;QAACC,YAAY/H;QAAoBgI,YAAY;IAAI;IAE7G,OAAOvI,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BtB,IAAI,CAAC,CAACiE,cAAgBJ,aAAaK,SAAS,CAACC,GAAG,CAACF,aAAaG,kBAC5DpE,IAAI,CAAC,IAAM6D,aAAaQ,QAAQ,CAACF,GAAG,CAACF,aAAaK,kBAClDtE,IAAI,CAAC,IAAMiE,cACb1C,KAAK,CAAC,CAAClB,QAAiBjF,SAAS;YAChCiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACwC;YAAE;YACXvC,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;AACd,EAAE;AAEF,OAAO,MAAMoG,iBAAiB,CAACpG,SAAqBC;IAClD,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM,EAACyD,EAAE,EAAC,GAAG3G,UAAUmD;IACvB,MAAMoG,UAAoB;QACxBnI,YAAY;IACd;IACA,MAAMwG,WAAqB/H,GAAG,CAAC,OAAO,EAAE8G,GAAG,MAAM,EAAE4C,QAAQ,4BAA4B,CAAC;IAExF,OAAO/I,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BC,KAAK,CAAC,CAAClB;QACN,MAAMjF,SAAS;YACfiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACwC;YAAE;YACXvC,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACF,EAAE;AAEF,OAAO,MAAMsG,iBAAiB,CAACrG;IAC7B,MAAM,EAACsG,KAAK,EAAEC,IAAI,EAAEvC,OAAO,EAAE,EAAEhG,WAAW,EAAE,EAAC,GAAGgC;IAChD,MAAMwG,WAAW,AAAC;QAACF;QAAOC;KAAK,CAAE9E,IAAI,CAAC,KAAKgF,IAAI;IAE/C,IAAGzC,MAAM;QACP,OAAOA;IACT,OAAO,IAAGwC,aAAa,IAAI;QACzB,OAAOA;IACT,OAAO,IAAGxI,UAAU;QAClB,OAAOA;IACT;IAEA,OAAO;AACT,EAAE;AAEF,OAAO,MAAM0I,iBAAiB,CAAC3G;IAC7B,MAAME,SAAS;IACf,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAEyH,SAAS,EAAC5I,QAAQ6I,SAAS,EAAE5I,QAAQ,EAAC,GAAG,CAAC,CAAC,EAAC,GAAG+B;IAC5E,MAAM,EAACR,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IACzE,MAAM6H,kBAAkB3K,cAAc,CAAC,MAAM,EAAEwK,WAAW;IAE1D,MAAMnC,WAAmB,CAAC,kBAAkB,EAAEsC,gBAAgB;EAC9D,EAAED,cAAcrF,IAAI,CAAC,MAAM;mBACV,EAAEoF,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IAE/C,OAAOpE,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BC,KAAK,CAAC,CAAClB;QACN,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACjD,QAAQ6I;gBAAW5I;YAAQ;YACpCiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACJ,EAAE;AAEF,OAAO,MAAMiH,UAAU,CAACjH,SAAqBC;IAC3C,MAAMC,SAAS;IACf,MAAM,EAACM,KAAK,EAAEiD,EAAE,EAAE/C,KAAK,EAAE1C,MAAM,EAAEC,QAAQ,EAAC,GAAGnB,UAAUmD;IACvD,MAAM,EAACE,YAAY,EAAEhB,MAAM,EAAC,GAAGa;IAC/B,MAAM,EAACR,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IACzE,IAAIuF,WAAmB;IAEvB,IAAGjB,IAAI;QACLiB,WAAW,CAAC,kBAAkB,EAAEjB,GAAG;IACnC,EAAEsD,cAAcrF,IAAI,CAAC,MAAM;;qBAEV,EAAEoF,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IACjD,OAAO,IAAGzD,UAAU;QAClByG,WAAW,CAAC;0BACU,EAAEzG,SAAS;IACjC,EAAE8I,cAAcrF,IAAI,CAAC,MAAM;qBACV,EAAEoF,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IACjD,OAAO,IAAGlB,OAAO;QACfkE,WAAW,CAAC;uBACO,EAAElE,MAAM;IAC3B,EAAEuG,cAAcrF,IAAI,CAAC,MAAM;qBACV,EAAEoF,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IACjD,OAAO,IAAGhB,OAAO;QACfgE,WAAW,CAAC;uBACO,EAAEhE,MAAM;IAC3B,EAAEqG,cAAcrF,IAAI,CAAC,MAAM;qBACV,EAAEoF,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IACjD;IAEA,OAAOpE,MAAM6C,cACVyB,KAAK,CAAC8C,UACN7C,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BtB,IAAI,CAAC,CAAC5B,OAASA,MACfmD,KAAK,CAAC,CAAClB,QAAiBjF,SAAS;YAChCiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACwC;gBAAIzF;gBAAQC;YAAQ;YAC7BiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;AACd,EAAE;AAEF,OAAO,MAAMkH,WAAW,CAAClH,SAAqBL;IAC5C,MAAMO,SAAS;IACf,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAC,GAAGa;IAC/B,MAAM,EAACF,KAAK,EAAE7B,QAAQ,EAAC,GAAGyB,iBAAiBC;IAC3C,MAAM,EAACH,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IACzE,MAAMgI,WAAqB;QAAC;KAAmB;IAE/C,IAAGlJ,UAAU;QACXkJ,SAAS3F,IAAI,CAAC,CAAC,sBAAsB,EAAE9E,cAAcuB,UAAU,EAAE,CAAC;IACpE;IAEA,MAAMyG,WAAmB,CAAC;WACjB,EAAEyC,SAASzF,IAAI,CAAC,QAAQ;IAC/B,EAAEqF,cAAcrF,IAAI,CAAC,MAAM;IAC3B,EAAE5B,MAAMnD,GAAG,CAAC;;qBAEK,EAAEmK,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IAEjD,OAAOpE,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG,IAC3BqB,KAAK,CAAC,CAAClB;QACNjF,SAAS;YACPiD;YACAc,UAAUpD;YACVsD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMoH,sBAAsB,CACjCpH,SACA,EAACqH,YAAY,EAAE,EAAEpJ,QAAQ,EAA4C,EACrE0B;IAEA,MAAMO,SAAS;IACf,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAEyH,SAAS,EAAC5I,QAAQ6I,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAG7G;IAClE,MAAMsH,kBAA4BD,UAAUtD,GAAG,CAAC,CAACwD,eAAyBjL,UAAUiL,cAAc,IAAIC,WAAW;IACjH,MAAM,EAAC1H,KAAK,EAAC,GAAGJ,iBAAiBC;IACjC,MAAM,EAACH,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IACzE,MAAM6H,kBAA0B,CAAC,MAAM,EAAEH,WAAW;IACpD,MAAMY,iBAAyB/K,cAAcuB;IAC7C,MAAMkJ,WAAqB;QACzB;QACA,CAAC,SAAS,EAAEO,KAAKC,SAAS,CAACL,iBAAiB,gBAAgB,CAAC;KAC9D;IAED,IAAGrJ,UAAU;QACXkJ,SAAS3F,IAAI,CAAC,CAAC,sBAAsB,EAAEiG,eAAe,EAAE,CAAC;IAC3D;IAEA,MAAM/C,WAAmB,CAAC,sBAAsB,EAAEsC,gBAAgB;;IAEhE,EAAED,cAAcrF,IAAI,CAAC,MAAM;WACpB,EAAEyF,SAASzF,IAAI,CAAC,QAAQ;IAC/B,EAAE5B,MAAMnD,GAAG,CAAC;qBACK,EAAEmK,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IAEjD,OAAOpE,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG,IAC3BqB,KAAK,CAAC,CAAClB;QACNjF,SAAS;YACPiD;YACAc,UAAUpD;YACVsD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAM4H,iBAAiB,CAC5B5H,SACA,EAACuD,IAAI,EAAEtF,QAAQ,EAAC,EAChB0B;IAEA,MAAMO,SAAS;IACf,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAEyH,SAAS,EAAC5I,QAAQ6I,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAG7G;IAClE,MAAM6H,aAAuBtE,MAAMnE,OAAO,CAAC0I,MAAgBC;QACzD,IAAGA,SAAS;YACVD,KAAKtG,IAAI,CAAClF,UAAUyL,SAAS,IAAIP,WAAW;QAC9C;QAEA,OAAOM;IACT,GAAG,EAAE;IACL,MAAM,EAAChI,KAAK,EAAC,GAAGJ,iBAAiBC;IACjC,MAAM,EAACH,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IACzE,MAAMsI,iBAAyB/K,cAAcuB;IAC7C,MAAMkJ,WAAqB;QACzB,CAAC,WAAW,EAAEN,UAAU,CAAC,CAAC;QAC1B;KACD;IAED,IAAG5I,UAAU;QACXkJ,SAAS3F,IAAI,CAAC,CAAC,sBAAsB,EAAEiG,eAAe,EAAE,CAAC;IAC3D;IAEA,MAAM/C,WAAmB,CAAC;oBACR,EAAEgD,KAAKC,SAAS,CAACE,YAAY;;;IAG7C,EAAEd,cAAcrF,IAAI,CAAC,MAAM;WACpB,EAAEyF,SAASzF,IAAI,CAAC,QAAQ;IAC/B,EAAE5B,MAAMnD,GAAG,CAAC;8BACc,EAAEmK,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAOpE,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG,IAC3BqB,KAAK,CAAC,CAAClB;QACNjF,SAAS;YACPiD;YACAc,UAAUpD;YACVsD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMgI,mBAAmB,CAAChI,SAAqB,EAAC/B,QAAQ,EAAC,EAAE0B;IAChE,MAAMO,SAAS;IACf,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAEyH,SAAS,EAAC5I,MAAM,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGgC;IACvD,MAAM,EAACF,KAAK,EAAC,GAAGJ,iBAAiBC;IACjC,MAAMsI,SAAS;QACb;QACA;KACD;IACD,MAAM,EAACzI,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IAEzE,IAAGlB,UAAU;QACXgK,OAAOzG,IAAI,CAAC,CAAC,sBAAsB,EAAE9E,cAAcuB,UAAU,EAAE,CAAC;IAClE;IAEA,yBAAyB;IACzB,MAAMyG,WAAmB,CAAC;kCACM,EAAE1G,OAAO;WAChC,EAAEiK,OAAOvG,IAAI,CAAC,QAAQ;IAC7B,EAAEqF,cAAcrF,IAAI,CAAC,MAAM;;IAE3B,EAAE5B,MAAMnD,GAAG,CAAC;;qBAEK,EAAEmK,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IAEjD,OAAOpE,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG,IAC3BqB,KAAK,CAAC,CAAClB;QACNjF,SAAS;YACPiD;YACAc,UAAUpD;YACVsD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMkI,uBAAuB,CAClClI,SACA,EAAChC,MAAM,EAAW,EAClB2B;IAEA,MAAMO,SAAS;IACf,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAC,GAAGa;IAC/B,MAAM,EAACF,KAAK,EAAE7B,QAAQ,EAAC,GAAGyB,iBAAiBC;IAC3C,MAAM,EAACH,SAASsH,aAAa,EAAErH,SAASsH,aAAa,EAAC,GAAG7H,gBAAgBC;IACzE,MAAMgJ,eAAuB9L,cAAc,CAAC,MAAM,EAAE2B,QAAQ;IAC5D,MAAMmJ,WAAqB;QACzB;KACD;IAED,IAAGlJ,UAAU;QACXkJ,SAAS3F,IAAI,CAAC,CAAC,sBAAsB,EAAE9E,cAAcuB,UAAU,EAAE,CAAC;IACpE;IAEA,MAAMyG,WAAmB,CAAC;4BACA,EAAEyD,aAAa;;;IAGvC,EAAEpB,cAAcrF,IAAI,CAAC,MAAM;WACpB,EAAEyF,SAASzF,IAAI,CAAC,QAAQ;IAC/B,EAAE5B,MAAMnD,GAAG,CAAC;8BACc,EAAEmK,cAAcpF,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAOpE,MAAM6C,cAAcyB,KAAK,CAAC8C,UAC9B7C,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG,IAC3BqB,KAAK,CAAC,CAAClB;QACNjF,SAAS;YACPiD;YACAc,UAAUpD;YACVsD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMoI,iBAAiB,CAAC,EAACrJ,OAAO,EAAED,KAAK,EAAC;IAC7C,IAAI;QACF,MAAM,EAACd,MAAM,EAAEC,QAAQ,EAAEC,UAAU,EAAC,GAAGV,WAAWsB;QAClD,OAAOf,YAAYC,QAAQC,UAAUC,YAAYa;IACnD,EAAE,OAAMmD,OAAO;QACb,MAAMA,OAAO,qCAAqC;IACpD;AACF,EAAE;AAEF,OAAO,MAAMmG,SAAS,OAAOrI,SAAqBsI;IAChD,MAAMpI,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM,EAACQ,KAAK,EAAEzB,OAAO,EAAE0B,QAAQ,EAAEC,KAAK,EAAEzC,QAAQ,EAAC,GAAGqK;IACpD,MAAMC,cAAsBhM,WAAWiE;IACvC,MAAMiH,iBAAyB/K,cAAcuB;IAC7C,MAAMmH,iBAAyB5I,cAAciE;IAC7C,MAAM+H,cAAsB/L,WAAWiE;IACvC,MAAM+H,gBAAwBvM,SAAS6C,YAAY;IAEnD,IAAG,AAAC,CAAC0I,kBAAkB,CAACc,eAAe,CAACC,eAAgB,CAACpD,gBAAgB;QACvE,MAAMlI,aAAa;YACjBgD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChD;YAAQ;YACjBiD,OAAOlE,WAAWmE,iBAAiB;QACrC,GAAGnB;IACL;IAEA,MAAMuB,UAAoB,EAAE;IAE5B,IAAGgH,aAAa;QACdhH,QAAQC,IAAI,CAAC,CAAC,YAAY,EAAE+G,YAAY,CAAC,CAAC;IAC5C;IAEA,IAAGC,aAAa;QACdjH,QAAQC,IAAI,CAAC,CAAC,WAAW,EAAEgH,aAAa;IAC1C;IAEA,IAAGf,gBAAgB;QACjBlG,QAAQC,IAAI,CAAC,CAAC,eAAe,EAAEiG,eAAe,CAAC,CAAC;IAClD;IAEA,MAAMhG,aAAqB,CAAC;WACnB,EAAEF,QAAQG,IAAI,CAAC,QAAQ;;YAEtB,CAAC;IAEX,IAAIgH;IAEJ,IAAI;QACFA,YAAY,MAAMpL,MAAM6C,cAAcyB,KAAK,CAACH,YAAYI,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI;IACtF,EAAE,OAAMjB,OAAO;QACb,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChD,UAAUwJ;YAAc;YACjCvG,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;IAEA,IAAG,CAAC0I,WAAW;QACb,MAAMxL,aAAa;YACjBgD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAChD;YAAQ;YACjBiD,OAAOlE,WAAW2L,sBAAsB;QAC1C,GAAG3I;IACL;IAEA,MAAM,EAACW,MAAM3C,MAAM,EAAEyC,UAAUmI,aAAa,EAAEvH,IAAI,EAAEnD,UAAU,EAAC,GAAGwK;IAClE,MAAMG,eAAuBzM,eAAegJ,gBAAgB/D;IAE5DyH,QAAQC,GAAG,CAAC;QACV3M;QACAyM;QACAD;QACAxD;QACA/D;IACF;IAEA,IAAGuH,kBAAkBC,cAAc;QACjC,MAAM3L,aAAa;YACjBgD;YACAc,UAAUpD;YACVqD,QAAQ;gBAAC/C;gBAAYF;gBAAQC;YAAQ;YACrCiD,OAAOlE,WAAW2L,sBAAsB;QAC1C,GAAG3I;IACL;IAEA,IAAI;QACF,MAAMlB,QAAQf,YAAYC,UAAU,IAAIC,YAAY,IAAIC,YAAYuK;QAEpE,OAAO3J;IACT,EAAE,OAAMoD,OAAO;QACb,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACjD;gBAAQC;YAAQ;YACzBiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACF,EAAE;AAEF,OAAO,MAAMgJ,UAAU,OAAOhJ;IAC5B,MAAME,SAAS;IACf,MAAM,EAACC,YAAY,EAAEyG,SAAS,EAAC5I,QAAQ6I,SAAS,EAAE5I,QAAQ,EAAC,GAAG,CAAC,CAAC,EAAC,GAAG+B;IACpE,MAAM6E,YAAoB,CAAC,MAAM,EAAEgC,WAAW;IAE9C,MAAMrD,SAAS;QACbyF,YAAYnG,KAAK1E,GAAG;QACpByI,WAAW;IACb;IACA,MAAMqC,eAAyBvM,GAAG,CAAC,iBAAiB,EAAEkI,UAAU;kBAChD,EAAErB,OAAO;;cAEb,CAAC;IAEb,IAAI;QACF,MAAMlG,MAAM6C,cAAcyB,KAAK,CAACsH,cAAcrH,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI;IAC5E,EAAE,OAAMjB,OAAO;QACbjF,SAAS;YACPiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACjD,QAAQ6I;gBAAW5I;YAAQ;YACpCiD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;QAEV,OAAO;IACT;IAEA,OAAO;AACT,EAAE;AAEF,OAAO,MAAMmJ,qBAAqB,CAACnJ;IACjC,MAAME,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAMoJ,aAAuBzM,GAAG,CAAC;;;;;qBAKd,CAAC;IAEpB,OAAOW,MAAM6C,cAAcyB,KAAK,CAACwH,YAC9BvH,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BC,KAAK,CAAC,CAAClB;QACN,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVsD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACJ,EAAE;AAEF,OAAO,MAAMqJ,iBAAiB,CAACrJ,SAAqBlB;IAClD,MAAMoB,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM,EAAChC,MAAM,EAAC,GAAGR,WAAWsB;IAC5B,MAAM+F,YAAYxI,cAAc,CAAC,MAAM,EAAE2B,QAAQ;IACjD,MAAM0G,WAAqB/H,GAAG,CAAC,kBAAkB,EAAEkI,UAAU,WAAW,CAAC;IAEzE,OAAOvH,MAAM6C,cACVyB,KAAK,CAAC8C,UACN7C,IAAI,CAAC,CAACC,SAAWA,OAAOqB,IAAI,IAC5BC,KAAK,CAAC,CAAClB;QACN,MAAMjF,SAAS;YACbiD;YACAc,UAAUpD;YACVqD,QAAQ;gBAACjD;YAAM;YACfkD,OAAOlE,WAAWmF,cAAc;QAClC,GAAGD,OAAOlC;IACZ;AACJ,EAAE"}