@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/actions/posts.js

@@ -1,112 +1,386 @@
-import{parseNum as L}from"@nlabs/utils/parsers/numbers";import{createHash as v,parseArangoId as S,parseChar as _,parseId as D,parseString as q,parseVarChar as x}from"@nlabs/utils/parsers/strings";import{aql as A}from"arangojs";import{parsePost as H}from"../adapters/postAdapter.js";import{ErrorTypes as m}from"../types/error.types.js";import{logError as f,logException as w}from"../utils/analyticsUtils.js";import{getLimit as V,useDb as E}from"../utils/arangodbUtils.js";import{extractTags as B,getTagsByName as U,updateTagsInItem as Q}from"./tags.js";const W=1e5,O="posts",$=(t={})=>{const{from:r=0,latitude:e=0,longitude:o=0,to:i=30,type:n="post"}=t;return{latitude:L(e,32),limit:V(r,i),longitude:L(o,32),type:_(n,32)}},C=(t=[],r="")=>(t||[]).reduce((e,o)=>{switch(o){case"hasRsvp":return e.queries.push(`LET hasRsvp = TO_BOOL(FIRST(
+/**
+ * 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, parseArangoId, parseChar, parseId, parseString, parseVarChar } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { parsePost } from '../adapters/postAdapter.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError, logException } from '../utils/analyticsUtils.js';
+import { getLimit, useDb } from '../utils/arangodbUtils.js';
+import { extractTags, getTagsByName, updateTagsInItem } from './tags.js';
+const MAX_CONTENT_LENGTH = 100000;
+const eventCategory = 'posts';
+export const parsePostOptions = (options = {})=>{
+    const { from = 0, latitude = 0, longitude = 0, to = 30, type = 'post' } = options;
+    return {
+        latitude: parseNum(latitude, 32),
+        limit: getLimit(from, to),
+        longitude: parseNum(longitude, 32),
+        type: parseChar(type, 32)
+    };
+};
+export const getPostOptional = (fields = [], sessionId = '')=>(fields || []).reduce((selects, field)=>{
+        switch(field){
+            case 'hasRsvp':
+                {
+                    selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(
           FOR post, r IN INBOUND p._id hasReaction
-          FILTER r.name == "rsvp" && r.type == "posts" && r._from == "users/${r}"
+          FILTER r.name == "rsvp" && r.type == "posts" && r._from == "users/${sessionId}"
           COLLECT WITH COUNT INTO count
           RETURN count
-        ))`),e.objects.push("hasRsvp:hasRsvp"),e;case"isSaved":return e.queries.push(`LET isSaved = TO_BOOL(FIRST(
+        ))`);
+                    selects.objects.push('hasRsvp:hasRsvp');
+                    return selects;
+                }
+            case 'isSaved':
+                {
+                    selects.queries.push(`LET isSaved = TO_BOOL(FIRST(
           FOR post, r IN INBOUND p._id hasReaction
-          FILTER r.name == "pin" && r.type == "posts" && r._from == "users/${r}"
+          FILTER r.name == "pin" && r.type == "posts" && r._from == "users/${sessionId}"
           COLLECT WITH COUNT INTO count
           RETURN count
-        ))`),e.objects.push("isSaved:isSaved"),e;case"reactions":return e.queries.push(`LET reactions = (
+        ))`);
+                    selects.objects.push('isSaved:isSaved');
+                    return selects;
+                }
+            case 'reactions':
+                {
+                    selects.queries.push(`LET reactions = (
           FOR post, r IN INBOUND p._id hasReaction
           COLLECT reactionName = r.value INTO reactionItems
           RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-        )`),e.objects.push("reactions:reactions"),e;case"rsvpCount":return e.queries.push(`LET rsvpCount = FIRST(
+        )`);
+                    selects.objects.push('reactions:reactions');
+                    return selects;
+                }
+            case 'rsvpCount':
+                {
+                    selects.queries.push(`LET rsvpCount = FIRST(
           FOR post, r IN INBOUND p._id hasReaction
           FILTER r.name == "rsvp" && r.type == "posts"
           COLLECT WITH COUNT INTO count
           RETURN count
-        )`),e.objects.push("rsvpCount:rsvpCount"),e;case"viewCount":return e.queries.push(`LET viewCount = FIRST(
+        )`);
+                    selects.objects.push('rsvpCount:rsvpCount');
+                    return selects;
+                }
+            case 'viewCount':
+                {
+                    selects.queries.push(`LET viewCount = FIRST(
           FOR post, r IN INBOUND p._id hasReaction
           FILTER r.name == "view" && r.type == "posts"
           COLLECT WITH COUNT INTO count
           RETURN count
-        )`),e.objects.push("viewCount:viewCount"),e;default:return e}},{objects:[],queries:[]}),st=async(t,r,e)=>{const o="getPost",{databaseName:i,fields:n,session:{userId:p}={}}=t,R=D(r),{type:c}=$(e),s=E(i),{objects:a,queries:u}=C(n,p),d=A`FOR p IN posts
-    FILTER p._key == ${R} && p.type == ${c}
+        )`);
+                    selects.objects.push('viewCount:viewCount');
+                    return selects;
+                }
+            default:
+                {
+                    return selects;
+                }
+        }
+    }, {
+        objects: [],
+        queries: []
+    });
+export const getPost = async (context, postId, options)=>{
+    const action = 'getPost';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const formatItemId = parseId(postId);
+    const { type } = parsePostOptions(options);
+    const database = useDb(databaseName);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const aqlQry = aql`FOR p IN posts
+    FILTER p._key == ${formatItemId} && p.type == ${type}
     LIMIT 1
-    RETURN p`;return s.query(d).then(I=>I.next()).then(I=>{const{_id:g,userId:T,groupId:h,privacy:N="default"}=I;let y;return T===p?I:(h&&N==="group"?y=`LET p = DOCUMENT("${g}")
-          ${u.join(`
-`)}
+    RETURN p`;
+    return database.query(aqlQry).then((cursor)=>cursor.next()).then((post)=>{
+        const { _id: postDocId, userId, groupId, privacy = 'default' } = post;
+        let privacyAqlQry;
+        if (userId === sessionId) {
+            return post;
+        }
+        if (groupId && privacy === 'group') {
+            privacyAqlQry = `LET p = DOCUMENT("${postDocId}")
+          ${selectQueries.join('\n')}
           FOR group IN groups
           FILTER group._key == p.groupId
           FOR u, e IN OUTBOUND group._id hasConnection
-          FILTER u._key == "${p}"
+          FILTER u._key == "${sessionId}"
           LIMIT 1
-          RETURN MERGE(p, {${a.join(", ")}})`:N==="public"&&(y=`LET p = DOCUMENT("${g}")
-          ${u.join(`
-`)}
+          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
+        } else if (privacy === 'public') {
+            privacyAqlQry = `LET p = DOCUMENT("${postDocId}")
+          ${selectQueries.join('\n')}
           LIMIT 1
-          RETURN MERGE(p, {${a.join(", ")}})`),y?s.query(y).then(l=>l.next()).catch(l=>f({action:o,category:O,label:m.DATABASE_ERROR},l,t)):{})}).catch(I=>f({action:o,category:O,label:m.DATABASE_ERROR},I,t))},ot=(t,r,e,o)=>{const i="getPostsByArea",{databaseName:n,fields:p,session:{userId:R}={}}=t,{limit:c,type:s}=$(o),a=L(r),u=L(e),{objects:d,queries:I}=C(p,R);I.push(`LET distance = DISTANCE(
-    ${a},
-    ${u},
+          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
+        }
+        if (privacyAqlQry) {
+            return database.query(privacyAqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                    action,
+                    category: eventCategory,
+                    label: ErrorTypes.DATABASE_ERROR
+                }, error, context));
+        }
+        return {};
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+// export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {
+//   // const action: string = 'getListByApp';
+//   const {database, fields, session: {userId: sessionId}} = context;
+//   const {limit, type} = parsePostOptions(options);
+//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);
+//   const aqlQry: string = `FOR p IN posts
+//     FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
+//     ${selectQueries.join('\n')}
+//     ${limit.aql}
+//     SORT p.added
+//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+//   return database.query(aqlQry)
+//     .then((cursor) => cursor.all())
+//     .catch((error: Error) => {
+//       throw error;
+//     });
+// };
+export const getPostsByArea = (context, latitude, longitude, options)=>{
+    const action = 'getPostsByArea';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const formatLatitude = parseNum(latitude);
+    const formatLongitude = parseNum(longitude);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    selectQueries.push(`LET distance = DISTANCE(
+    ${formatLatitude},
+    ${formatLongitude},
     NOT_NULL(p.latitude, 0),
     NOT_NULL(p.longitude, 0))
-  `),d.push("distance:distance");const g=`FOR p IN posts
-    ${I.join(`
-`)}
-    FILTER p.type == "${s}" && p.privacy == "public" && p.parentId == null
-    ${c.aql}
+  `);
+    selectObjects.push('distance:distance');
+    const aqlQry = `FOR p IN posts
+    ${selectQueries.join('\n')}
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parentId == null
+    ${limit.aql}
     SORT distance, p.added
-    RETURN DISTINCT MERGE(p, {${d.join(", ")}})`;return E(n).query(g).then(T=>T.all()).catch(T=>(f({action:i,category:O,label:m.DATABASE_ERROR},T,t),[]))},rt=(t,r)=>{const{databaseName:e,fields:o,session:{userId:i}={}}=t,{limit:n,type:p}=$(r),{objects:R,queries:c}=C(o,i),s=`FOR p IN posts
-    FILTER p.type == "${p}" && p.privacy == "public" && p.parent == null
-    ${c.join(`
-`)}
-    ${n.aql}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+// export const getPostsByGroup = (
+//   context: ApiContext,
+//   groupId: string,
+//   options?: PostOptions
+// ): Promise<PostType[]> => {
+//   // const action: string = 'getListByGroup';
+//   const {database, fields, session: {userId: sessionId}} = context;
+//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);
+//   // Group id
+//   const formatGroupId: string = parseId(groupId);
+//   const db = database;
+//   const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup
+//       FILTER u._key == ${sessionId}
+//       RETURN g`;
+//   return db.query(aqlQry)
+//     .then((cursor) => cursor.all())
+//     .then((groups: GroupType[] = []) => {
+//       if(groups.length) {
+//         const {limit, type} = parsePostOptions(options);
+//         const postAqlQry: string = `FOR p IN posts
+//           FILTER p.type == "${type}" && p.groupId == "${formatGroupId}" && p.parent == null
+//           ${selectQueries.join('\n')}
+//           ${limit.aql}
+//           SORT p.added
+//           RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+//         return db.query(postAqlQry)
+//           .then((cursor) => cursor.all())
+//           .catch((error: Error) => {
+//             throw error;
+//           });
+//       }
+//       return [];
+//     })
+//     .catch((error: Error) => {
+//       throw error;
+//     });
+// };
+export const getPostsByLatest = (context, options)=>{
+    // const action: string = 'getListByLatest';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const aqlQry = `FOR p IN posts
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
     SORT p.added DESC
-    RETURN DISTINCT MERGE(p, {${R.join(", ")}})`;return E(e).query(s).then(a=>a.all()).catch(a=>{throw a})},nt=(t,r=[],e)=>{const o="getPostsByReactions",{databaseName:i,fields:n,session:{userId:p}={}}=t,{latitude:R,limit:c,longitude:s,type:a}=$(e),{objects:u,queries:d}=C(n,p),I=`users/${p}`,g=JSON.stringify(r.map(P=>_(P,32).toLowerCase())),T=[],h=[`p.type == "${a}"`,'p.privacy == "public"'],N=L(R),y=L(s);N&&y&&(d.push(`LET distance = DISTANCE(
-      ${N},
-      ${y},
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        throw error;
+    });
+};
+export const getPostsByReactions = (context, reactions = [], options)=>{
+    const action = 'getPostsByReactions';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { latitude, limit, longitude, type } = parsePostOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const formatSessionId = `users/${sessionId}`;
+    const formatReactions = JSON.stringify(reactions.map((reaction)=>parseChar(reaction, 32).toLowerCase()));
+    const sortBy = [];
+    const filters = [
+        `p.type == "${type}"`,
+        'p.privacy == "public"'
+    ];
+    const formatLatitude = parseNum(latitude);
+    const formatLongitude = parseNum(longitude);
+    if (formatLatitude && formatLongitude) {
+        selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
       NOT_NULL(p.latitude, 0),
       NOT_NULL(p.longitude, 0))
-    `),u.push("distance:distance"),T.push("distance")),r.length&&(T.push("matchedTags DESC"),d.push(`LET matchedReactions = LENGTH(
+    `);
+        selectObjects.push('distance:distance');
+        sortBy.push('distance');
+    }
+    if (reactions.length) {
+        sortBy.push('matchedTags DESC');
+        selectQueries.push(`LET matchedReactions = LENGTH(
       FOR mr IN reactions
       FILTER mr.matched == true
       RETURN mr
-    )`),u.push("matchedReactions:matchedReactions"),h.push("matchedReactions > 0")),T.push("p.added DESC"),u.push("reactions:reactions");const l=`FOR p, r IN OUTBOUND "${I}" hasReaction
+    )`);
+        selectObjects.push('matchedReactions:matchedReactions');
+        filters.push('matchedReactions > 0');
+    }
+    sortBy.push('p.added DESC');
+    selectObjects.push('reactions:reactions');
+    // Get data from database
+    const aqlQry = `FOR p, r IN OUTBOUND "${formatSessionId}" hasReaction
     LET reactions = (
       FOR reaction, hr IN 1..1 INBOUND p isTagged
-      LET matched = LENGTH(${g}) > 0 && POSITION(${g}, reaction.name)
+      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)
       SORT reaction.name
       RETURN MERGE(reaction, {matched:matched})
     )
-    ${d.join(`
-`)}
-    FILTER ${h.join(" && ")}
-    ${c.aql}
-    RETURN DISTINCT MERGE(p, {${u.join(", ")}})`;return E(i).query(l).then(P=>P.all()).catch(P=>(f({action:o,category:O,label:m.DATABASE_ERROR},P,t),[]))},at=(t,r=[],e)=>{const o="getPostsByTags",{databaseName:i,fields:n,session:{userId:p}={}}=t,{latitude:R,limit:c,longitude:s,type:a}=$(e),{objects:u,queries:d}=C(n,p),I=JSON.stringify(r.map(l=>_(l,32).toLowerCase())),g=[],T=[`p.type == "${a}"`,'p.privacy == "public"'],h=L(R),N=L(s);h&&N&&(d.push(`LET distance = DISTANCE(
-      ${h},
-      ${N},
+    ${selectQueries.join('\n')}
+    FILTER ${filters.join(' && ')}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getPostsByTags = (context, tags = [], options)=>{
+    const action = 'getPostsByTags';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { latitude, limit, longitude, type } = parsePostOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const formatTagNames = JSON.stringify(tags.map((tag)=>parseChar(tag, 32).toLowerCase()));
+    const sortBy = [];
+    const filters = [
+        `p.type == "${type}"`,
+        'p.privacy == "public"'
+    ];
+    const formatLatitude = parseNum(latitude);
+    const formatLongitude = parseNum(longitude);
+    if (formatLatitude && formatLongitude) {
+        selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
       NOT_NULL(p.latitude, 0),
       NOT_NULL(p.longitude, 0))
-    `),u.push("distance:distance"),g.push("distance")),r.length&&(g.push("matchedTags DESC"),d.push(`LET matchedTags = LENGTH(
+    `);
+        selectObjects.push('distance:distance');
+        sortBy.push('distance');
+    }
+    if (tags.length) {
+        sortBy.push('matchedTags DESC');
+        selectQueries.push(`LET matchedTags = LENGTH(
       FOR t IN tags
       FILTER t.matched == true
       RETURN t
-    )`),u.push("matchedTags:matchedTags"),T.push("matchedTags > 0")),g.push("p.added DESC"),u.push("tags:tags");const y=`FOR p IN posts
+    )`);
+        selectObjects.push('matchedTags:matchedTags');
+        filters.push('matchedTags > 0');
+    }
+    sortBy.push('p.added DESC');
+    selectObjects.push('tags:tags');
+    const aqlQry = `FOR p IN posts
     LET tags = (
       FOR tag, it IN 1..1 INBOUND p isTagged
-      LET matched = LENGTH(${I}) > 0 && POSITION(${I}, tag.name)
+      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)
       SORT tag.name
       RETURN MERGE(tag, {matched:matched})
     )
-    ${d.join(`
-`)}
-    FILTER ${T.join(" && ")}
-    ${c.aql}
-    SORT ${g.join(", ")}
-    RETURN DISTINCT MERGE(p, {${u.join(", ")}})`;return E(i).query(y).then(l=>l.all()).catch(l=>(f({action:o,category:O,label:m.DATABASE_ERROR},l,t),[]))},it=(t,r,e)=>{const o="getPostsByUser",{databaseName:i,fields:n,session:{userId:p}={}}=t,{limit:R,type:c}=$(e),s=D(r),{objects:a,queries:u}=C(n,p),d=`FOR p IN posts
-    FILTER p.userId == "${s}" && p.type == "${c}" && p.privacy == "public" && p.parent == null
-    ${u.join(`
-`)}
-    ${R.aql}
+    ${selectQueries.join('\n')}
+    FILTER ${filters.join(' && ')}
+    ${limit.aql}
+    SORT ${sortBy.join(', ')}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getPostsByUser = (context, userId, options)=>{
+    const action = 'getPostsByUser';
+    const { databaseName, fields, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const formatUserId = parseId(userId);
+    const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+    const aqlQry = `FOR p IN posts
+    FILTER p.userId == "${formatUserId}" && p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
     SORT p.added
-    RETURN DISTINCT MERGE(p, {${a.join(", ")}})`;return E(i).query(d).then(I=>I.all()).catch(I=>(f({action:o,category:O,label:m.DATABASE_ERROR},I,t),[]))},pt=(t,r,e)=>{const o="getPostComments",{databaseName:i,session:{userId:n}={}}=t,{limit:p,type:R}=$(e),c=D(r),s=A`FOR p IN posts
-    FILTER p.type == ${R} && p._key == ${c}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getPostComments = (context, postId, options)=>{
+    const action = 'getPostComments';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const { limit, type } = parsePostOptions(options);
+    const formatItemId = parseId(postId);
+    // Get the parent post to get restrictions
+    const aqlQry = aql`FOR p IN posts
+    FILTER p.type == ${type} && p._key == ${formatItemId}
     LIMIT 1
-    RETURN p`;return E(i).query(s).then(a=>a.next()).then(a=>{const{_key:u,groupId:d,privacy:I="default"}=a;let g;return d&&I==="group"?g=`FOR p IN posts
+    RETURN p`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((post)=>{
+        const { _key, groupId, privacy = 'default' } = post;
+        // Query based on privacy level
+        let privacyAqlQry;
+        if (groupId && privacy === 'group') {
+            privacyAqlQry = `FOR p IN posts
           FOR user IN users
-          FILTER p.parent == "${u}" && user._key == p.userId
+          FILTER p.parent == "${_key}" && user._key == p.userId
           LET reactions = (
             FOR post, r IN INBOUND p._id reactions
             COLLECT reactionName = r.value INTO reactionItems
@@ -115,29 +389,220 @@ import{parseNum as L}from"@nlabs/utils/parsers/numbers";import{createHash as v,p
           FOR group IN groups
           FILTER group._key == p.groupId
           FOR u, e IN OUTBOUND group._id hasConnection
-          FILTER u._key == "${n}"
+          FILTER u._key == "${sessionId}"
           SORT p.added
-          ${p.aql}
-          RETURN MERGE(p, {user: user, reactions: reactions})`:I==="public"&&(g=`FOR p IN posts
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+        } else if (privacy === 'public') {
+            privacyAqlQry = `FOR p IN posts
           FOR user IN users
-          FILTER p.parent == "${u}" && user._key == p.userId
+          FILTER p.parent == "${_key}" && user._key == p.userId
           LET reactions = (
             FOR post, r IN INBOUND p._id reactions
             COLLECT reactionName = r.value INTO reactionItems
             RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
           )
           SORT p.added
-          ${p.aql}
-          RETURN MERGE(p, {user: user, reactions: reactions})`),g?E(i).query(g).then(T=>T.all()).catch(T=>(f({action:o,category:O,label:m.DATABASE_ERROR},T,t),[])):[]}).catch(a=>(f({action:o,category:O,label:m.DATABASE_ERROR},a,t),[]))},ct=async(t,{content:r="",endDate:e,groupId:o="",location:i,latitude:n,longitude:p,name:R="",parentId:c="",privacy:s="public",tags:a=[],startDate:u,type:d="default"})=>{const I="addPost",{databaseName:g,session:{userId:T}={}}=t,h=Date.now(),N=v(`post-${T}`),y={_id:`posts/${N}`,_key:N,added:h,content:q(r,W)||"",endDate:e?L(e,13):void 0,groupId:o?D(o):void 0,latitude:n!==void 0?L(n):void 0,location:i?q(i,160):void 0,longitude:p!==void 0?L(p):void 0,modified:h,name:q(R,160),parentId:c?D(c):void 0,privacy:x(s,16),startDate:u?L(u,13):void 0,type:_(d,32),userId:T},l=A`INSERT ${y} IN posts RETURN NEW`;try{const P=await E(g).query(l).then(b=>b.next()).catch(b=>f({action:I,category:O,label:m.DATABASE_ERROR},b,t)),{_id:M}=P,j=await B(y.content||"");if(a.length||j.length){const b=(await U(t,a.map(({name:F})=>F||""))).map(F=>({...F,tagBy:T})),G=(await U(t,j||[])).map(F=>({...F,tagBy:"extract"})),k=await Q(t,{itemDocId:M,tags:[...G,...b]});return{...P,tags:k}}return P}catch(P){throw P}},ut=async(t,r)=>{const e="updatePost",{databaseName:o,session:{userId:i}={}}=t,n=Date.now(),p=H(r),{postId:R,tags:c=[]}=p,s={...p,modified:n};if(!R)throw w({action:e,category:O,value:m.INVALID_ID},t);const a={...s,_key:R,added:n,userId:i},u=A`UPSERT {_key: ${R}, userId: ${i}}
-    INSERT ${a}
-    UPDATE ${s}
-    IN posts RETURN NEW`;try{const d=await E(o).query(u).then(T=>T.next()).catch(T=>f({action:e,category:O,value:m.DATABASE_ERROR},T,{})),{_id:I}=d,g=await B(a.content||"");if(c?.length||g?.length){const T=c?.length?(await U(t,c.map(({name:y})=>y||""))).map(y=>({...y,tagBy:i})):[],h=g?.length?(await U(t,g||[])).map(y=>({...y,tagBy:"extract"})):[],N=await Q(t,{itemDocId:I,tags:[...h,...T]});return{...d,tags:N}}return d}catch(d){throw d}},dt=async(t,r)=>{const e="deletePost",{databaseName:o,session:{userId:i}={}}=t,n=S(r);if(!n)throw w({action:e,category:O,value:m.INVALID_ID},t);const p=A`FOR t IN isTagged
-  FILTER t._to == ${n}
-  REMOVE t IN isTagged`;await E(o).query(p).catch(s=>{throw s});const R=A`FOR f IN hasFile
-    FILTER f._to == ${n}
-    REMOVE f IN hasFile`;await E(o).query(R).catch(s=>{throw s});const c=A`FOR p IN posts
-      FILTER p._id == ${n} && p.userId == ${i}
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+        }
+        if (privacyAqlQry) {
+            return useDb(databaseName).query(privacyAqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+                logError({
+                    action,
+                    category: eventCategory,
+                    label: ErrorTypes.DATABASE_ERROR
+                }, error, context);
+                return [];
+            });
+        }
+        return [];
+    }).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const addPost = async (context, { content = '', endDate, groupId = '', location, latitude, longitude, name = '', parentId = '', privacy = 'public', tags = [], startDate, type = 'default' })=>{
+    const action = 'addPost';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const now = Date.now();
+    const postId = createHash(`post-${sessionId}`);
+    const insert = {
+        _id: `posts/${postId}`,
+        _key: postId,
+        added: now,
+        content: parseString(content, MAX_CONTENT_LENGTH) || '',
+        endDate: endDate ? parseNum(endDate, 13) : undefined,
+        groupId: groupId ? parseId(groupId) : undefined,
+        latitude: latitude !== undefined ? parseNum(latitude) : undefined,
+        location: location ? parseString(location, 160) : undefined,
+        longitude: longitude !== undefined ? parseNum(longitude) : undefined,
+        modified: now,
+        name: parseString(name, 160),
+        parentId: parentId ? parseId(parentId) : undefined,
+        privacy: parseVarChar(privacy, 16),
+        startDate: startDate ? parseNum(startDate, 13) : undefined,
+        type: parseChar(type, 32),
+        userId: sessionId
+    };
+    const aqlQry = aql`INSERT ${insert} IN posts RETURN NEW`;
+    try {
+        const savedPost = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+        const { _id: postDocId } = savedPost;
+        const contentTagNames = await extractTags(insert.content || '');
+        if (tags.length || contentTagNames.length) {
+            const userTags = (await getTagsByName(context, tags.map(({ name })=>name || ''))).map((tag)=>({
+                    ...tag,
+                    tagBy: sessionId
+                }));
+            const contentTags = (await getTagsByName(context, contentTagNames || [])).map((tag)=>({
+                    ...tag,
+                    tagBy: 'extract'
+                }));
+            const updatedTags = await updateTagsInItem(context, {
+                itemDocId: postDocId,
+                tags: [
+                    ...contentTags,
+                    ...userTags
+                ]
+            });
+            return {
+                ...savedPost,
+                tags: updatedTags
+            };
+        }
+        return savedPost;
+    } catch (error) {
+        throw error;
+    }
+};
+export const updatePost = async (context, post)=>{
+    const action = 'updatePost';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const now = Date.now();
+    const parsedPost = parsePost(post);
+    const { postId, tags = [] } = parsedPost;
+    const update = {
+        ...parsedPost,
+        modified: now
+    };
+    if (!postId) {
+        throw logException({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.INVALID_ID
+        }, context);
+    }
+    const insert = {
+        ...update,
+        _key: postId,
+        added: now,
+        userId: sessionId
+    };
+    const aqlQry = aql`UPSERT {_key: ${postId}, userId: ${sessionId}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN posts RETURN NEW`;
+    try {
+        const updatedPost = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, {}));
+        const { _id: updatedPostId } = updatedPost;
+        const contentTagNames = await extractTags(insert.content || '');
+        if (tags?.length || contentTagNames?.length) {
+            const userTags = tags?.length ? (await getTagsByName(context, tags.map(({ name })=>name || ''))).map((tag)=>({
+                    ...tag,
+                    tagBy: sessionId
+                })) : [];
+            const contentTags = contentTagNames?.length ? (await getTagsByName(context, contentTagNames || [])).map((tag)=>({
+                    ...tag,
+                    tagBy: 'extract'
+                })) : [];
+            const updatedTags = await updateTagsInItem(context, {
+                itemDocId: updatedPostId,
+                tags: [
+                    ...contentTags,
+                    ...userTags
+                ]
+            });
+            return {
+                ...updatedPost,
+                tags: updatedTags
+            };
+        }
+        return updatedPost;
+    } catch (error) {
+        throw error;
+    }
+};
+export const deletePost = async (context, postDocId)=>{
+    const action = 'deletePost';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const formatPostId = parseArangoId(postDocId);
+    if (!formatPostId) {
+        throw logException({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.INVALID_ID
+        }, context);
+    }
+    const edgeAqlQry = aql`FOR t IN isTagged
+  FILTER t._to == ${formatPostId}
+  REMOVE t IN isTagged`;
+    await useDb(databaseName).query(edgeAqlQry).catch((error)=>{
+        throw error;
+    });
+    const fileAqlQry = aql`FOR f IN hasFile
+    FILTER f._to == ${formatPostId}
+    REMOVE f IN hasFile`;
+    await useDb(databaseName).query(fileAqlQry).catch((error)=>{
+        throw error;
+    });
+    const aqlQry = aql`FOR p IN posts
+      FILTER p._id == ${formatPostId} && p.userId == ${sessionId}
       LIMIT 1
       REMOVE p IN posts
-      RETURN OLD`;return E(o).query(c).then(s=>s.next()).catch(s=>{throw s})},Tt=(t,r,e,o="isPosted",i={})=>{const n="createPostEdge",{databaseName:p}=t,R=E(p).collection(o),c=S(r),s=S(e);if(!s||!c)throw new Error(m.INVALID_ID);const a=v(`postEdge-${c}-${s}`),u={_from:c,_key:a,_to:s,added:Date.now(),...i};return R.save(u,{returnNew:!0}).catch(d=>{throw f({action:n,category:O,value:m.DATABASE_ERROR},d,t)})};export{ct as addPost,Tt as createPostEdge,dt as deletePost,st as getPost,pt as getPostComments,C as getPostOptional,ot as getPostsByArea,rt as getPostsByLatest,nt as getPostsByReactions,at as getPostsByTags,it as getPostsByUser,$ as parsePostOptions,ut as updatePost};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/posts.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, parseArangoId, parseChar, parseId, parseString, parseVarChar\n} from '@nlabs/utils/parsers/strings';\nimport { aql } from 'arangojs';\nimport { AqlQuery } from 'arangojs/aql';\n\nimport { parsePost } from '../adapters/postAdapter.js';\nimport { ErrorTypes } from '../types/error.types.js';\nimport { logError, logException } from '../utils/analyticsUtils.js';\nimport { getLimit, useDb } from '../utils/arangodbUtils.js';\nimport { extractTags, getTagsByName, updateTagsInItem } from './tags.js';\n\nimport type { EdgeCollection } from 'arangojs/collections';\nimport type { ArangoDbLimit } from '../types/arangodb.types.js';\nimport type { ApiContext } from '../types/auth.types.js';\nimport type { FileType } from '../types/files.types.js';\nimport type { PostInputType, PostOptions, PostType } from '../types/posts.types.js';\nimport type { TagType } from '../types/tags.types.js';\n\nconst MAX_CONTENT_LENGTH: number = 100000;\nconst eventCategory: string = 'posts';\n\nexport const parsePostOptions = (options: PostOptions = {}) => {\n  const {\n    from = 0,\n    latitude = 0,\n    longitude = 0,\n    to = 30,\n    type = 'post'\n  } = options;\n\n  return {\n    latitude: parseNum(latitude, 32),\n    limit: getLimit(from, to) as ArangoDbLimit,\n    longitude: parseNum(longitude, 32),\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getPostOptional = (fields: string[] = [], sessionId: string = '') =>\n  (fields || []).reduce((selects: {objects: string[], queries: string[]}, field: string) => {\n    switch(field) {\n      case 'hasRsvp': {\n        selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"rsvp\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('hasRsvp:hasRsvp');\n        return selects;\n      }\n      case 'isSaved': {\n        selects.queries.push(`LET isSaved = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"pin\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('isSaved:isSaved');\n        return selects;\n      }\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (\n          FOR post, r IN INBOUND p._id hasReaction\n          COLLECT reactionName = r.value INTO reactionItems\n          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n        )`);\n        selects.objects.push('reactions:reactions');\n        return selects;\n      }\n      case 'rsvpCount': {\n        selects.queries.push(`LET rsvpCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"rsvp\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('rsvpCount:rsvpCount');\n        return selects;\n      }\n      case 'viewCount': {\n        selects.queries.push(`LET viewCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"view\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('viewCount:viewCount');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getPost = async (\n  context: ApiContext,\n  postId: string,\n  options?: PostOptions\n): Promise<PostType> => {\n  const action: string = 'getPost';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const formatItemId: string = parseId(postId);\n  const {type} = parsePostOptions(options);\n  const database = useDb(databaseName);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p._key == ${formatItemId} && p.type == ${type}\n    LIMIT 1\n    RETURN p`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((post: PostType) => {\n      const {\n        _id: postDocId,\n        userId,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      let privacyAqlQry: string | undefined;\n\n      if(userId === sessionId) {\n        return post;\n      }\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id hasConnection\n          FILTER u._key == \"${sessionId}\"\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      }\n\n      if(privacyAqlQry) {\n        return database.query(privacyAqlQry)\n          .then((cursor) => cursor.next())\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context));\n      }\n\n      return {};\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\n\n// export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n//   // const action: string = 'getListByApp';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {limit, type} = parsePostOptions(options);\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n//   const aqlQry: string = `FOR p IN posts\n//     FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n//     ${selectQueries.join('\\n')}\n//     ${limit.aql}\n//     SORT p.added\n//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//   return database.query(aqlQry)\n//     .then((cursor) => cursor.all())\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByArea = (\n  context: ApiContext,\n  latitude: number,\n  longitude: number,\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByArea';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  selectQueries.push(`LET distance = DISTANCE(\n    ${formatLatitude},\n    ${formatLongitude},\n    NOT_NULL(p.latitude, 0),\n    NOT_NULL(p.longitude, 0))\n  `);\n  selectObjects.push('distance:distance');\n\n  const aqlQry: string = `FOR p IN posts\n    ${selectQueries.join('\\n')}\n    FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parentId == null\n    ${limit.aql}\n    SORT distance, p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\n// export const getPostsByGroup = (\n//   context: ApiContext,\n//   groupId: string,\n//   options?: PostOptions\n// ): Promise<PostType[]> => {\n//   // const action: string = 'getListByGroup';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n\n//   // Group id\n//   const formatGroupId: string = parseId(groupId);\n//   const db = database;\n//   const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup\n//       FILTER u._key == ${sessionId}\n//       RETURN g`;\n\n//   return db.query(aqlQry)\n//     .then((cursor) => cursor.all())\n//     .then((groups: GroupType[] = []) => {\n//       if(groups.length) {\n//         const {limit, type} = parsePostOptions(options);\n//         const postAqlQry: string = `FOR p IN posts\n//           FILTER p.type == \"${type}\" && p.groupId == \"${formatGroupId}\" && p.parent == null\n//           ${selectQueries.join('\\n')}\n//           ${limit.aql}\n//           SORT p.added\n//           RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//         return db.query(postAqlQry)\n//           .then((cursor) => cursor.all())\n//           .catch((error: Error) => {\n//             throw error;\n//           });\n//       }\n\n//       return [];\n//     })\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByLatest = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n  // const action: string = 'getListByLatest';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added DESC\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getPostsByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByReactions';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatReactions: string = JSON.stringify(reactions.map((reaction) => parseChar(reaction, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(reactions.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedReactions = LENGTH(\n      FOR mr IN reactions\n      FILTER mr.matched == true\n      RETURN mr\n    )`);\n    selectObjects.push('matchedReactions:matchedReactions');\n    filters.push('matchedReactions > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('reactions:reactions');\n\n  // Get data from database\n  const aqlQry: string = `FOR p, r IN OUTBOUND \"${formatSessionId}\" hasReaction\n    LET reactions = (\n      FOR reaction, hr IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)\n      SORT reaction.name\n      RETURN MERGE(reaction, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostsByTags = (\n  context: ApiContext,\n  tags: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByTags';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatTagNames: string = JSON.stringify(tags.map((tag) => parseChar(tag, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(tags.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedTags = LENGTH(\n      FOR t IN tags\n      FILTER t.matched == true\n      RETURN t\n    )`);\n    selectObjects.push('matchedTags:matchedTags');\n    filters.push('matchedTags > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('tags:tags');\n\n  const aqlQry: string = `FOR p IN posts\n    LET tags = (\n      FOR tag, it IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)\n      SORT tag.name\n      RETURN MERGE(tag, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    SORT ${sortBy.join(', ')}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostsByUser = (context: ApiContext, userId: string, options?: PostOptions): Promise<PostType[]> => {\n  const action: string = 'getPostsByUser';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatUserId: string = parseId(userId);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.userId == \"${formatUserId}\" && p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostComments = (context: ApiContext, postId: string, options?: PostOptions): Promise<PostType[]> => {\n  const action: string = 'getPostComments';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatItemId: string = parseId(postId);\n\n  // Get the parent post to get restrictions\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p.type == ${type} && p._key == ${formatItemId}\n    LIMIT 1\n    RETURN p`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((post: PostType) => {\n      const {\n        _key,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      // Query based on privacy level\n      let privacyAqlQry: string | undefined;\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id hasConnection\n          FILTER u._key == \"${sessionId}\"\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      }\n\n      if(privacyAqlQry) {\n        return useDb(databaseName).query(privacyAqlQry)\n          .then((cursor) => cursor.all() as unknown as PostType[])\n          .catch((error: Error) => {\n            logError({\n              action,\n              category: eventCategory,\n              label: ErrorTypes.DATABASE_ERROR\n            }, error, context);\n\n            return [] as PostType[];\n          });\n      }\n\n      return [] as PostType[];\n    })\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const addPost = async (\n  context: ApiContext,\n  {\n    content = '',\n    endDate,\n    groupId = '',\n    location,\n    latitude,\n    longitude,\n    name = '',\n    parentId = '',\n    privacy = 'public',\n    tags = [],\n    startDate,\n    type = 'default'\n  }: PostInputType\n): Promise<PostType> => {\n  const action: string = 'addPost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now = Date.now();\n  const postId = createHash(`post-${sessionId}`);\n  const insert: PostType = {\n    _id: `posts/${postId}`,\n    _key: postId,\n    added: now,\n    content: parseString(content, MAX_CONTENT_LENGTH) || '',\n    endDate: endDate ? parseNum(endDate, 13) : undefined,\n    groupId: groupId ? parseId(groupId) : undefined,\n    latitude: latitude !== undefined ? parseNum(latitude) : undefined,\n    location: location ? parseString(location, 160) : undefined,\n    longitude: longitude !== undefined ? parseNum(longitude) : undefined,\n    modified: now,\n    name: parseString(name, 160),\n    parentId: parentId ? parseId(parentId) : undefined,\n    privacy: parseVarChar(privacy, 16),\n    startDate: startDate ? parseNum(startDate, 13) : undefined,\n    type: parseChar(type, 32),\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN posts RETURN NEW`;\n\n  try {\n    const savedPost: PostType = await useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n    const {_id: postDocId} = savedPost;\n    const contentTagNames = await extractTags(insert.content || '');\n\n    if(tags.length || contentTagNames.length) {\n      const userTags = (await getTagsByName(context, tags.map(({name}) => name || '')))\n        .map((tag) => ({...tag, tagBy: sessionId}));\n      const contentTags = (await getTagsByName(context, contentTagNames || []))\n        .map((tag) => ({...tag, tagBy: 'extract'}));\n      const updatedTags: TagType[] = await updateTagsInItem(\n        context,\n        {\n          itemDocId: postDocId,\n          tags: [...contentTags, ...userTags]\n        }\n      );\n\n      return {\n        ...savedPost,\n        tags: updatedTags\n      };\n    }\n\n    return savedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const updatePost = async (context: ApiContext, post: PostInputType): Promise<PostType> => {\n  const action: string = 'updatePost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now: number = Date.now();\n  const parsedPost = parsePost(post);\n  const {\n    postId,\n    tags = []\n  } = parsedPost;\n\n  const update: PostType = {\n    ...parsedPost,\n    modified: now\n  };\n\n  if(!postId) {\n    throw logException({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ID\n    }, context);\n  }\n\n  const insert = {\n    ...update,\n    _key: postId,\n    added: now,\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${postId}, userId: ${sessionId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN posts RETURN NEW`;\n\n  try {\n    const updatedPost: PostType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {}));\n    const {_id: updatedPostId} = updatedPost;\n    const contentTagNames = await extractTags(insert.content || '');\n\n    if(tags?.length || contentTagNames?.length) {\n      const userTags = tags?.length ? (await getTagsByName(context, tags.map(({name}) => name || '')))\n        .map((tag) => ({...tag, tagBy: sessionId})) : [];\n      const contentTags = contentTagNames?.length ? (await getTagsByName(context, contentTagNames || []))\n        .map((tag) => ({...tag, tagBy: 'extract'})) : [];\n      const updatedTags: TagType[] = await updateTagsInItem(\n        context,\n        {\n          itemDocId: updatedPostId,\n          tags: [...contentTags, ...userTags]\n        }\n      );\n\n      return {\n        ...updatedPost,\n        tags: updatedTags\n      };\n    }\n\n    return updatedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const deletePost = async (context: ApiContext, postDocId: string): Promise<PostType> => {\n  const action: string = 'deletePost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const formatPostId: string = parseArangoId(postDocId);\n\n  if(!formatPostId) {\n    throw logException({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ID\n    }, context);\n  }\n\n  const edgeAqlQry: AqlQuery = aql`FOR t IN isTagged\n  FILTER t._to == ${formatPostId}\n  REMOVE t IN isTagged`;\n\n  await useDb(databaseName).query(edgeAqlQry)\n    .catch((error: Error) => {\n      throw error;\n    });\n\n  const fileAqlQry: AqlQuery = aql`FOR f IN hasFile\n    FILTER f._to == ${formatPostId}\n    REMOVE f IN hasFile`;\n\n  await useDb(databaseName).query(fileAqlQry)\n    .catch((error: Error) => {\n      throw error;\n    });\n\n  const aqlQry = aql`FOR p IN posts\n      FILTER p._id == ${formatPostId} && p.userId == ${sessionId}\n      LIMIT 1\n      REMOVE p IN posts\n      RETURN OLD`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const createPostEdge = (\n  context: ApiContext,\n  postDocId: string,\n  itemDocId: string,\n  edgeType: string = 'isPosted',\n  props = {}\n): Promise<FileType> => {\n  const action = 'createPostEdge';\n  const {databaseName} = context;\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection(edgeType);\n  const formatPostId: string = parseArangoId(postDocId);\n  const formatDocId: string = parseArangoId(itemDocId);\n\n  if(!formatDocId || !formatPostId) {\n    throw new Error(ErrorTypes.INVALID_ID);\n  }\n\n  const edgeId: string = createHash(`postEdge-${formatPostId}-${formatDocId}`);\n  const edge = {\n    _from: formatPostId,\n    _key: edgeId,\n    _to: formatDocId,\n    added: Date.now(),\n    ...props\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};\n"],
  "mappings": "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",
  "names": ["parseNum", "createHash", "parseArangoId", "parseChar", "parseId", "parseString", "parseVarChar", "aql", "parsePost", "ErrorTypes", "logError", "logException", "getLimit", "useDb", "extractTags", "getTagsByName", "updateTagsInItem", "MAX_CONTENT_LENGTH", "eventCategory", "parsePostOptions", "options", "from", "latitude", "longitude", "to", "type", "getPostOptional", "fields", "sessionId", "selects", "field", "getPost", "context", "postId", "action", "databaseName", "formatItemId", "database", "selectObjects", "selectQueries", "aqlQry", "cursor", "post", "postDocId", "userId", "groupId", "privacy", "privacyAqlQry", "error", "getPostsByArea", "limit", "formatLatitude", "formatLongitude", "getPostsByLatest", "getPostsByReactions", "reactions", "formatSessionId", "formatReactions", "reaction", "sortBy", "filters", "getPostsByTags", "tags", "formatTagNames", "tag", "getPostsByUser", "formatUserId", "getPostComments", "_key", "addPost", "content", "endDate", "location", "name", "parentId", "startDate", "now", "insert", "savedPost", "contentTagNames", "userTags", "contentTags", "updatedTags", "updatePost", "parsedPost", "update", "updatedPost", "updatedPostId", "deletePost", "formatPostId", "edgeAqlQry", "fileAqlQry", "createPostEdge", "itemDocId", "edgeType", "props", "edgeCollection", "formatDocId", "edgeId", "edge"]
}

+      RETURN OLD`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+export const createPostEdge = (context, postDocId, itemDocId, edgeType = 'isPosted', props = {})=>{
+    const action = 'createPostEdge';
+    const { databaseName } = context;
+    const edgeCollection = useDb(databaseName).collection(edgeType);
+    const formatPostId = parseArangoId(postDocId);
+    const formatDocId = parseArangoId(itemDocId);
+    if (!formatDocId || !formatPostId) {
+        throw new Error(ErrorTypes.INVALID_ID);
+    }
+    const edgeId = createHash(`postEdge-${formatPostId}-${formatDocId}`);
+    const edge = {
+        _from: formatPostId,
+        _key: edgeId,
+        _to: formatDocId,
+        added: Date.now(),
+        ...props
+    };
+    return edgeCollection.save(edge, {
+        returnNew: true
+    }).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/posts.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, parseArangoId, parseChar, parseId, parseString, parseVarChar\n} from '@nlabs/utils/parsers/strings';\nimport { aql } from 'arangojs';\nimport { AqlQuery } from 'arangojs/aql';\n\nimport { parsePost } from '../adapters/postAdapter.js';\nimport { ErrorTypes } from '../types/error.types.js';\nimport { logError, logException } from '../utils/analyticsUtils.js';\nimport { getLimit, useDb } from '../utils/arangodbUtils.js';\nimport { extractTags, getTagsByName, updateTagsInItem } from './tags.js';\n\nimport type { EdgeCollection } from 'arangojs/collections';\nimport type { ArangoDbLimit } from '../types/arangodb.types.js';\nimport type { ApiContext } from '../types/auth.types.js';\nimport type { FileType } from '../types/files.types.js';\nimport type { PostInputType, PostOptions, PostType } from '../types/posts.types.js';\nimport type { TagType } from '../types/tags.types.js';\n\nconst MAX_CONTENT_LENGTH: number = 100000;\nconst eventCategory: string = 'posts';\n\nexport const parsePostOptions = (options: PostOptions = {}) => {\n  const {\n    from = 0,\n    latitude = 0,\n    longitude = 0,\n    to = 30,\n    type = 'post'\n  } = options;\n\n  return {\n    latitude: parseNum(latitude, 32),\n    limit: getLimit(from, to) as ArangoDbLimit,\n    longitude: parseNum(longitude, 32),\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getPostOptional = (fields: string[] = [], sessionId: string = '') =>\n  (fields || []).reduce((selects: {objects: string[], queries: string[]}, field: string) => {\n    switch(field) {\n      case 'hasRsvp': {\n        selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"rsvp\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('hasRsvp:hasRsvp');\n        return selects;\n      }\n      case 'isSaved': {\n        selects.queries.push(`LET isSaved = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"pin\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('isSaved:isSaved');\n        return selects;\n      }\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (\n          FOR post, r IN INBOUND p._id hasReaction\n          COLLECT reactionName = r.value INTO reactionItems\n          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n        )`);\n        selects.objects.push('reactions:reactions');\n        return selects;\n      }\n      case 'rsvpCount': {\n        selects.queries.push(`LET rsvpCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"rsvp\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('rsvpCount:rsvpCount');\n        return selects;\n      }\n      case 'viewCount': {\n        selects.queries.push(`LET viewCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReaction\n          FILTER r.name == \"view\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('viewCount:viewCount');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getPost = async (\n  context: ApiContext,\n  postId: string,\n  options?: PostOptions\n): Promise<PostType> => {\n  const action: string = 'getPost';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const formatItemId: string = parseId(postId);\n  const {type} = parsePostOptions(options);\n  const database = useDb(databaseName);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p._key == ${formatItemId} && p.type == ${type}\n    LIMIT 1\n    RETURN p`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((post: PostType) => {\n      const {\n        _id: postDocId,\n        userId,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      let privacyAqlQry: string | undefined;\n\n      if(userId === sessionId) {\n        return post;\n      }\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id hasConnection\n          FILTER u._key == \"${sessionId}\"\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      }\n\n      if(privacyAqlQry) {\n        return database.query(privacyAqlQry)\n          .then((cursor) => cursor.next())\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context));\n      }\n\n      return {};\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\n\n// export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n//   // const action: string = 'getListByApp';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {limit, type} = parsePostOptions(options);\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n//   const aqlQry: string = `FOR p IN posts\n//     FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n//     ${selectQueries.join('\\n')}\n//     ${limit.aql}\n//     SORT p.added\n//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//   return database.query(aqlQry)\n//     .then((cursor) => cursor.all())\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByArea = (\n  context: ApiContext,\n  latitude: number,\n  longitude: number,\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByArea';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  selectQueries.push(`LET distance = DISTANCE(\n    ${formatLatitude},\n    ${formatLongitude},\n    NOT_NULL(p.latitude, 0),\n    NOT_NULL(p.longitude, 0))\n  `);\n  selectObjects.push('distance:distance');\n\n  const aqlQry: string = `FOR p IN posts\n    ${selectQueries.join('\\n')}\n    FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parentId == null\n    ${limit.aql}\n    SORT distance, p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\n// export const getPostsByGroup = (\n//   context: ApiContext,\n//   groupId: string,\n//   options?: PostOptions\n// ): Promise<PostType[]> => {\n//   // const action: string = 'getListByGroup';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n\n//   // Group id\n//   const formatGroupId: string = parseId(groupId);\n//   const db = database;\n//   const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup\n//       FILTER u._key == ${sessionId}\n//       RETURN g`;\n\n//   return db.query(aqlQry)\n//     .then((cursor) => cursor.all())\n//     .then((groups: GroupType[] = []) => {\n//       if(groups.length) {\n//         const {limit, type} = parsePostOptions(options);\n//         const postAqlQry: string = `FOR p IN posts\n//           FILTER p.type == \"${type}\" && p.groupId == \"${formatGroupId}\" && p.parent == null\n//           ${selectQueries.join('\\n')}\n//           ${limit.aql}\n//           SORT p.added\n//           RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//         return db.query(postAqlQry)\n//           .then((cursor) => cursor.all())\n//           .catch((error: Error) => {\n//             throw error;\n//           });\n//       }\n\n//       return [];\n//     })\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByLatest = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n  // const action: string = 'getListByLatest';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added DESC\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getPostsByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByReactions';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatReactions: string = JSON.stringify(reactions.map((reaction) => parseChar(reaction, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(reactions.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedReactions = LENGTH(\n      FOR mr IN reactions\n      FILTER mr.matched == true\n      RETURN mr\n    )`);\n    selectObjects.push('matchedReactions:matchedReactions');\n    filters.push('matchedReactions > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('reactions:reactions');\n\n  // Get data from database\n  const aqlQry: string = `FOR p, r IN OUTBOUND \"${formatSessionId}\" hasReaction\n    LET reactions = (\n      FOR reaction, hr IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)\n      SORT reaction.name\n      RETURN MERGE(reaction, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostsByTags = (\n  context: ApiContext,\n  tags: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByTags';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatTagNames: string = JSON.stringify(tags.map((tag) => parseChar(tag, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(tags.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedTags = LENGTH(\n      FOR t IN tags\n      FILTER t.matched == true\n      RETURN t\n    )`);\n    selectObjects.push('matchedTags:matchedTags');\n    filters.push('matchedTags > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('tags:tags');\n\n  const aqlQry: string = `FOR p IN posts\n    LET tags = (\n      FOR tag, it IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)\n      SORT tag.name\n      RETURN MERGE(tag, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    SORT ${sortBy.join(', ')}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostsByUser = (context: ApiContext, userId: string, options?: PostOptions): Promise<PostType[]> => {\n  const action: string = 'getPostsByUser';\n  const {databaseName, fields, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatUserId: string = parseId(userId);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.userId == \"${formatUserId}\" && p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as PostType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const getPostComments = (context: ApiContext, postId: string, options?: PostOptions): Promise<PostType[]> => {\n  const action: string = 'getPostComments';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatItemId: string = parseId(postId);\n\n  // Get the parent post to get restrictions\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p.type == ${type} && p._key == ${formatItemId}\n    LIMIT 1\n    RETURN p`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((post: PostType) => {\n      const {\n        _key,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      // Query based on privacy level\n      let privacyAqlQry: string | undefined;\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id hasConnection\n          FILTER u._key == \"${sessionId}\"\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      }\n\n      if(privacyAqlQry) {\n        return useDb(databaseName).query(privacyAqlQry)\n          .then((cursor) => cursor.all() as unknown as PostType[])\n          .catch((error: Error) => {\n            logError({\n              action,\n              category: eventCategory,\n              label: ErrorTypes.DATABASE_ERROR\n            }, error, context);\n\n            return [] as PostType[];\n          });\n      }\n\n      return [] as PostType[];\n    })\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as PostType[];\n    });\n};\n\nexport const addPost = async (\n  context: ApiContext,\n  {\n    content = '',\n    endDate,\n    groupId = '',\n    location,\n    latitude,\n    longitude,\n    name = '',\n    parentId = '',\n    privacy = 'public',\n    tags = [],\n    startDate,\n    type = 'default'\n  }: PostInputType\n): Promise<PostType> => {\n  const action: string = 'addPost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now = Date.now();\n  const postId = createHash(`post-${sessionId}`);\n  const insert: PostType = {\n    _id: `posts/${postId}`,\n    _key: postId,\n    added: now,\n    content: parseString(content, MAX_CONTENT_LENGTH) || '',\n    endDate: endDate ? parseNum(endDate, 13) : undefined,\n    groupId: groupId ? parseId(groupId) : undefined,\n    latitude: latitude !== undefined ? parseNum(latitude) : undefined,\n    location: location ? parseString(location, 160) : undefined,\n    longitude: longitude !== undefined ? parseNum(longitude) : undefined,\n    modified: now,\n    name: parseString(name, 160),\n    parentId: parentId ? parseId(parentId) : undefined,\n    privacy: parseVarChar(privacy, 16),\n    startDate: startDate ? parseNum(startDate, 13) : undefined,\n    type: parseChar(type, 32),\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN posts RETURN NEW`;\n\n  try {\n    const savedPost: PostType = await useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n    const {_id: postDocId} = savedPost;\n    const contentTagNames = await extractTags(insert.content || '');\n\n    if(tags.length || contentTagNames.length) {\n      const userTags = (await getTagsByName(context, tags.map(({name}) => name || '')))\n        .map((tag) => ({...tag, tagBy: sessionId}));\n      const contentTags = (await getTagsByName(context, contentTagNames || []))\n        .map((tag) => ({...tag, tagBy: 'extract'}));\n      const updatedTags: TagType[] = await updateTagsInItem(\n        context,\n        {\n          itemDocId: postDocId,\n          tags: [...contentTags, ...userTags]\n        }\n      );\n\n      return {\n        ...savedPost,\n        tags: updatedTags\n      };\n    }\n\n    return savedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const updatePost = async (context: ApiContext, post: PostInputType): Promise<PostType> => {\n  const action: string = 'updatePost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now: number = Date.now();\n  const parsedPost = parsePost(post);\n  const {\n    postId,\n    tags = []\n  } = parsedPost;\n\n  const update: PostType = {\n    ...parsedPost,\n    modified: now\n  };\n\n  if(!postId) {\n    throw logException({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ID\n    }, context);\n  }\n\n  const insert = {\n    ...update,\n    _key: postId,\n    added: now,\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${postId}, userId: ${sessionId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN posts RETURN NEW`;\n\n  try {\n    const updatedPost: PostType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {}));\n    const {_id: updatedPostId} = updatedPost;\n    const contentTagNames = await extractTags(insert.content || '');\n\n    if(tags?.length || contentTagNames?.length) {\n      const userTags = tags?.length ? (await getTagsByName(context, tags.map(({name}) => name || '')))\n        .map((tag) => ({...tag, tagBy: sessionId})) : [];\n      const contentTags = contentTagNames?.length ? (await getTagsByName(context, contentTagNames || []))\n        .map((tag) => ({...tag, tagBy: 'extract'})) : [];\n      const updatedTags: TagType[] = await updateTagsInItem(\n        context,\n        {\n          itemDocId: updatedPostId,\n          tags: [...contentTags, ...userTags]\n        }\n      );\n\n      return {\n        ...updatedPost,\n        tags: updatedTags\n      };\n    }\n\n    return updatedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const deletePost = async (context: ApiContext, postDocId: string): Promise<PostType> => {\n  const action: string = 'deletePost';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const formatPostId: string = parseArangoId(postDocId);\n\n  if(!formatPostId) {\n    throw logException({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ID\n    }, context);\n  }\n\n  const edgeAqlQry: AqlQuery = aql`FOR t IN isTagged\n  FILTER t._to == ${formatPostId}\n  REMOVE t IN isTagged`;\n\n  await useDb(databaseName).query(edgeAqlQry)\n    .catch((error: Error) => {\n      throw error;\n    });\n\n  const fileAqlQry: AqlQuery = aql`FOR f IN hasFile\n    FILTER f._to == ${formatPostId}\n    REMOVE f IN hasFile`;\n\n  await useDb(databaseName).query(fileAqlQry)\n    .catch((error: Error) => {\n      throw error;\n    });\n\n  const aqlQry = aql`FOR p IN posts\n      FILTER p._id == ${formatPostId} && p.userId == ${sessionId}\n      LIMIT 1\n      REMOVE p IN posts\n      RETURN OLD`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const createPostEdge = (\n  context: ApiContext,\n  postDocId: string,\n  itemDocId: string,\n  edgeType: string = 'isPosted',\n  props = {}\n): Promise<FileType> => {\n  const action = 'createPostEdge';\n  const {databaseName} = context;\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection(edgeType);\n  const formatPostId: string = parseArangoId(postDocId);\n  const formatDocId: string = parseArangoId(itemDocId);\n\n  if(!formatDocId || !formatPostId) {\n    throw new Error(ErrorTypes.INVALID_ID);\n  }\n\n  const edgeId: string = createHash(`postEdge-${formatPostId}-${formatDocId}`);\n  const edge = {\n    _from: formatPostId,\n    _key: edgeId,\n    _to: formatDocId,\n    added: Date.now(),\n    ...props\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n    });\n};\n"],"names":["parseNum","createHash","parseArangoId","parseChar","parseId","parseString","parseVarChar","aql","parsePost","ErrorTypes","logError","logException","getLimit","useDb","extractTags","getTagsByName","updateTagsInItem","MAX_CONTENT_LENGTH","eventCategory","parsePostOptions","options","from","latitude","longitude","to","type","limit","getPostOptional","fields","sessionId","reduce","selects","field","queries","push","objects","getPost","context","postId","action","databaseName","session","userId","formatItemId","database","selectObjects","selectQueries","aqlQry","query","then","cursor","next","post","_id","postDocId","groupId","privacy","privacyAqlQry","join","catch","error","category","label","DATABASE_ERROR","getPostsByArea","formatLatitude","formatLongitude","all","getPostsByLatest","getPostsByReactions","reactions","formatSessionId","formatReactions","JSON","stringify","map","reaction","toLowerCase","sortBy","filters","length","getPostsByTags","tags","formatTagNames","tag","getPostsByUser","formatUserId","getPostComments","_key","addPost","content","endDate","location","name","parentId","startDate","now","Date","insert","added","undefined","modified","savedPost","contentTagNames","userTags","tagBy","contentTags","updatedTags","itemDocId","updatePost","parsedPost","update","value","INVALID_ID","updatedPost","updatedPostId","deletePost","formatPostId","edgeAqlQry","fileAqlQry","createPostEdge","edgeType","props","edgeCollection","collection","formatDocId","Error","edgeId","edge","_from","_to","save","returnNew"],"mappings":"AAAA;;;CAGC,GACD,SAASA,QAAQ,QAAQ,+BAA+B;AACxD,SACIC,UAAU,EAAEC,aAAa,EAAEC,SAAS,EAAEC,OAAO,EAAEC,WAAW,EAAEC,YAAY,QACrE,+BAA+B;AACtC,SAASC,GAAG,QAAQ,WAAW;AAG/B,SAASC,SAAS,QAAQ,6BAA6B;AACvD,SAASC,UAAU,QAAQ,0BAA0B;AACrD,SAASC,QAAQ,EAAEC,YAAY,QAAQ,6BAA6B;AACpE,SAASC,QAAQ,EAAEC,KAAK,QAAQ,4BAA4B;AAC5D,SAASC,WAAW,EAAEC,aAAa,EAAEC,gBAAgB,QAAQ,YAAY;AASzE,MAAMC,qBAA6B;AACnC,MAAMC,gBAAwB;AAE9B,OAAO,MAAMC,mBAAmB,CAACC,UAAuB,CAAC,CAAC;IACxD,MAAM,EACJC,OAAO,CAAC,EACRC,WAAW,CAAC,EACZC,YAAY,CAAC,EACbC,KAAK,EAAE,EACPC,OAAO,MAAM,EACd,GAAGL;IAEJ,OAAO;QACLE,UAAUtB,SAASsB,UAAU;QAC7BI,OAAOd,SAASS,MAAMG;QACtBD,WAAWvB,SAASuB,WAAW;QAC/BE,MAAMtB,UAAUsB,MAAM;IACxB;AACF,EAAE;AAEF,OAAO,MAAME,kBAAkB,CAACC,SAAmB,EAAE,EAAEC,YAAoB,EAAE,GAC3E,AAACD,CAAAA,UAAU,EAAE,AAAD,EAAGE,MAAM,CAAC,CAACC,SAAiDC;QACtE,OAAOA;YACL,KAAK;gBAAW;oBACdD,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;4EAE8C,EAAEL,UAAU;;;UAG9E,CAAC;oBACHE,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAW;oBACdA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;2EAE6C,EAAEL,UAAU;;;UAG7E,CAAC;oBACHE,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAa;oBAChBA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;;;SAIrB,CAAC;oBACFH,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAa;oBAChBA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;;;;SAKrB,CAAC;oBACFH,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA,KAAK;gBAAa;oBAChBA,QAAQE,OAAO,CAACC,IAAI,CAAC,CAAC;;;;;SAKrB,CAAC;oBACFH,QAAQI,OAAO,CAACD,IAAI,CAAC;oBACrB,OAAOH;gBACT;YACA;gBAAS;oBACP,OAAOA;gBACT;QACF;IACF,GAAG;QAACI,SAAS,EAAE;QAAEF,SAAS,EAAE;IAAA,GAAG;AAEjC,OAAO,MAAMG,UAAU,OACrBC,SACAC,QACAlB;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAMM,eAAuBvC,QAAQkC;IACrC,MAAM,EAACb,IAAI,EAAC,GAAGN,iBAAiBC;IAChC,MAAMwB,WAAW/B,MAAM2B;IACvB,MAAM,EAACL,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMkB,SAAmBxC,GAAG,CAAC;qBACV,EAAEoC,aAAa,cAAc,EAAElB,KAAK;;YAE7C,CAAC;IAEX,OAAOmB,SAASI,KAAK,CAACD,QACnBE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BF,IAAI,CAAC,CAACG;QACL,MAAM,EACJC,KAAKC,SAAS,EACdZ,MAAM,EACNa,OAAO,EACPC,UAAU,SAAS,EACpB,GAAaJ;QAEd,IAAIK;QAEJ,IAAGf,WAAWb,WAAW;YACvB,OAAOuB;QACT;QAEA,IAAGG,WAAWC,YAAY,SAAS;YACjCC,gBAAgB,CAAC,kBAAkB,EAAEH,UAAU;UAC7C,EAAER,cAAcY,IAAI,CAAC,MAAM;;;;4BAIT,EAAE7B,UAAU;;2BAEb,EAAEgB,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;QACnD,OAAO,IAAGF,YAAY,UAAU;YAC9BC,gBAAgB,CAAC,kBAAkB,EAAEH,UAAU;UAC7C,EAAER,cAAcY,IAAI,CAAC,MAAM;;2BAEV,EAAEb,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;QACnD;QAEA,IAAGD,eAAe;YAChB,OAAOb,SAASI,KAAK,CAACS,eACnBR,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC,QAAiBlD,SAAS;oBAChC6B;oBACAsB,UAAU3C;oBACV4C,OAAOrD,WAAWsD,cAAc;gBAClC,GAAGH,OAAOvB;QACd;QAEA,OAAO,CAAC;IACV,GACCsB,KAAK,CAAC,CAACC,QAAiBlD,SAAS;YAChC6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;AACd,EAAE;AAGF,oGAAoG;AACpG,8CAA8C;AAC9C,sEAAsE;AACtE,qDAAqD;AACrD,iGAAiG;AACjG,2CAA2C;AAC3C,8EAA8E;AAC9E,kCAAkC;AAClC,mBAAmB;AACnB,mBAAmB;AACnB,gEAAgE;AAEhE,kCAAkC;AAClC,sCAAsC;AACtC,iCAAiC;AACjC,qBAAqB;AACrB,UAAU;AACV,KAAK;AAEL,OAAO,MAAM2B,iBAAiB,CAC5B3B,SACAf,UACAC,WACAH;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAM6C,iBAAyBjE,SAASsB;IACxC,MAAM4C,kBAA0BlE,SAASuB;IACzC,MAAM,EAACY,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjFiB,cAAcZ,IAAI,CAAC,CAAC;IAClB,EAAE+B,eAAe;IACjB,EAAEC,gBAAgB;;;EAGpB,CAAC;IACDrB,cAAcX,IAAI,CAAC;IAEnB,MAAMa,SAAiB,CAAC;IACtB,EAAED,cAAcY,IAAI,CAAC,MAAM;sBACT,EAAEjC,KAAK;IACzB,EAAEC,MAAMnB,GAAG,CAAC;;8BAEc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,mCAAmC;AACnC,yBAAyB;AACzB,qBAAqB;AACrB,0BAA0B;AAC1B,8BAA8B;AAC9B,gDAAgD;AAChD,sEAAsE;AACtE,iGAAiG;AAEjG,gBAAgB;AAChB,oDAAoD;AACpD,yBAAyB;AACzB,0EAA0E;AAC1E,sCAAsC;AACtC,mBAAmB;AAEnB,4BAA4B;AAC5B,sCAAsC;AACtC,4CAA4C;AAC5C,4BAA4B;AAC5B,2DAA2D;AAC3D,qDAAqD;AACrD,8FAA8F;AAC9F,wCAAwC;AACxC,yBAAyB;AACzB,yBAAyB;AACzB,sEAAsE;AAEtE,sCAAsC;AACtC,4CAA4C;AAC5C,uCAAuC;AACvC,2BAA2B;AAC3B,gBAAgB;AAChB,UAAU;AAEV,mBAAmB;AACnB,SAAS;AACT,iCAAiC;AACjC,qBAAqB;AACrB,UAAU;AACV,KAAK;AAEL,OAAO,MAAM+B,mBAAmB,CAAC/B,SAAqBjB;IACpD,4CAA4C;IAC5C,MAAM,EAACoB,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAM,EAACe,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMkB,SAAiB,CAAC;sBACJ,EAAEtB,KAAK;IACzB,EAAEqB,cAAcY,IAAI,CAAC,MAAM;IAC3B,EAAEhC,MAAMnB,GAAG,CAAC;;8BAEc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;AACJ,EAAE;AAEF,OAAO,MAAMS,sBAAsB,CACjChC,SACAiC,YAAsB,EAAE,EACxBlD;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACf,QAAQ,EAAEI,KAAK,EAAEH,SAAS,EAAEE,IAAI,EAAC,GAAGN,iBAAiBC;IAC5D,MAAM,EAACe,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAM0C,kBAA0B,CAAC,MAAM,EAAE1C,WAAW;IACpD,MAAM2C,kBAA0BC,KAAKC,SAAS,CAACJ,UAAUK,GAAG,CAAC,CAACC,WAAazE,UAAUyE,UAAU,IAAIC,WAAW;IAC9G,MAAMC,SAAmB,EAAE;IAC3B,MAAMC,UAAoB;QAAC,CAAC,WAAW,EAAEtD,KAAK,CAAC,CAAC;QAAE;KAAwB;IAC1E,MAAMwC,iBAAyBjE,SAASsB;IACxC,MAAM4C,kBAA0BlE,SAASuB;IAEzC,IAAG0C,kBAAkBC,iBAAiB;QACpCpB,cAAcZ,IAAI,CAAC,CAAC;MAClB,EAAE+B,eAAe;MACjB,EAAEC,gBAAgB;;;IAGpB,CAAC;QACDrB,cAAcX,IAAI,CAAC;QACnB4C,OAAO5C,IAAI,CAAC;IACd;IAEA,IAAGoC,UAAUU,MAAM,EAAE;QACnBF,OAAO5C,IAAI,CAAC;QACZY,cAAcZ,IAAI,CAAC,CAAC;;;;KAInB,CAAC;QACFW,cAAcX,IAAI,CAAC;QACnB6C,QAAQ7C,IAAI,CAAC;IACf;IAEA4C,OAAO5C,IAAI,CAAC;IACZW,cAAcX,IAAI,CAAC;IAEnB,yBAAyB;IACzB,MAAMa,SAAiB,CAAC,sBAAsB,EAAEwB,gBAAgB;;;2BAGvC,EAAEC,gBAAgB,kBAAkB,EAAEA,gBAAgB;;;;IAI7E,EAAE1B,cAAcY,IAAI,CAAC,MAAM;WACpB,EAAEqB,QAAQrB,IAAI,CAAC,QAAQ;IAC9B,EAAEhC,MAAMnB,GAAG,CAAC;8BACc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAM4C,iBAAiB,CAC5B5C,SACA6C,OAAiB,EAAE,EACnB9D;IAEA,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACf,QAAQ,EAAEI,KAAK,EAAEH,SAAS,EAAEE,IAAI,EAAC,GAAGN,iBAAiBC;IAC5D,MAAM,EAACe,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMsD,iBAAyBV,KAAKC,SAAS,CAACQ,KAAKP,GAAG,CAAC,CAACS,MAAQjF,UAAUiF,KAAK,IAAIP,WAAW;IAC9F,MAAMC,SAAmB,EAAE;IAC3B,MAAMC,UAAoB;QAAC,CAAC,WAAW,EAAEtD,KAAK,CAAC,CAAC;QAAE;KAAwB;IAC1E,MAAMwC,iBAAyBjE,SAASsB;IACxC,MAAM4C,kBAA0BlE,SAASuB;IAEzC,IAAG0C,kBAAkBC,iBAAiB;QACpCpB,cAAcZ,IAAI,CAAC,CAAC;MAClB,EAAE+B,eAAe;MACjB,EAAEC,gBAAgB;;;IAGpB,CAAC;QACDrB,cAAcX,IAAI,CAAC;QACnB4C,OAAO5C,IAAI,CAAC;IACd;IAEA,IAAGgD,KAAKF,MAAM,EAAE;QACdF,OAAO5C,IAAI,CAAC;QACZY,cAAcZ,IAAI,CAAC,CAAC;;;;KAInB,CAAC;QACFW,cAAcX,IAAI,CAAC;QACnB6C,QAAQ7C,IAAI,CAAC;IACf;IAEA4C,OAAO5C,IAAI,CAAC;IACZW,cAAcX,IAAI,CAAC;IAEnB,MAAMa,SAAiB,CAAC;;;2BAGC,EAAEoC,eAAe,kBAAkB,EAAEA,eAAe;;;;IAI3E,EAAErC,cAAcY,IAAI,CAAC,MAAM;WACpB,EAAEqB,QAAQrB,IAAI,CAAC,QAAQ;IAC9B,EAAEhC,MAAMnB,GAAG,CAAC;SACP,EAAEuE,OAAOpB,IAAI,CAAC,MAAM;8BACC,EAAEb,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMgD,iBAAiB,CAAChD,SAAqBK,QAAgBtB;IAClE,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEZ,MAAM,EAAEa,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAClE,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAMkE,eAAuBlF,QAAQsC;IACrC,MAAM,EAACP,SAASU,aAAa,EAAEZ,SAASa,aAAa,EAAC,GAAGnB,gBAAgBC,QAAQC;IACjF,MAAMkB,SAAiB,CAAC;wBACF,EAAEuC,aAAa,gBAAgB,EAAE7D,KAAK;IAC1D,EAAEqB,cAAcY,IAAI,CAAC,MAAM;IAC3B,EAAEhC,MAAMnB,GAAG,CAAC;;8BAEc,EAAEsC,cAAca,IAAI,CAAC,MAAM,EAAE,CAAC;IAE1D,OAAO7C,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMkD,kBAAkB,CAAClD,SAAqBC,QAAgBlB;IACnE,MAAMmB,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAM,EAACX,KAAK,EAAED,IAAI,EAAC,GAAGN,iBAAiBC;IACvC,MAAMuB,eAAuBvC,QAAQkC;IAErC,0CAA0C;IAC1C,MAAMS,SAAmBxC,GAAG,CAAC;qBACV,EAAEkB,KAAK,cAAc,EAAEkB,aAAa;;YAE7C,CAAC;IAEX,OAAO9B,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BF,IAAI,CAAC,CAACG;QACL,MAAM,EACJoC,IAAI,EACJjC,OAAO,EACPC,UAAU,SAAS,EACpB,GAAaJ;QAEd,+BAA+B;QAC/B,IAAIK;QAEJ,IAAGF,WAAWC,YAAY,SAAS;YACjCC,gBAAgB,CAAC;;8BAEK,EAAE+B,KAAK;;;;;;;;;4BAST,EAAE3D,UAAU;;UAE9B,EAAEH,MAAMnB,GAAG,CAAC;6DACuC,CAAC;QACxD,OAAO,IAAGiD,YAAY,UAAU;YAC9BC,gBAAgB,CAAC;;8BAEK,EAAE+B,KAAK;;;;;;;UAO3B,EAAE9D,MAAMnB,GAAG,CAAC;6DACuC,CAAC;QACxD;QAEA,IAAGkD,eAAe;YAChB,OAAO5C,MAAM2B,cAAcQ,KAAK,CAACS,eAC9BR,IAAI,CAAC,CAACC,SAAWA,OAAOiB,GAAG,IAC3BR,KAAK,CAAC,CAACC;gBACNlD,SAAS;oBACP6B;oBACAsB,UAAU3C;oBACV4C,OAAOrD,WAAWsD,cAAc;gBAClC,GAAGH,OAAOvB;gBAEV,OAAO,EAAE;YACX;QACJ;QAEA,OAAO,EAAE;IACX,GACCsB,KAAK,CAAC,CAACC;QACNlD,SAAS;YACP6B;YACAsB,UAAU3C;YACV4C,OAAOrD,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;QAEV,OAAO,EAAE;IACX;AACJ,EAAE;AAEF,OAAO,MAAMoD,UAAU,OACrBpD,SACA,EACEqD,UAAU,EAAE,EACZC,OAAO,EACPpC,UAAU,EAAE,EACZqC,QAAQ,EACRtE,QAAQ,EACRC,SAAS,EACTsE,OAAO,EAAE,EACTC,WAAW,EAAE,EACbtC,UAAU,QAAQ,EAClB0B,OAAO,EAAE,EACTa,SAAS,EACTtE,OAAO,SAAS,EACF;IAEhB,MAAMc,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAM2D,MAAMC,KAAKD,GAAG;IACpB,MAAM1D,SAASrC,WAAW,CAAC,KAAK,EAAE4B,WAAW;IAC7C,MAAMqE,SAAmB;QACvB7C,KAAK,CAAC,MAAM,EAAEf,QAAQ;QACtBkD,MAAMlD;QACN6D,OAAOH;QACPN,SAASrF,YAAYqF,SAASzE,uBAAuB;QACrD0E,SAASA,UAAU3F,SAAS2F,SAAS,MAAMS;QAC3C7C,SAASA,UAAUnD,QAAQmD,WAAW6C;QACtC9E,UAAUA,aAAa8E,YAAYpG,SAASsB,YAAY8E;QACxDR,UAAUA,WAAWvF,YAAYuF,UAAU,OAAOQ;QAClD7E,WAAWA,cAAc6E,YAAYpG,SAASuB,aAAa6E;QAC3DC,UAAUL;QACVH,MAAMxF,YAAYwF,MAAM;QACxBC,UAAUA,WAAW1F,QAAQ0F,YAAYM;QACzC5C,SAASlD,aAAakD,SAAS;QAC/BuC,WAAWA,YAAY/F,SAAS+F,WAAW,MAAMK;QACjD3E,MAAMtB,UAAUsB,MAAM;QACtBiB,QAAQb;IACV;IACA,MAAMkB,SAAmBxC,GAAG,CAAC,OAAO,EAAE2F,OAAO,oBAAoB,CAAC;IAElE,IAAI;QACF,MAAMI,YAAsB,MAAMzF,MAAM2B,cAAcQ,KAAK,CAACD,QACzDE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC,QAAiBlD,SAAS;gBAChC6B;gBACAsB,UAAU3C;gBACV4C,OAAOrD,WAAWsD,cAAc;YAClC,GAAGH,OAAOvB;QACZ,MAAM,EAACgB,KAAKC,SAAS,EAAC,GAAGgD;QACzB,MAAMC,kBAAkB,MAAMzF,YAAYoF,OAAOR,OAAO,IAAI;QAE5D,IAAGR,KAAKF,MAAM,IAAIuB,gBAAgBvB,MAAM,EAAE;YACxC,MAAMwB,WAAW,AAAC,CAAA,MAAMzF,cAAcsB,SAAS6C,KAAKP,GAAG,CAAC,CAAC,EAACkB,IAAI,EAAC,GAAKA,QAAQ,IAAG,EAC5ElB,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO5E;gBAAS,CAAA;YAC1C,MAAM6E,cAAc,AAAC,CAAA,MAAM3F,cAAcsB,SAASkE,mBAAmB,EAAE,CAAA,EACpE5B,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO;gBAAS,CAAA;YAC1C,MAAME,cAAyB,MAAM3F,iBACnCqB,SACA;gBACEuE,WAAWtD;gBACX4B,MAAM;uBAAIwB;uBAAgBF;iBAAS;YACrC;YAGF,OAAO;gBACL,GAAGF,SAAS;gBACZpB,MAAMyB;YACR;QACF;QAEA,OAAOL;IACT,EAAE,OAAM1C,OAAO;QACb,MAAMA;IACR;AACF,EAAE;AAEF,OAAO,MAAMiD,aAAa,OAAOxE,SAAqBe;IACpD,MAAMb,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAM2D,MAAcC,KAAKD,GAAG;IAC5B,MAAMc,aAAatG,UAAU4C;IAC7B,MAAM,EACJd,MAAM,EACN4C,OAAO,EAAE,EACV,GAAG4B;IAEJ,MAAMC,SAAmB;QACvB,GAAGD,UAAU;QACbT,UAAUL;IACZ;IAEA,IAAG,CAAC1D,QAAQ;QACV,MAAM3B,aAAa;YACjB4B;YACAsB,UAAU3C;YACV8F,OAAOvG,WAAWwG,UAAU;QAC9B,GAAG5E;IACL;IAEA,MAAM6D,SAAS;QACb,GAAGa,MAAM;QACTvB,MAAMlD;QACN6D,OAAOH;QACPtD,QAAQb;IACV;IACA,MAAMkB,SAAmBxC,GAAG,CAAC,cAAc,EAAE+B,OAAO,UAAU,EAAET,UAAU;WACjE,EAAEqE,OAAO;WACT,EAAEa,OAAO;uBACG,CAAC;IAEtB,IAAI;QACF,MAAMG,cAAwB,MAAMrG,MAAM2B,cACvCQ,KAAK,CAACD,QACNE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC,QAAiBlD,SAAS;gBAChC6B;gBACAsB,UAAU3C;gBACV8F,OAAOvG,WAAWsD,cAAc;YAClC,GAAGH,OAAO,CAAC;QACb,MAAM,EAACP,KAAK8D,aAAa,EAAC,GAAGD;QAC7B,MAAMX,kBAAkB,MAAMzF,YAAYoF,OAAOR,OAAO,IAAI;QAE5D,IAAGR,MAAMF,UAAUuB,iBAAiBvB,QAAQ;YAC1C,MAAMwB,WAAWtB,MAAMF,SAAS,AAAC,CAAA,MAAMjE,cAAcsB,SAAS6C,KAAKP,GAAG,CAAC,CAAC,EAACkB,IAAI,EAAC,GAAKA,QAAQ,IAAG,EAC3FlB,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO5E;gBAAS,CAAA,KAAM,EAAE;YAClD,MAAM6E,cAAcH,iBAAiBvB,SAAS,AAAC,CAAA,MAAMjE,cAAcsB,SAASkE,mBAAmB,EAAE,CAAA,EAC9F5B,GAAG,CAAC,CAACS,MAAS,CAAA;oBAAC,GAAGA,GAAG;oBAAEqB,OAAO;gBAAS,CAAA,KAAM,EAAE;YAClD,MAAME,cAAyB,MAAM3F,iBACnCqB,SACA;gBACEuE,WAAWO;gBACXjC,MAAM;uBAAIwB;uBAAgBF;iBAAS;YACrC;YAGF,OAAO;gBACL,GAAGU,WAAW;gBACdhC,MAAMyB;YACR;QACF;QAEA,OAAOO;IACT,EAAE,OAAMtD,OAAO;QACb,MAAMA;IACR;AACF,EAAE;AAEF,OAAO,MAAMwD,aAAa,OAAO/E,SAAqBiB;IACpD,MAAMf,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQb,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGQ;IAC1D,MAAMgF,eAAuBnH,cAAcoD;IAE3C,IAAG,CAAC+D,cAAc;QAChB,MAAM1G,aAAa;YACjB4B;YACAsB,UAAU3C;YACV8F,OAAOvG,WAAWwG,UAAU;QAC9B,GAAG5E;IACL;IAEA,MAAMiF,aAAuB/G,GAAG,CAAC;kBACjB,EAAE8G,aAAa;sBACX,CAAC;IAErB,MAAMxG,MAAM2B,cAAcQ,KAAK,CAACsE,YAC7B3D,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;IAEF,MAAM2D,aAAuBhH,GAAG,CAAC;oBACf,EAAE8G,aAAa;uBACZ,CAAC;IAEtB,MAAMxG,MAAM2B,cAAcQ,KAAK,CAACuE,YAC7B5D,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;IAEF,MAAMb,SAASxC,GAAG,CAAC;sBACC,EAAE8G,aAAa,gBAAgB,EAAExF,UAAU;;;gBAGjD,CAAC;IAEf,OAAOhB,MAAM2B,cAAcQ,KAAK,CAACD,QAC9BE,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI,IAC5BQ,KAAK,CAAC,CAACC;QACN,MAAMA;IACR;AACJ,EAAE;AAEF,OAAO,MAAM4D,iBAAiB,CAC5BnF,SACAiB,WACAsD,WACAa,WAAmB,UAAU,EAC7BC,QAAQ,CAAC,CAAC;IAEV,MAAMnF,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAMsF,iBAAiC9G,MAAM2B,cAAcoF,UAAU,CAACH;IACtE,MAAMJ,eAAuBnH,cAAcoD;IAC3C,MAAMuE,cAAsB3H,cAAc0G;IAE1C,IAAG,CAACiB,eAAe,CAACR,cAAc;QAChC,MAAM,IAAIS,MAAMrH,WAAWwG,UAAU;IACvC;IAEA,MAAMc,SAAiB9H,WAAW,CAAC,SAAS,EAAEoH,aAAa,CAAC,EAAEQ,aAAa;IAC3E,MAAMG,OAAO;QACXC,OAAOZ;QACP7B,MAAMuC;QACNG,KAAKL;QACL1B,OAAOF,KAAKD,GAAG;QACf,GAAG0B,KAAK;IACV;IAEA,OAAOC,eAAeQ,IAAI,CAACH,MAAM;QAACI,WAAW;IAAI,GAC9CzE,KAAK,CAAC,CAACC;QACN,MAAMlD,SAAS;YACb6B;YACAsB,UAAU3C;YACV8F,OAAOvG,WAAWsD,cAAc;QAClC,GAAGH,OAAOvB;IACZ;AACJ,EAAE"}