@nlabs/reaktor 0.3.0 → 0.4.1

package/lib/actions/images.js

@@ -0,0 +1,682 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  addImage: () => addImage,
+  addImageEdge: () => addImageEdge,
+  deleteImage: () => deleteImage,
+  getAppImageUrl: () => getAppImageUrl,
+  getImage: () => getImage,
+  getImageCountByItem: () => getImageCountByItem,
+  getImageOptional: () => getImageOptional,
+  getImagesByGroup: () => getImagesByGroup,
+  getImagesByItem: () => getImagesByItem,
+  getImagesByReactions: () => getImagesByReactions,
+  getImagesByUser: () => getImagesByUser,
+  getPathUserImages: () => getPathUserImages,
+  getUserImageUrl: () => getUserImageUrl,
+  parseImageOptions: () => parseImageOptions,
+  resizeSaveImage: () => resizeSaveImage,
+  updateImage: () => updateImage
+});
+var import_rip_hunter = __toModule(require("@nlabs/rip-hunter"));
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_file_type = __toModule(require("file-type"));
+var import_gm = __toModule(require("gm"));
+var import_cloneDeep = __toModule(require("lodash/cloneDeep"));
+var import_isEmpty = __toModule(require("lodash/isEmpty"));
+var import_luxon = __toModule(require("luxon"));
+var import_config = __toModule(require("../config"));
+var import_utils2 = __toModule(require("../utils"));
+var import_groups = __toModule(require("./groups"));
+var import_s32 = __toModule(require("./s3"));
+const eventCategory = "images";
+const parseImageOptions = (options = {}) => {
+  const {
+    from = 0,
+    to = 30,
+    type = "default"
+  } = options;
+  return {
+    limit: (0, import_utils2.getLimit)(from, to),
+    type: (0, import_utils.parseChar)(type, 32)
+  };
+};
+const getImageOptional = (fields = []) => fields.reduce((selects, field) => {
+  if (field.includes("Count")) {
+    return (0, import_utils2.selectReactionCountByType)("images", "i", field, selects);
+  }
+  switch (field) {
+    case "reactions": {
+      selects.queries.push(`LET reactions = (
+          FOR image, r IN INBOUND i._id reactions
+          COLLECT reactionName = r.value INTO reactionItems
+          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+        )`);
+      selects.objects.push("reactions:reactions");
+      return selects;
+    }
+    case "tags": {
+      selects.queries.push(`LET tags = (
+          FOR t, pl IN INBOUND i._id isTagged
+          RETURN t
+        )`);
+      selects.objects.push("tags:tags");
+      return selects;
+    }
+    case "user": {
+      selects.queries.push(`LET user = FIRST(
+          FOR u IN users
+          FILTER i.userId == u._key
+          LIMIT 1
+          RETURN u
+        )`);
+      selects.objects.push("user:user");
+      return selects;
+    }
+    default: {
+      return selects;
+    }
+  }
+}, { objects: [], queries: [] });
+const getImagesByUser = (context, userId, from, to) => {
+  const action = "getImagesByUser";
+  const { database } = context;
+  const formatUserId = (0, import_utils.parseId)(userId);
+  const limit = (0, import_utils2.getLimit)(from, to);
+  const aqlQry = `FOR i IN images
+      FILTER i.userId == "${formatUserId}"
+      LET user = FIRST(
+        FOR u IN users
+        FILTER u._key == i.userId
+        LIMIT 1
+        RETURN u
+      )
+      ${limit.aql}
+      SORT i.added
+      RETURN MERGE(i, {user:user})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getImageCountByItem = (context, itemId) => {
+  const action = "getImageCountByItem";
+  const { database } = context;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const aqlQry = import_arangojs.aql`FOR i IN hasImages
+      FILTER i._to == ${formatItemId}
+      RETURN {count: COUNT(i)}`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then(({ count } = { count: 0 }) => count).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => 0));
+};
+const getImagesByItem = async (context, itemId, options = {}) => {
+  const action = "getImagesByItem";
+  const { database, fields = [] } = context;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const { limit } = parseImageOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getImageOptional(fields);
+  const aqlQry = `FOR i, l IN 1..1 OUTBOUND "${formatItemId}" hasImages
+    FILTER NOT IS_NULL(i)
+    ${selectQueries.join("\n")}
+    SORT i.added
+    ${limit.aql}
+    RETURN MERGE(i, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getImagesByGroup = (context, params) => {
+  const action = "getImagesByGroup";
+  const { database, session: { userId: sessionId } } = context;
+  const { filters = [], groupId, from, to } = params;
+  const formatGroupId = (0, import_utils.parseId)(groupId);
+  const limit = (0, import_utils2.getLimit)(from, to);
+  filters.map((filter) => {
+    const { conditional, name, value } = filter;
+    let formatCond = conditional;
+    if (conditional !== ">=" && conditional !== "<=" && conditional !== ">" && conditional !== "<") {
+      formatCond = "==";
+    }
+    switch (name) {
+      case "added":
+        return `p.added ${formatCond} ${(0, import_utils.parseNum)(value)}`;
+      default:
+        return "";
+    }
+  });
+  return (0, import_groups.getGroupDetails)(context, formatGroupId).then((group) => {
+    if (group.privacy === "public") {
+      filters.push(`p.groupId == "${groupId}"`);
+      const filterStr = filters.join(" && ");
+      const aqlQry = `FOR i IN
+          FLATTEN(
+            FOR p IN posts
+            FILTER ${filterStr}
+            LET images = (
+              FOR i, e IN INBOUND p._id hasImages
+              RETURN i
+            )
+            SORT p.added DESC
+            RETURN images
+          )
+          SORT i.added DESC
+          ${limit.aql}
+          RETURN i`;
+      return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+        action,
+        category: eventCategory,
+        label: "db_error"
+      }, error, context).then(() => null));
+    }
+    return (0, import_groups.isGrouped)(database, sessionId, groupId).then((grouped) => {
+      if (grouped.isValid) {
+        filters.push(`p.groupId == "${grouped.groupId}"`);
+        const filterList = filters.join(" && ");
+        const aqlQry = `FOR p IN post
+                FILTER ${filterList}
+                FOR f IN p.files
+                FILTER f.type == "image/jpeg" || f.type == "image/png"
+                ${limit.aql}
+                SORT p.added DESC
+                RETURN f`;
+        return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+          action,
+          category: eventCategory,
+          label: "db_error"
+        }, error, context).then(() => null));
+      }
+      return [];
+    });
+  });
+};
+const getImagesByReactions = (context, reactions = [], options) => {
+  const action = "getUsersByImage";
+  const { database, fields = [], session: { userId: sessionId } } = context;
+  const { limit } = parseImageOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getImageOptional(fields);
+  const formatSessionId = `users/${sessionId}`;
+  const formatReactions = reactions.map((reactionName) => (0, import_utils.parseChar)(reactionName, 32));
+  const filterBy = [
+    'r.type == "images"',
+    `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`
+  ];
+  const aqlQry = `FOR i, r IN OUTBOUND "${formatSessionId}" hasReactions
+    OPTIONS {vertexCollections: "images"}
+    ${selectQueries.join("\n")}
+    FILTER ${filterBy.join(" && ")}
+    ${limit.aql}
+    RETURN MERGE(i, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => []));
+};
+const getImage = (context, id) => {
+  const action = "getItem";
+  const { database } = context;
+  const formatId = (0, import_utils.parseId)(id);
+  const aqlQry = import_arangojs.aql`FOR i IN images
+    FILTER i._key==${formatId}
+    LIMIT 1
+    RETURN i`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((image = {}) => image).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getPathUserImages = (userId, imageId, type, dir = "images") => {
+  let filename = imageId;
+  switch (type) {
+    case "image/png":
+      filename = `${imageId}.png`;
+      break;
+    default:
+      filename = `${imageId}.jpg`;
+      break;
+  }
+  return `users/${userId}/${dir}/${filename}`;
+};
+const getAppImageUrl = (data) => {
+  const { imageId, directory = "images", imageType = "profile", isThumb, type, typeId } = data;
+  const host = import_config.Config.get("environment") === "prod" ? `https://box.${import_config.Config.get("app.url")}` : `https://s3.amazonaws.com/dev.${import_config.Config.get("app.url")}`;
+  const suffix = isThumb ? "-th" : "";
+  if (imageId) {
+    switch (type) {
+      case "apps":
+        return `${host}/${type}/${directory}/${imageId}${suffix}.jpg`;
+      case "users":
+        return `${host}/${type}/${typeId}/${directory}/${imageId}${suffix}.jpg`;
+    }
+    if (imageType === "profile") {
+      return `${host}/defaults/${type}_bk${suffix}.jpg`;
+    }
+    return `${host}/defaults/${type}_wh${suffix}.jpg`;
+  }
+  return "";
+};
+const getUserImageUrl = (data) => {
+  const { bucket, imageId, isThumb = false, userId } = data;
+  const imgDir = isThumb ? "thumbs" : "images";
+  if (imageId) {
+    const imageKey = `users/${userId}/${imgDir}/${imageId}.jpg`;
+    return (0, import_s32.s3GetSignedUrl)({ Bucket: bucket, Key: imageKey, Expires: 900 });
+  }
+  return "";
+};
+const resizeSaveImage = (context, imageId, buffer, type = "image/jpeg", s3Options) => {
+  const action = "resizeSaveImage";
+  const { session: { userId: sessionId } } = context;
+  const imgW = import_config.Config.get("image.imgSize");
+  const imgQ = import_config.Config.get("image.imgQuality");
+  let photo = {};
+  const format = type.split("/")[1];
+  console.log({ buffer, format, imgW, imgQ });
+  return new Promise((resolve) => {
+    (0, import_gm.default)(buffer, "img").setFormat(format).quality(imgQ).autoOrient().resize(imgW, imgW, ">").identify({ bufferStream: true }, (error, val = {}) => {
+      if (error) {
+        (0, import_utils2.logError)({
+          action,
+          category: eventCategory,
+          label: "image_save",
+          value: "gm_image_identify"
+        }, error, context).catch((error2) => {
+          throw error2;
+        });
+      } else {
+        const formatVals = (0, import_utils2.lowerCaseKeys)(val);
+        const { make: cameraMake, model: cameraModel, datetimeoriginal: taken } = formatVals;
+        photo = __spreadProps(__spreadValues({}, (0, import_cloneDeep.default)(photo)), {
+          make: cameraMake,
+          model: cameraModel,
+          taken: taken ? import_luxon.DateTime.fromMillis(taken).millisecond : null
+        });
+        const stats = formatVals["channel statistics"];
+        if (stats) {
+          let { red, green, blue, mean } = stats;
+          if (red) {
+            mean = red["standard deviation"] || red.mean;
+            red = mean ? +mean.split(" ")[0].substring(0, 3) : 0;
+          } else {
+            red = 0;
+          }
+          if (green) {
+            mean = green["standard deviation"] || green.mean;
+            green = mean ? +mean.split(" ")[0].substring(0, 3) : 0;
+          } else {
+            green = 0;
+          }
+          if (blue) {
+            mean = blue["standard deviation"] || blue.mean;
+            blue = mean ? +mean.split(" ")[0].substring(0, 3) : 0;
+          } else {
+            blue = 0;
+          }
+          const rgb = blue | green << 8 | red << 16;
+          const color = rgb.toString(16);
+          photo.color = color === "0" ? "000000" : color;
+        }
+      }
+    }).stream((error, stdout) => {
+      if (error) {
+        (0, import_utils2.logError)({
+          action,
+          category: eventCategory,
+          isInternal: true,
+          label: "image_save",
+          value: "gm_image_stream"
+        }, error, context).then(() => null);
+      } else {
+        let imageBuffer = Buffer.from("");
+        stdout.on("data", (data) => {
+          imageBuffer = Buffer.concat([imageBuffer, data]);
+        });
+        stdout.on("end", () => {
+          photo.fileSize = imageBuffer.length;
+          const imageObj = __spreadProps(__spreadValues({
+            ACL: "authenticated-read",
+            Body: imageBuffer,
+            Bucket: null,
+            ContentType: type
+          }, s3Options || {}), {
+            Key: getPathUserImages(sessionId, imageId, type, "images")
+          });
+          (0, import_s32.s3Put)(imageObj).then(() => {
+            const thmW = import_config.Config.get("image.thmSize");
+            const thmQ = import_config.Config.get("image.thmQuality");
+            (0, import_gm.default)(imageBuffer, "img").setFormat("jpeg").size((thumbError, resizeVal) => {
+              if (!thumbError) {
+                const { height, width } = resizeVal;
+                photo = __spreadProps(__spreadValues({}, (0, import_cloneDeep.default)(photo)), { height, width });
+              }
+            }).gravity("Center").resize(thmW, thmW, "^").extent(thmW, thmW).quality(thmQ).stream((streamError, thumbStdout) => {
+              if (streamError) {
+                (0, import_utils2.logError)({
+                  action,
+                  category: eventCategory,
+                  label: "image_save",
+                  value: "gm_thumbnail_steam"
+                }, streamError, context).catch((error2) => {
+                  throw error2;
+                });
+              } else {
+                let thumbBuffer = Buffer.from("");
+                thumbStdout.on("data", (data) => {
+                  thumbBuffer = Buffer.concat([thumbBuffer, data]);
+                });
+                thumbStdout.on("end", () => {
+                  const thumbObj = __spreadProps(__spreadValues({
+                    ACL: "authenticated-read",
+                    Body: thumbBuffer,
+                    Bucket: null,
+                    ContentType: type
+                  }, s3Options || {}), {
+                    Key: getPathUserImages(sessionId, imageId, type, "thumbs")
+                  });
+                  (0, import_s32.s3Put)(thumbObj).then(() => {
+                    resolve(photo);
+                  }).catch((s3PutError) => (0, import_utils2.logError)({
+                    action,
+                    category: eventCategory,
+                    label: "image_save",
+                    value: "s3_put_image"
+                  }, s3PutError, context).catch((error2) => {
+                    throw error2;
+                  }));
+                });
+              }
+            });
+          }).catch((s3Error) => (0, import_utils2.logError)({
+            action,
+            category: eventCategory,
+            isInternal: true,
+            label: "image_save",
+            value: "s3_image_save"
+          }, s3Error, context).then(() => null));
+        });
+      }
+    });
+  });
+};
+const addImage = (context, image, s3Options) => {
+  const action = "addImage";
+  const { database, session: { userId: sessionId } } = context;
+  const { imageId, description, buffer, fileType } = image;
+  const now = Date.now();
+  return resizeSaveImage(context, imageId, buffer, fileType, s3Options).then((resizedImage) => {
+    const insert = __spreadProps(__spreadValues({}, resizedImage), {
+      _key: imageId,
+      added: now,
+      description,
+      fileType,
+      modified: now,
+      userId: sessionId
+    });
+    const aqlQry = import_arangojs.aql`INSERT ${insert} IN images RETURN NEW`;
+    return database.query(aqlQry).then((cursor) => cursor.next()).then(import_utils2.defaultObject).catch((error) => (0, import_utils2.logError)({
+      action,
+      category: eventCategory,
+      isInternal: true,
+      label: "db_error"
+    }, error, context).then(() => null));
+  }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    isInternal: true,
+    label: "image_resize"
+  }, error, context).then(() => null));
+};
+const addImageEdge = async (context, imageEdge) => {
+  const action = "addImageEdge";
+  const { database, session: { userId: sessionId } } = context;
+  const { imageId, itemId, itemType } = imageEdge;
+  const now = Date.now();
+  const edgeCollection = database.collection("hasImages");
+  const edgeId = (0, import_utils.createHash)(`hasImages-${imageId}-${itemId}-${sessionId}`);
+  const formatItemType = (0, import_utils.parseChar)(itemType).toLowerCase();
+  const formatItemId = (0, import_utils.parseId)(itemId);
+  let itemDocId;
+  const formatImgId = (0, import_utils.parseId)(imageId);
+  const fileDocId = `images/${formatImgId}`;
+  switch (formatItemType) {
+    case "groups":
+      itemDocId = `groups/${formatItemId}`;
+      break;
+    case "posts":
+      itemDocId = `posts/${formatItemId}`;
+      break;
+    case "users":
+    case "profile":
+      itemDocId = `users/${formatItemId}`;
+      break;
+    default:
+      itemDocId = "";
+      break;
+  }
+  const edge = {
+    _from: itemDocId,
+    _key: edgeId,
+    _to: fileDocId,
+    added: now,
+    type: itemType
+  };
+  if (!(0, import_isEmpty.default)(itemDocId)) {
+    return edgeCollection.save(edge, { returnNew: true }).then((fileEdge) => edgeCollection.document(fileEdge)).catch((error) => (0, import_utils2.logError)({
+      action,
+      category: eventCategory,
+      isInternal: true,
+      label: "db_error",
+      params: {
+        edge,
+        fileDocId,
+        imageId,
+        itemDocId,
+        itemId,
+        itemType
+      }
+    }, error, context).then(() => null));
+  }
+  return {};
+};
+const updateImage = async (context, image, s3Options) => {
+  const action = "updateImage";
+  const { database, session: { userId: sessionId } } = context;
+  const {
+    base64 = "",
+    buffer: imageBuffer,
+    description = "",
+    imageId,
+    itemId,
+    itemType,
+    fileType,
+    url = ""
+  } = image;
+  const now = Date.now();
+  const formatImageId = imageId || (0, import_utils.createHash)(`image-${sessionId}`);
+  const formatItemId = (0, import_utils.parseId)(itemId);
+  const formatItemType = (0, import_utils.parseChar)(itemType, 16).toLowerCase();
+  const customParams = {
+    description,
+    imageId: formatImageId,
+    userId: sessionId
+  };
+  if (!(0, import_isEmpty.default)(base64) || imageBuffer) {
+    let buffer = imageBuffer;
+    if (!(0, import_isEmpty.default)(base64)) {
+      const formatBase64 = base64.substr(base64.indexOf(",") + 1);
+      buffer = Buffer.from(formatBase64, "base64");
+    }
+    let updatedFileType = fileType;
+    if (!fileType) {
+      const fileMime = await import_file_type.default.fromBuffer(buffer);
+      const { mime } = fileMime;
+      updatedFileType = mime;
+    }
+    const imgParams = __spreadProps(__spreadValues({}, customParams), {
+      buffer,
+      fileType: updatedFileType
+    });
+    return addImage(context, imgParams, s3Options).then((image2) => {
+      if (formatItemId && formatItemType) {
+        const imageEdge = {
+          imageId: formatImageId,
+          itemId: formatItemId,
+          itemType: formatItemType
+        };
+        return addImageEdge(context, imageEdge).then(() => image2);
+      }
+      return image2;
+    }).catch((error) => (0, import_utils2.logError)({
+      action,
+      category: eventCategory,
+      label: "image_save_error"
+    }, error, context).then(() => null));
+  } else if (url !== "") {
+    let contentType;
+    return (0, import_rip_hunter.get)(url).then((res) => {
+      if (res.status !== 200) {
+        return (0, import_utils2.logException)({
+          action,
+          category: eventCategory,
+          label: "fetch_image_url",
+          value: res.statusText
+        }, context).then(() => null);
+      }
+      contentType = res.headers.get("content-type");
+      return res;
+    }).then((res) => res.buffer()).then((buffer) => {
+      const imgParams = __spreadProps(__spreadValues({}, customParams), {
+        buffer,
+        fileType: contentType
+      });
+      return addImage(context, imgParams, s3Options).then((image2) => {
+        if (formatItemId && formatItemType) {
+          const imageEdge = { imageId: formatImageId, itemId: formatItemId, itemType: formatItemType };
+          return addImageEdge(context, imageEdge).then(() => image2);
+        }
+        return image2;
+      });
+    }).catch((error) => (0, import_utils2.logError)({
+      action,
+      category: eventCategory,
+      label: "fetch_error"
+    }, error, context).then(() => null));
+  } else if (imageId !== "") {
+    const update = {
+      description,
+      modified: now
+    };
+    const aqlQry = import_arangojs.aql`UPDATE {_key: ${formatImageId}} WITH ${update} IN images RETURN NEW`;
+    return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+      action,
+      category: eventCategory,
+      label: "db_error",
+      params: {
+        aqlQry,
+        formatImageId,
+        update
+      }
+    }, error, context).then(() => null));
+  }
+  return null;
+};
+const deleteImage = async (context, imageId) => {
+  const action = "delete";
+  const { database, session: { userId: sessionId } } = context;
+  const formatImageId = (0, import_utils.parseId)(imageId);
+  const removeEdgeQuery = import_arangojs.aql`FOR hi IN hasImages
+    FILTER hi._from == ${formatImageId}
+    REMOVE hi IN hasImages
+    RETURN OLD`;
+  await database.query(removeEdgeQuery);
+  const aqlQuery = import_arangojs.aql`FOR i IN images
+    FILTER i._key == ${formatImageId} && i.userId == ${sessionId}
+    REMOVE i IN images
+    RETURN OLD`;
+  const image = await database.query(aqlQuery).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+  if (!(0, import_isEmpty.default)(image)) {
+    const { _key: imageKey } = image;
+    const params = {
+      Bucket: null,
+      Delete: {
+        Objects: [
+          { Key: `users/${sessionId}/images/${imageKey}.jpg` },
+          { Key: `users/${sessionId}/thumbs/${imageKey}.jpg` }
+        ],
+        Quiet: true
+      }
+    };
+    return (0, import_s32.s3DeleteList)(params).then(() => image);
+  }
+  return {};
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addImage,
+  addImageEdge,
+  deleteImage,
+  getAppImageUrl,
+  getImage,
+  getImageCountByItem,
+  getImageOptional,
+  getImagesByGroup,
+  getImagesByItem,
+  getImagesByReactions,
+  getImagesByUser,
+  getPathUserImages,
+  getUserImageUrl,
+  parseImageOptions,
+  resizeSaveImage,
+  updateImage
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/images.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 {get as httpGet} from '@nlabs/rip-hunter';\nimport {createHash, parseArangoId, parseChar, parseId, parseNum} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport {DeleteObjectsRequest, PutObjectRequest} from 'aws-sdk/clients/s3';\nimport FileType, {FileTypeResult} from 'file-type';\nimport gm from 'gm';\nimport cloneDeep from 'lodash/cloneDeep';\nimport isEmpty from 'lodash/isEmpty';\nimport {DateTime} from 'luxon';\n\nimport {Config} from '../config';\nimport {\n  ApiContext,\n  ArangoDBLimit,\n  GroupType,\n  GroupUser,\n  ImageEdgeType,\n  ImageIdentifyType,\n  ImageOptions,\n  ImageType,\n  ImageUrlData,\n  QueryFilter\n} from '../types';\nimport {defaultObject, getLimit, logError, logException, lowerCaseKeys, selectReactionCountByType} from '../utils';\nimport {getGroupDetails, isGrouped} from './groups';\nimport {s3DeleteList, s3GetSignedUrl, s3Put} from './s3';\n\nconst eventCategory: string = 'images';\n\nexport const parseImageOptions = (options: ImageOptions = {}) => {\n  const {\n    from = 0,\n    to = 30,\n    type = 'default'\n  } = options;\n\n  return {\n    limit: getLimit(from, to),\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getImageOptional = (fields: string[] = []) =>\n  fields.reduce((selects: any, field: string) => {\n    if(field.includes('Count')) {\n      return selectReactionCountByType('images', 'i', field, selects);\n    }\n\n    switch(field) {\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (\n          FOR image, r IN INBOUND i._id reactions\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 'tags': {\n        selects.queries.push(`LET tags = (\n          FOR t, pl IN INBOUND i._id isTagged\n          RETURN t\n        )`);\n        selects.objects.push('tags:tags');\n        return selects;\n      }\n      case 'user': {\n        selects.queries.push(`LET user = FIRST(\n          FOR u IN users\n          FILTER i.userId == u._key\n          LIMIT 1\n          RETURN u\n        )`);\n        selects.objects.push('user:user');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getImagesByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number,\n  to: number\n): Promise<ImageType[]> => {\n  const action: string = 'getImagesByUser';\n  const {database} = context;\n  const formatUserId: string = parseId(userId);\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR i IN images\n      FILTER i.userId == \"${formatUserId}\"\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == i.userId\n        LIMIT 1\n        RETURN u\n      )\n      ${limit.aql}\n      SORT i.added\n      RETURN MERGE(i, {user:user})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getImageCountByItem = (context: ApiContext, itemId: string): Promise<number> => {\n  const action: string = 'getImageCountByItem';\n  const {database} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const aqlQry: AqlQuery = aql`FOR i IN hasImages\n      FILTER i._to == ${formatItemId}\n      RETURN {count: COUNT(i)}`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then(({count} = {count: 0}) => count)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => 0));\n};\n\nexport const getImagesByItem = async (\n  context: ApiContext,\n  itemId: string,\n  options: ImageOptions = {}\n): Promise<ImageType[]> => {\n  const action: string = 'getImagesByItem';\n  const {database, fields = []} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptional(fields);\n  const aqlQry: string = `FOR i, l IN 1..1 OUTBOUND \"${formatItemId}\" hasImages\n    FILTER NOT IS_NULL(i)\n    ${selectQueries.join('\\n')}\n    SORT i.added\n    ${limit.aql}\n    RETURN MERGE(i, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getImagesByGroup = (context: ApiContext, params): Promise<ImageType[]> => {\n  const action: string = 'getImagesByGroup';\n  const {database, session: {userId: sessionId}} = context;\n  const {filters = [], groupId, from, to} = params;\n  const formatGroupId: string = parseId(groupId);\n  const limit = getLimit(from, to);\n\n  filters\n    .map((filter: QueryFilter) => {\n      const {conditional, name, value} = filter;\n      let formatCond: string = conditional;\n\n      if(conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {\n        formatCond = '==';\n      }\n\n      switch(name) {\n        case 'added':\n          return `p.added ${formatCond} ${parseNum(value)}`;\n        default:\n          return '';\n      }\n    });\n\n  return getGroupDetails(context, formatGroupId)\n    .then((group: GroupType) => {\n      if(group.privacy === 'public') {\n        filters.push(`p.groupId == \"${groupId}\"`);\n        const filterStr = filters.join(' && ');\n        const aqlQry: string = `FOR i IN\n          FLATTEN(\n            FOR p IN posts\n            FILTER ${filterStr}\n            LET images = (\n              FOR i, e IN INBOUND p._id hasImages\n              RETURN i\n            )\n            SORT p.added DESC\n            RETURN images\n          )\n          SORT i.added DESC\n          ${limit.aql}\n          RETURN i`;\n\n        return database.query(aqlQry)\n          .then((cursor: ArrayCursor) => cursor.all())\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            label: 'db_error'\n          }, error, context).then(() => null));\n      }\n      return isGrouped(database, sessionId, groupId)\n        .then((grouped: GroupUser) => {\n          if(grouped.isValid) {\n            filters.push(`p.groupId == \"${grouped.groupId}\"`);\n            const filterList: string = filters.join(' && ');\n            const aqlQry: string = `FOR p IN post\n                FILTER ${filterList}\n                FOR f IN p.files\n                FILTER f.type == \"image/jpeg\" || f.type == \"image/png\"\n                ${limit.aql}\n                SORT p.added DESC\n                RETURN f`;\n\n            return database.query(aqlQry)\n              .then((cursor: ArrayCursor) => cursor.all())\n              .catch((error: Error) => logError({\n                action,\n                category: eventCategory,\n                label: 'db_error'\n              }, error, context).then(() => null));\n          }\n          return [];\n        });\n    });\n};\n\nexport const getImagesByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: ImageOptions\n): Promise<ImageType[]> => {\n  const action: string = 'getUsersByImage';\n  const {database, fields = [], session: {userId: sessionId}} = context;\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptional(fields);\n\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatReactions: string[] = reactions.map((reactionName) => parseChar(reactionName, 32));\n  const filterBy: string[] = [\n    'r.type == \"images\"',\n    `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`];\n\n  // Get data from database\n  const aqlQry: string = `FOR i, r IN OUTBOUND \"${formatSessionId}\" hasReactions\n    OPTIONS {vertexCollections: \"images\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN MERGE(i, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => []));\n};\n\nexport const getImage = (context: ApiContext, id: string): Promise<ImageType> => {\n  const action: string = 'getItem';\n  const {database} = context;\n  const formatId: string = parseId(id);\n  const aqlQry: AqlQuery = aql`FOR i IN images\n    FILTER i._key==${formatId}\n    LIMIT 1\n    RETURN i`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((image: ImageType = {}) => image)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getPathUserImages = (userId: string, imageId: string, type: string, dir: string = 'images'): string => {\n  let filename: string = imageId;\n\n  switch(type) {\n    case 'image/png':\n      filename = `${imageId}.png`;\n      break;\n    default:\n      filename = `${imageId}.jpg`;\n      break;\n  }\n\n  return `users/${userId}/${dir}/${filename}`;\n};\n\nexport const getAppImageUrl = (data: ImageUrlData): string => {\n  const {imageId, directory = 'images', imageType = 'profile', isThumb, type, typeId} = data;\n  const host: string = Config.get('environment') === 'prod'\n    ? `https://box.${Config.get('app.url')}`\n    : `https://s3.amazonaws.com/dev.${Config.get('app.url')}`;\n  const suffix: string = isThumb ? '-th' : '';\n\n  if(imageId) {\n    switch(type) {\n      case 'apps':\n        // https://box.reaktor.io/myApp/app/images/123.jpg\n        return `${host}/${type}/${directory}/${imageId}${suffix}.jpg`;\n      case 'users':\n        // https://box.reaktor.io/myApp/users/demoUser/images/123.jpg\n        return `${host}/${type}/${typeId}/${directory}/${imageId}${suffix}.jpg`;\n    }\n\n    if(imageType === 'profile') {\n      return `${host}/defaults/${type}_bk${suffix}.jpg`;\n    }\n\n    return `${host}/defaults/${type}_wh${suffix}.jpg`;\n  }\n\n  return '';\n};\n\nexport const getUserImageUrl = (data: ImageUrlData): string => {\n  const {bucket, imageId, isThumb = false, userId} = data;\n  const imgDir: string = isThumb ? 'thumbs' : 'images';\n\n  if(imageId) {\n    const imageKey: string = `users/${userId}/${imgDir}/${imageId}.jpg`;\n    return s3GetSignedUrl({Bucket: bucket, Key: imageKey, Expires: 900});\n  }\n\n  return '';\n};\n\nexport const resizeSaveImage = (\n  context: ApiContext,\n  imageId: string,\n  buffer: Buffer,\n  type: string = 'image/jpeg', s3Options?: PutObjectRequest): Promise<ImageType> => {\n  const action: string = 'resizeSaveImage';\n  const {session: {userId: sessionId}} = context;\n  const imgW: number = Config.get('image.imgSize');\n  const imgQ: number = Config.get('image.imgQuality');\n  let photo: ImageType = {};\n  const format: string = (type.split('/'))[1];\n\n  console.log({buffer, format, imgW, imgQ});\n  return new Promise((resolve) => {\n    gm(buffer, 'img')\n      .setFormat(format)\n      .quality(imgQ)\n      .autoOrient()\n      .resize(imgW, imgW, '>')\n      .identify({bufferStream: true}, (error: Error, val: ImageIdentifyType = {}): any => {\n        if(error) {\n          logError({\n            action,\n            category: eventCategory,\n            label: 'image_save',\n            value: 'gm_image_identify'\n          }, error, context).catch((error) => {\n            throw error;\n          });\n        } else {\n          const formatVals = lowerCaseKeys(val);\n          const {make: cameraMake, model: cameraModel, datetimeoriginal: taken}: ImageIdentifyType = formatVals;\n          photo = {\n            ...cloneDeep(photo),\n            make: cameraMake,\n            model: cameraModel,\n            taken: taken ? DateTime.fromMillis(taken).millisecond : null\n          };\n\n          // If no background color, get the mean color value\n          const stats = formatVals['channel statistics'];\n\n          if(stats) {\n            let {red, green, blue, mean} = stats;\n\n            if(red) {\n              mean = red['standard deviation'] || red.mean;\n              red = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;\n            } else {\n              red = 0;\n            }\n\n            if(green) {\n              mean = green['standard deviation'] || green.mean;\n              green = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;\n            } else {\n              green = 0;\n            }\n\n            if(blue) {\n              mean = blue['standard deviation'] || blue.mean;\n              blue = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;\n            } else {\n              blue = 0;\n            }\n\n            const rgb = blue | (green << 8) | (red << 16);\n            const color = rgb.toString(16);\n            photo.color = color === '0' ? '000000' : color;\n          }\n        }\n      })\n      .stream((error: Error, stdout): any => {\n        if(error) {\n          logError({\n            action,\n            category: eventCategory,\n            isInternal: true,\n            label: 'image_save',\n            value: 'gm_image_stream'\n          }, error, context).then(() => null);\n        } else {\n          let imageBuffer: Buffer = Buffer.from('');\n\n          stdout.on('data', (data) => {\n            imageBuffer = Buffer.concat([imageBuffer, data]);\n          });\n\n          stdout.on('end', () => {\n            // Get file size\n            photo.fileSize = imageBuffer.length;\n\n            // Upload data\n            const imageObj: PutObjectRequest = {\n              ACL: 'authenticated-read',\n              Body: imageBuffer,\n              Bucket: null,\n              ContentType: type,\n              ...s3Options || {},\n              Key: getPathUserImages(sessionId, imageId, type, 'images')\n            };\n\n            s3Put(imageObj)\n              .then(() => {\n                const thmW = Config.get('image.thmSize');\n                const thmQ = Config.get('image.thmQuality');\n\n                // Upload thumbnail\n                gm(imageBuffer, 'img')\n                  .setFormat('jpeg')\n                  .size((thumbError: Error, resizeVal) => {\n                    if(!thumbError) {\n                      // Get updated resize values\n                      const {height, width} = resizeVal;\n                      photo = {...cloneDeep(photo), height, width};\n                    }\n                  })\n                  .gravity('Center')\n                  .resize(thmW, thmW, '^')\n                  .extent(thmW, thmW)\n                  .quality(thmQ)\n                  .stream((streamError: Error, thumbStdout): any => {\n                    if(streamError) {\n                      logError({\n                        action,\n                        category: eventCategory,\n                        label: 'image_save',\n                        value: 'gm_thumbnail_steam'\n                      }, streamError, context)\n                        .catch((error) => {\n                          throw error;\n                        });\n                    } else {\n                      let thumbBuffer: Buffer = Buffer.from('');\n\n                      thumbStdout.on('data', (data) => {\n                        thumbBuffer = Buffer.concat([thumbBuffer, data]);\n                      });\n\n                      thumbStdout.on('end', () => {\n                        // Upload data\n                        const thumbObj: PutObjectRequest = {\n                          ACL: 'authenticated-read',\n                          Body: thumbBuffer,\n                          Bucket: null,\n                          ContentType: type,\n                          ...s3Options || {},\n                          Key: getPathUserImages(sessionId, imageId, type, 'thumbs')\n                        };\n\n                        s3Put(thumbObj)\n                          .then(() => {\n                            resolve(photo);\n                          })\n                          .catch((s3PutError) => logError({\n                            action,\n                            category: eventCategory,\n                            label: 'image_save',\n                            value: 's3_put_image'\n                          }, s3PutError, context)\n                            .catch((error) => {\n                              throw error;\n                            }));\n                      });\n                    }\n                  });\n              })\n              .catch((s3Error) => logError({\n                action,\n                category: eventCategory,\n                isInternal: true,\n                label: 'image_save',\n                value: 's3_image_save'\n              }, s3Error, context).then(() => null));\n          });\n        }\n      });\n  });\n};\n\nexport const addImage = (context: ApiContext, image: ImageType, s3Options?: PutObjectRequest): Promise<ImageType> => {\n  const action: string = 'addImage';\n  const {database, session: {userId: sessionId}} = context;\n  const {imageId, description, buffer, fileType} = image;\n  const now: number = Date.now();\n\n  return resizeSaveImage(context, imageId, buffer, fileType, s3Options)\n    .then((resizedImage: any) => {\n      const insert: ImageType = {\n        ...resizedImage,\n        _key: imageId,\n        added: now,\n        description,\n        fileType,\n        modified: now,\n        userId: sessionId\n      };\n\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN images RETURN NEW`;\n\n      return database.query(aqlQry)\n        .then((cursor: ArrayCursor) => cursor.next())\n        .then(defaultObject)\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          isInternal: true,\n          label: 'db_error'\n        }, error, context).then(() => null));\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      isInternal: true,\n      label: 'image_resize'\n    }, error, context).then(() => null));\n};\n\nexport const addImageEdge = async (context: ApiContext, imageEdge: ImageEdgeType): Promise<object> => {\n  const action: string = 'addImageEdge';\n  const {database, session: {userId: sessionId}} = context;\n  const {imageId, itemId, itemType} = imageEdge;\n  const now: number = Date.now();\n  const edgeCollection: EdgeCollection = database.collection('hasImages');\n  const edgeId: string = createHash(`hasImages-${imageId}-${itemId}-${sessionId}`);\n  const formatItemType: string = parseChar(itemType).toLowerCase();\n  const formatItemId: string = parseId(itemId);\n  let itemDocId: string;\n  const formatImgId: string = parseId(imageId);\n  const fileDocId: string = `images/${formatImgId}`;\n\n  switch(formatItemType) {\n    case 'groups':\n      itemDocId = `groups/${formatItemId}`;\n      break;\n    case 'posts':\n      itemDocId = `posts/${formatItemId}`;\n      break;\n    case 'users':\n    case 'profile':\n      itemDocId = `users/${formatItemId}`;\n      break;\n    default:\n      itemDocId = '';\n      break;\n  }\n  const edge: any = {\n    _from: itemDocId,\n    _key: edgeId,\n    _to: fileDocId,\n    added: now,\n    type: itemType\n  };\n\n  if(!isEmpty(itemDocId)) {\n    return edgeCollection.save(edge, {returnNew: true})\n      .then((fileEdge) => edgeCollection.document(fileEdge))\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        isInternal: true,\n        label: 'db_error',\n        params: {\n          edge,\n          fileDocId,\n          imageId,\n          itemDocId,\n          itemId,\n          itemType\n        }\n      }, error, context).then(() => null));\n  }\n\n  return {};\n};\n\nexport const updateImage = async (\n  context: ApiContext,\n  image: ImageType,\n  s3Options?: PutObjectRequest\n): Promise<ImageType> => {\n  const action: string = 'updateImage';\n  const {database, session: {userId: sessionId}} = context;\n\n  // Item props\n  const {\n    base64 = '',\n    buffer: imageBuffer,\n    description = '',\n    imageId,\n    itemId,\n    itemType,\n    fileType,\n    url = ''\n  } = image;\n\n  // Save Base64 data\n  const now: number = Date.now();\n  const formatImageId: string = imageId || createHash(`image-${sessionId}`);\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: string = parseChar(itemType, 16).toLowerCase();\n  const customParams: ImageType = {\n    description,\n    imageId: formatImageId,\n    userId: sessionId\n  };\n\n  if(!isEmpty(base64) || imageBuffer) {\n    let buffer: Buffer = imageBuffer;\n\n    // Parse Base64 data\n    if(!isEmpty(base64)) {\n      const formatBase64: string = base64.substr(base64.indexOf(',') + 1);\n      buffer = Buffer.from(formatBase64, 'base64');\n    }\n\n    let updatedFileType = fileType;\n\n    if(!fileType) {\n      const fileMime: FileTypeResult = await FileType.fromBuffer(buffer);\n      const {mime} = fileMime;\n      updatedFileType = mime;\n    }\n\n    const imgParams: ImageType = {\n      ...customParams,\n      buffer,\n      fileType: updatedFileType\n    };\n\n    return addImage(context, imgParams, s3Options)\n      .then((image: ImageType) => {\n        if(formatItemId && formatItemType) {\n          const imageEdge: ImageEdgeType = {\n            imageId: formatImageId,\n            itemId: formatItemId,\n            itemType: formatItemType\n          };\n          return addImageEdge(context, imageEdge).then(() => image);\n        }\n\n        return image;\n      })\n      .catch((error) => logError({\n        action,\n        category: eventCategory,\n        label: 'image_save_error'\n      }, error, context).then(() => null));\n  } else if(url !== '') {\n    // Download image from the web\n    let contentType: string;\n\n    return httpGet(url)\n      .then((res: Response) => {\n        if(res.status !== 200) {\n          return logException({\n            action,\n            category: eventCategory,\n            label: 'fetch_image_url',\n            value: res.statusText\n          }, context).then(() => null);\n        }\n\n        contentType = res.headers.get('content-type');\n\n        return res;\n      })\n      .then((res) => res.buffer())\n      .then((buffer: Buffer) => {\n        const imgParams: ImageType = {\n          ...customParams,\n          buffer,\n          fileType: contentType\n        };\n\n        return addImage(context, imgParams, s3Options).then((image: ImageType) => {\n          if(formatItemId && formatItemType) {\n            const imageEdge: ImageEdgeType = {imageId: formatImageId, itemId: formatItemId, itemType: formatItemType};\n            return addImageEdge(context, imageEdge).then(() => image);\n          }\n\n          return image;\n        });\n      })\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: 'fetch_error'\n      }, error, context).then(() => null));\n  } else if(imageId !== '') {\n    // Update metadata\n    const update: any = {\n      description,\n      modified: now\n    };\n    const aqlQry: AqlQuery = aql`UPDATE {_key: ${formatImageId}} WITH ${update} IN images RETURN NEW`;\n\n    return database.query(aqlQry)\n      .then((cursor: ArrayCursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: 'db_error',\n        params: {\n          aqlQry,\n          formatImageId,\n          update\n        }\n      }, error, context).then(() => null));\n  }\n\n  return null;\n};\n\nexport const deleteImage = async (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const action: string = 'delete';\n  const {database, session: {userId: sessionId}} = context;\n  const formatImageId = parseId(imageId);\n\n  const removeEdgeQuery = aql`FOR hi IN hasImages\n    FILTER hi._from == ${formatImageId}\n    REMOVE hi IN hasImages\n    RETURN OLD`;\n\n  await database.query(removeEdgeQuery);\n\n  const aqlQuery = aql`FOR i IN images\n    FILTER i._key == ${formatImageId} && i.userId == ${sessionId}\n    REMOVE i IN images\n    RETURN OLD`;\n\n  const image = await database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n\n  if(!isEmpty(image)) {\n    const {_key: imageKey} = image;\n    const params: DeleteObjectsRequest = {\n      Bucket: null,\n      Delete: {\n        Objects: [\n          {Key: `users/${sessionId}/images/${imageKey}.jpg`},\n          {Key: `users/${sessionId}/thumbs/${imageKey}.jpg`}\n        ],\n        Quiet: true\n      }\n    };\n\n    return s3DeleteList(params).then(() => image);\n  }\n\n  return {};\n};\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,wBAA6B;AAC7B,mBAAsE;AACtE,sBAAkB;AAKlB,uBAAuC;AACvC,gBAAe;AACf,uBAAsB;AACtB,qBAAoB;AACpB,mBAAuB;AAEvB,oBAAqB;AAarB,oBAAwG;AACxG,oBAAyC;AACzC,iBAAkD;AAElD,MAAM,gBAAwB;AAEvB,MAAM,oBAAoB,CAAC,UAAwB,OAAO;AAC/D,QAAM;AAAA,IACJ,OAAO;AAAA,IACP,KAAK;AAAA,IACL,OAAO;AAAA,MACL;AAEJ,SAAO;AAAA,IACL,OAAO,4BAAS,MAAM;AAAA,IACtB,MAAM,4BAAU,MAAM;AAAA;AAAA;AAInB,MAAM,mBAAmB,CAAC,SAAmB,OAClD,OAAO,OAAO,CAAC,SAAc,UAAkB;AAC7C,MAAG,MAAM,SAAS,UAAU;AAC1B,WAAO,6CAA0B,UAAU,KAAK,OAAO;AAAA;AAGzD,UAAO;AAAA,SACA,aAAa;AAChB,cAAQ,QAAQ,KAAK;AAAA;AAAA;AAAA;AAAA;AAKrB,cAAQ,QAAQ,KAAK;AACrB,aAAO;AAAA;AAAA,SAEJ,QAAQ;AACX,cAAQ,QAAQ,KAAK;AAAA;AAAA;AAAA;AAIrB,cAAQ,QAAQ,KAAK;AACrB,aAAO;AAAA;AAAA,SAEJ,QAAQ;AACX,cAAQ,QAAQ,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAMrB,cAAQ,QAAQ,KAAK;AACrB,aAAO;AAAA;AAAA,aAEA;AACP,aAAO;AAAA;AAAA;AAAA,GAGV,EAAC,SAAS,IAAI,SAAS;AAErB,MAAM,kBAAkB,CAC7B,SACA,QACA,MACA,OACyB;AACzB,QAAM,SAAiB;AACvB,QAAM,EAAC,aAAY;AACnB,QAAM,eAAuB,0BAAQ;AACrC,QAAM,QAAuB,4BAAS,MAAM;AAC5C,QAAM,SAAiB;AAAA,4BACG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOpB,MAAM;AAAA;AAAA;AAIZ,SAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,OACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAG3B,MAAM,sBAAsB,CAAC,SAAqB,WAAoC;AAC3F,QAAM,SAAiB;AACvB,QAAM,EAAC,aAAY;AACnB,QAAM,eAAuB,gCAAc;AAC3C,QAAM,SAAmB;AAAA,wBACH;AAAA;AAGtB,SAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,QACrC,KAAK,CAAC,EAAC,UAAS,EAAC,OAAO,QAAO,OAC/B,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAG3B,MAAM,kBAAkB,OAC7B,SACA,QACA,UAAwB,OACC;AACzB,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,OAAM;AAChC,QAAM,eAAuB,gCAAc;AAC3C,QAAM,EAAC,UAAS,kBAAkB;AAClC,QAAM,EAAC,SAAS,eAAe,SAAS,kBAAiB,iBAAiB;AAC1E,QAAM,SAAiB,8BAA8B;AAAA;AAAA,MAEjD,cAAc,KAAK;AAAA;AAAA,MAEnB,MAAM;AAAA,uBACW,cAAc,KAAK;AAExC,SAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,OACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAG3B,MAAM,mBAAmB,CAAC,SAAqB,WAAiC;AACrF,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,gBAAc;AACjD,QAAM,EAAC,UAAU,IAAI,SAAS,MAAM,OAAM;AAC1C,QAAM,gBAAwB,0BAAQ;AACtC,QAAM,QAAQ,4BAAS,MAAM;AAE7B,UACG,IAAI,CAAC,WAAwB;AAC5B,UAAM,EAAC,aAAa,MAAM,UAAS;AACnC,QAAI,aAAqB;AAEzB,QAAG,gBAAgB,QAAQ,gBAAgB,QAAQ,gBAAgB,OAAO,gBAAgB,KAAK;AAC7F,mBAAa;AAAA;AAGf,YAAO;AAAA,WACA;AACH,eAAO,WAAW,cAAc,2BAAS;AAAA;AAEzC,eAAO;AAAA;AAAA;AAIf,SAAO,mCAAgB,SAAS,eAC7B,KAAK,CAAC,UAAqB;AAC1B,QAAG,MAAM,YAAY,UAAU;AAC7B,cAAQ,KAAK,iBAAiB;AAC9B,YAAM,YAAY,QAAQ,KAAK;AAC/B,YAAM,SAAiB;AAAA;AAAA;AAAA,qBAGV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAST,MAAM;AAAA;AAGV,aAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,OACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,QAChC;AAAA,QACA,UAAU;AAAA,QACV,OAAO;AAAA,SACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAElC,WAAO,6BAAU,UAAU,WAAW,SACnC,KAAK,CAAC,YAAuB;AAC5B,UAAG,QAAQ,SAAS;AAClB,gBAAQ,KAAK,iBAAiB,QAAQ;AACtC,cAAM,aAAqB,QAAQ,KAAK;AACxC,cAAM,SAAiB;AAAA,yBACV;AAAA;AAAA;AAAA,kBAGP,MAAM;AAAA;AAAA;AAIZ,eAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,OACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,UAChC;AAAA,UACA,UAAU;AAAA,UACV,OAAO;AAAA,WACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAElC,aAAO;AAAA;AAAA;AAAA;AAKV,MAAM,uBAAuB,CAClC,SACA,YAAsB,IACtB,YACyB;AACzB,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,IAAI,SAAS,EAAC,QAAQ,gBAAc;AAC9D,QAAM,EAAC,UAAS,kBAAkB;AAClC,QAAM,EAAC,SAAS,eAAe,SAAS,kBAAiB,iBAAiB;AAE1E,QAAM,kBAA0B,SAAS;AACzC,QAAM,kBAA4B,UAAU,IAAI,CAAC,iBAAiB,4BAAU,cAAc;AAC1F,QAAM,WAAqB;AAAA,IACzB;AAAA,IACA,YAAY,KAAK,UAAU;AAAA;AAG7B,QAAM,SAAiB,yBAAyB;AAAA;AAAA,MAE5C,cAAc,KAAK;AAAA,aACZ,SAAS,KAAK;AAAA,MACrB,MAAM;AAAA,uBACW,cAAc,KAAK;AAExC,SAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,OACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAG3B,MAAM,WAAW,CAAC,SAAqB,OAAmC;AAC/E,QAAM,SAAiB;AACvB,QAAM,EAAC,aAAY;AACnB,QAAM,WAAmB,0BAAQ;AACjC,QAAM,SAAmB;AAAA,qBACN;AAAA;AAAA;AAInB,SAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,QACrC,KAAK,CAAC,QAAmB,OAAO,OAChC,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAG3B,MAAM,oBAAoB,CAAC,QAAgB,SAAiB,MAAc,MAAc,aAAqB;AAClH,MAAI,WAAmB;AAEvB,UAAO;AAAA,SACA;AACH,iBAAW,GAAG;AACd;AAAA;AAEA,iBAAW,GAAG;AACd;AAAA;AAGJ,SAAO,SAAS,UAAU,OAAO;AAAA;AAG5B,MAAM,iBAAiB,CAAC,SAA+B;AAC5D,QAAM,EAAC,SAAS,YAAY,UAAU,YAAY,WAAW,SAAS,MAAM,WAAU;AACtF,QAAM,OAAe,qBAAO,IAAI,mBAAmB,SAC/C,eAAe,qBAAO,IAAI,eAC1B,gCAAgC,qBAAO,IAAI;AAC/C,QAAM,SAAiB,UAAU,QAAQ;AAEzC,MAAG,SAAS;AACV,YAAO;AAAA,WACA;AAEH,eAAO,GAAG,QAAQ,QAAQ,aAAa,UAAU;AAAA,WAC9C;AAEH,eAAO,GAAG,QAAQ,QAAQ,UAAU,aAAa,UAAU;AAAA;AAG/D,QAAG,cAAc,WAAW;AAC1B,aAAO,GAAG,iBAAiB,UAAU;AAAA;AAGvC,WAAO,GAAG,iBAAiB,UAAU;AAAA;AAGvC,SAAO;AAAA;AAGF,MAAM,kBAAkB,CAAC,SAA+B;AAC7D,QAAM,EAAC,QAAQ,SAAS,UAAU,OAAO,WAAU;AACnD,QAAM,SAAiB,UAAU,WAAW;AAE5C,MAAG,SAAS;AACV,UAAM,WAAmB,SAAS,UAAU,UAAU;AACtD,WAAO,+BAAe,EAAC,QAAQ,QAAQ,KAAK,UAAU,SAAS;AAAA;AAGjE,SAAO;AAAA;AAGF,MAAM,kBAAkB,CAC7B,SACA,SACA,QACA,OAAe,cAAc,cAAqD;AAClF,QAAM,SAAiB;AACvB,QAAM,EAAC,SAAS,EAAC,QAAQ,gBAAc;AACvC,QAAM,OAAe,qBAAO,IAAI;AAChC,QAAM,OAAe,qBAAO,IAAI;AAChC,MAAI,QAAmB;AACvB,QAAM,SAAkB,KAAK,MAAM,KAAM;AAEzC,UAAQ,IAAI,EAAC,QAAQ,QAAQ,MAAM;AACnC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,2BAAG,QAAQ,OACR,UAAU,QACV,QAAQ,MACR,aACA,OAAO,MAAM,MAAM,KACnB,SAAS,EAAC,cAAc,QAAO,CAAC,OAAc,MAAyB,OAAY;AAClF,UAAG,OAAO;AACR,oCAAS;AAAA,UACP;AAAA,UACA,UAAU;AAAA,UACV,OAAO;AAAA,UACP,OAAO;AAAA,WACN,OAAO,SAAS,MAAM,CAAC,WAAU;AAClC,gBAAM;AAAA;AAAA,aAEH;AACL,cAAM,aAAa,iCAAc;AACjC,cAAM,EAAC,MAAM,YAAY,OAAO,aAAa,kBAAkB,UAA4B;AAC3F,gBAAQ,iCACH,8BAAU,SADP;AAAA,UAEN,MAAM;AAAA,UACN,OAAO;AAAA,UACP,OAAO,QAAQ,sBAAS,WAAW,OAAO,cAAc;AAAA;AAI1D,cAAM,QAAQ,WAAW;AAEzB,YAAG,OAAO;AACR,cAAI,EAAC,KAAK,OAAO,MAAM,SAAQ;AAE/B,cAAG,KAAK;AACN,mBAAO,IAAI,yBAAyB,IAAI;AACxC,kBAAM,OAAO,CAAG,KAAK,MAAM,KAAK,GAAI,UAAU,GAAG,KAAM;AAAA,iBAClD;AACL,kBAAM;AAAA;AAGR,cAAG,OAAO;AACR,mBAAO,MAAM,yBAAyB,MAAM;AAC5C,oBAAQ,OAAO,CAAG,KAAK,MAAM,KAAK,GAAI,UAAU,GAAG,KAAM;AAAA,iBACpD;AACL,oBAAQ;AAAA;AAGV,cAAG,MAAM;AACP,mBAAO,KAAK,yBAAyB,KAAK;AAC1C,mBAAO,OAAO,CAAG,KAAK,MAAM,KAAK,GAAI,UAAU,GAAG,KAAM;AAAA,iBACnD;AACL,mBAAO;AAAA;AAGT,gBAAM,MAAM,OAAQ,SAAS,IAAM,OAAO;AAC1C,gBAAM,QAAQ,IAAI,SAAS;AAC3B,gBAAM,QAAQ,UAAU,MAAM,WAAW;AAAA;AAAA;AAAA,OAI9C,OAAO,CAAC,OAAc,WAAgB;AACrC,UAAG,OAAO;AACR,oCAAS;AAAA,UACP;AAAA,UACA,UAAU;AAAA,UACV,YAAY;AAAA,UACZ,OAAO;AAAA,UACP,OAAO;AAAA,WACN,OAAO,SAAS,KAAK,MAAM;AAAA,aACzB;AACL,YAAI,cAAsB,OAAO,KAAK;AAEtC,eAAO,GAAG,QAAQ,CAAC,SAAS;AAC1B,wBAAc,OAAO,OAAO,CAAC,aAAa;AAAA;AAG5C,eAAO,GAAG,OAAO,MAAM;AAErB,gBAAM,WAAW,YAAY;AAG7B,gBAAM,WAA6B;AAAA,YACjC,KAAK;AAAA,YACL,MAAM;AAAA,YACN,QAAQ;AAAA,YACR,aAAa;AAAA,aACV,aAAa,KALiB;AAAA,YAMjC,KAAK,kBAAkB,WAAW,SAAS,MAAM;AAAA;AAGnD,gCAAM,UACH,KAAK,MAAM;AACV,kBAAM,OAAO,qBAAO,IAAI;AACxB,kBAAM,OAAO,qBAAO,IAAI;AAGxB,mCAAG,aAAa,OACb,UAAU,QACV,KAAK,CAAC,YAAmB,cAAc;AACtC,kBAAG,CAAC,YAAY;AAEd,sBAAM,EAAC,QAAQ,UAAS;AACxB,wBAAQ,iCAAI,8BAAU,SAAd,EAAsB,QAAQ;AAAA;AAAA,eAGzC,QAAQ,UACR,OAAO,MAAM,MAAM,KACnB,OAAO,MAAM,MACb,QAAQ,MACR,OAAO,CAAC,aAAoB,gBAAqB;AAChD,kBAAG,aAAa;AACd,4CAAS;AAAA,kBACP;AAAA,kBACA,UAAU;AAAA,kBACV,OAAO;AAAA,kBACP,OAAO;AAAA,mBACN,aAAa,SACb,MAAM,CAAC,WAAU;AAChB,wBAAM;AAAA;AAAA,qBAEL;AACL,oBAAI,cAAsB,OAAO,KAAK;AAEtC,4BAAY,GAAG,QAAQ,CAAC,SAAS;AAC/B,gCAAc,OAAO,OAAO,CAAC,aAAa;AAAA;AAG5C,4BAAY,GAAG,OAAO,MAAM;AAE1B,wBAAM,WAA6B;AAAA,oBACjC,KAAK;AAAA,oBACL,MAAM;AAAA,oBACN,QAAQ;AAAA,oBACR,aAAa;AAAA,qBACV,aAAa,KALiB;AAAA,oBAMjC,KAAK,kBAAkB,WAAW,SAAS,MAAM;AAAA;AAGnD,wCAAM,UACH,KAAK,MAAM;AACV,4BAAQ;AAAA,qBAET,MAAM,CAAC,eAAe,4BAAS;AAAA,oBAC9B;AAAA,oBACA,UAAU;AAAA,oBACV,OAAO;AAAA,oBACP,OAAO;AAAA,qBACN,YAAY,SACZ,MAAM,CAAC,WAAU;AAChB,0BAAM;AAAA;AAAA;AAAA;AAAA;AAAA,aAMrB,MAAM,CAAC,YAAY,4BAAS;AAAA,YAC3B;AAAA,YACA,UAAU;AAAA,YACV,YAAY;AAAA,YACZ,OAAO;AAAA,YACP,OAAO;AAAA,aACN,SAAS,SAAS,KAAK,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAOvC,MAAM,WAAW,CAAC,SAAqB,OAAkB,cAAqD;AACnH,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,gBAAc;AACjD,QAAM,EAAC,SAAS,aAAa,QAAQ,aAAY;AACjD,QAAM,MAAc,KAAK;AAEzB,SAAO,gBAAgB,SAAS,SAAS,QAAQ,UAAU,WACxD,KAAK,CAAC,iBAAsB;AAC3B,UAAM,SAAoB,iCACrB,eADqB;AAAA,MAExB,MAAM;AAAA,MACN,OAAO;AAAA,MACP;AAAA,MACA;AAAA,MACA,UAAU;AAAA,MACV,QAAQ;AAAA;AAGV,UAAM,SAAmB,6BAAa;AAEtC,WAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,QACrC,KAAK,6BACL,MAAM,CAAC,UAAiB,4BAAS;AAAA,MAChC;AAAA,MACA,UAAU;AAAA,MACV,YAAY;AAAA,MACZ,OAAO;AAAA,OACN,OAAO,SAAS,KAAK,MAAM;AAAA,KAEjC,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,YAAY;AAAA,IACZ,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAAA;AAG3B,MAAM,eAAe,OAAO,SAAqB,cAA8C;AACpG,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,gBAAc;AACjD,QAAM,EAAC,SAAS,QAAQ,aAAY;AACpC,QAAM,MAAc,KAAK;AACzB,QAAM,iBAAiC,SAAS,WAAW;AAC3D,QAAM,SAAiB,6BAAW,aAAa,WAAW,UAAU;AACpE,QAAM,iBAAyB,4BAAU,UAAU;AACnD,QAAM,eAAuB,0BAAQ;AACrC,MAAI;AACJ,QAAM,cAAsB,0BAAQ;AACpC,QAAM,YAAoB,UAAU;AAEpC,UAAO;AAAA,SACA;AACH,kBAAY,UAAU;AACtB;AAAA,SACG;AACH,kBAAY,SAAS;AACrB;AAAA,SACG;AAAA,SACA;AACH,kBAAY,SAAS;AACrB;AAAA;AAEA,kBAAY;AACZ;AAAA;AAEJ,QAAM,OAAY;AAAA,IAChB,OAAO;AAAA,IACP,MAAM;AAAA,IACN,KAAK;AAAA,IACL,OAAO;AAAA,IACP,MAAM;AAAA;AAGR,MAAG,CAAC,4BAAQ,YAAY;AACtB,WAAO,eAAe,KAAK,MAAM,EAAC,WAAW,QAC1C,KAAK,CAAC,aAAa,eAAe,SAAS,WAC3C,MAAM,CAAC,UAAiB,4BAAS;AAAA,MAChC;AAAA,MACA,UAAU;AAAA,MACV,YAAY;AAAA,MACZ,OAAO;AAAA,MACP,QAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAAA,OAED,OAAO,SAAS,KAAK,MAAM;AAAA;AAGlC,SAAO;AAAA;AAGF,MAAM,cAAc,OACzB,SACA,OACA,cACuB;AACvB,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,gBAAc;AAGjD,QAAM;AAAA,IACJ,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,cAAc;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,MACJ;AAGJ,QAAM,MAAc,KAAK;AACzB,QAAM,gBAAwB,WAAW,6BAAW,SAAS;AAC7D,QAAM,eAAuB,0BAAQ;AACrC,QAAM,iBAAyB,4BAAU,UAAU,IAAI;AACvD,QAAM,eAA0B;AAAA,IAC9B;AAAA,IACA,SAAS;AAAA,IACT,QAAQ;AAAA;AAGV,MAAG,CAAC,4BAAQ,WAAW,aAAa;AAClC,QAAI,SAAiB;AAGrB,QAAG,CAAC,4BAAQ,SAAS;AACnB,YAAM,eAAuB,OAAO,OAAO,OAAO,QAAQ,OAAO;AACjE,eAAS,OAAO,KAAK,cAAc;AAAA;AAGrC,QAAI,kBAAkB;AAEtB,QAAG,CAAC,UAAU;AACZ,YAAM,WAA2B,MAAM,yBAAS,WAAW;AAC3D,YAAM,EAAC,SAAQ;AACf,wBAAkB;AAAA;AAGpB,UAAM,YAAuB,iCACxB,eADwB;AAAA,MAE3B;AAAA,MACA,UAAU;AAAA;AAGZ,WAAO,SAAS,SAAS,WAAW,WACjC,KAAK,CAAC,WAAqB;AAC1B,UAAG,gBAAgB,gBAAgB;AACjC,cAAM,YAA2B;AAAA,UAC/B,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,UAAU;AAAA;AAEZ,eAAO,aAAa,SAAS,WAAW,KAAK,MAAM;AAAA;AAGrD,aAAO;AAAA,OAER,MAAM,CAAC,UAAU,4BAAS;AAAA,MACzB;AAAA,MACA,UAAU;AAAA,MACV,OAAO;AAAA,OACN,OAAO,SAAS,KAAK,MAAM;AAAA,aACxB,QAAQ,IAAI;AAEpB,QAAI;AAEJ,WAAO,2BAAQ,KACZ,KAAK,CAAC,QAAkB;AACvB,UAAG,IAAI,WAAW,KAAK;AACrB,eAAO,gCAAa;AAAA,UAClB;AAAA,UACA,UAAU;AAAA,UACV,OAAO;AAAA,UACP,OAAO,IAAI;AAAA,WACV,SAAS,KAAK,MAAM;AAAA;AAGzB,oBAAc,IAAI,QAAQ,IAAI;AAE9B,aAAO;AAAA,OAER,KAAK,CAAC,QAAQ,IAAI,UAClB,KAAK,CAAC,WAAmB;AACxB,YAAM,YAAuB,iCACxB,eADwB;AAAA,QAE3B;AAAA,QACA,UAAU;AAAA;AAGZ,aAAO,SAAS,SAAS,WAAW,WAAW,KAAK,CAAC,WAAqB;AACxE,YAAG,gBAAgB,gBAAgB;AACjC,gBAAM,YAA2B,EAAC,SAAS,eAAe,QAAQ,cAAc,UAAU;AAC1F,iBAAO,aAAa,SAAS,WAAW,KAAK,MAAM;AAAA;AAGrD,eAAO;AAAA;AAAA,OAGV,MAAM,CAAC,UAAiB,4BAAS;AAAA,MAChC;AAAA,MACA,UAAU;AAAA,MACV,OAAO;AAAA,OACN,OAAO,SAAS,KAAK,MAAM;AAAA,aACxB,YAAY,IAAI;AAExB,UAAM,SAAc;AAAA,MAClB;AAAA,MACA,UAAU;AAAA;AAEZ,UAAM,SAAmB,oCAAoB,uBAAuB;AAEpE,WAAO,SAAS,MAAM,QACnB,KAAK,CAAC,WAAwB,OAAO,QACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,MAChC;AAAA,MACA,UAAU;AAAA,MACV,OAAO;AAAA,MACP,QAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA;AAAA,OAED,OAAO,SAAS,KAAK,MAAM;AAAA;AAGlC,SAAO;AAAA;AAGF,MAAM,cAAc,OAAO,SAAqB,YAAwC;AAC7F,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,gBAAc;AACjD,QAAM,gBAAgB,0BAAQ;AAE9B,QAAM,kBAAkB;AAAA,yBACD;AAAA;AAAA;AAIvB,QAAM,SAAS,MAAM;AAErB,QAAM,WAAW;AAAA,uBACI,gCAAgC;AAAA;AAAA;AAIrD,QAAM,QAAQ,MAAM,SAAS,MAAM,UAChC,KAAK,CAAC,WAAwB,OAAO,QACrC,MAAM,CAAC,UAAiB,4BAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO;AAAA,KACN,OAAO,SAAS,KAAK,MAAM;AAEhC,MAAG,CAAC,4BAAQ,QAAQ;AAClB,UAAM,EAAC,MAAM,aAAY;AACzB,UAAM,SAA+B;AAAA,MACnC,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,SAAS;AAAA,UACP,EAAC,KAAK,SAAS,oBAAoB;AAAA,UACnC,EAAC,KAAK,SAAS,oBAAoB;AAAA;AAAA,QAErC,OAAO;AAAA;AAAA;AAIX,WAAO,6BAAa,QAAQ,KAAK,MAAM;AAAA;AAGzC,SAAO;AAAA;",
  "names": []
}
