@cexy/hoonfca 1.0.0 → 1.0.2

package/utils.js

@@ -1,165 +1,151 @@
+/* eslint-disable no-prototype-builtins */
 "use strict";
 
-const chalk = require("chalk");
-const gradient = require("gradient-string");
-const stream = require("stream");
-const querystring = require("querystring");
-const url = require("url");
-
-const echaceb = gradient(["#0061ff", "#681297"]);
-const ws = echaceb("ws3-fca");
-
-// Helper function first to prevent hoisting/undefined bugs
-function getType(obj) {
-  return Object.prototype.toString.call(obj).slice(8, -1);
+var bluebird = require("bluebird");
+var request = bluebird.promisify(require("request").defaults({ jar: true }));
+var stream = require("stream");
+var log = require("npmlog");
+var querystring = require("querystring");
+var url = require("url");
+const { Container } = require("nosql-json-database");
+const path = require("path");
+const { existsSync, mkdirSync } = require("fs");
+
+if (!existsSync(path.join(process.cwd(), "dinovn-fca")))
+  mkdirSync(path.join(process.cwd(), "dinovn-fca"));
+const database = new Container(path.join(process.cwd(), "dinovn-fca"));
+const usersCache = database.createCollection("users");
+const groupsCache = database.createCollection("groups");
+
+function setProxy(url) {
+  if (typeof url == undefined)
+    return (request = bluebird.promisify(
+      require("request").defaults({
+        jar: true,
+      }),
+    ));
+  return (request = bluebird.promisify(
+    require("request").defaults({
+      jar: true,
+      proxy: url,
+    }),
+  ));
 }
 
-const getRandom = arr => arr[Math.floor(Math.random() * arr.length)];
-const defaultUserAgent = "facebookexternalhit/1.1";
-const windowsUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3";
-
-function randomUserAgent() {
-    const platform = {
-    platform: ['Windows NT 10.0; Win64; x64', 'Macintosh; Intel Mac OS X 14.7; rv:132.0'],
-    browsers: {
-        chrome: ['122.0.0.0', '121.0.0.0'],
-        firefox: ['123.0', '122.0'],
-        edge: ['122.0.2365.92']
-       }
-    };
-    const browserName = getRandom(Object.keys(platform.browsers));
-    const version = getRandom(platform.browsers[browserName]);
-    const plat = getRandom(platform.platform);
-    const userAgentArray = [
-          defaultUserAgent,
-          windowsUserAgent,
-          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15",
-          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:45.0) Gecko/20100101 Firefox/45.0",
-          "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0",
-          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/601.7.7 (KHTML, like Gecko) Version/9.1.2 Safari/601.7.7",
-          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.1.2 Safari/603.3.8",
-          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.3",
-    ];
-    return getRandom([
-      browserName === 'firefox' ? `Mozilla/5.0 (${plat}) Gecko/20100101 Firefox/${version}` : `Mozilla/5.0 (${plat}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36`,
-      getRandom(userAgentArray)
-    ]);
-}
-
-const headers = {
-  "content-type": "application/x-www-form-urlencoded",
-  "referer": "https://www.facebook.com/",
-  "origin": "https://www.facebook.com",
-  "connection": "keep-alive",
-  "Sec-Fetch-Site": "same-origin",
-  "Sec-Fetch-User": "?1"
-};
-
-let request = require("request").defaults({
-  jar: true
-});
-
-function setProxy(proxy) {
-  request = require("request").defaults({
-    jar: true,
-    ...(proxy && { proxy })
-  });
-}
-
-function getHeaders(urlStr, options, ctx, customHeader) {
-  const headers1 = {
-    "host": new URL(urlStr).hostname,
-    ...headers,
-    "User-Agent": customHeader?.customUserAgent ?? options?.userAgent ?? defaultUserAgent
+function getHeaders(url, options, ctx, customHeader) {
+  var headers = {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Referer: "https://www.facebook.com/",
+    Host: url.replace("https://", "").split("/")[0],
+    Origin: "https://www.facebook.com",
+    "User-Agent": options.userAgent,
+    Connection: "keep-alive",
   };
-  if (ctx && ctx.region) headers1["X-MSGR-Region"] = ctx.region;
   if (customHeader) {
-    Object.assign(headers1, customHeader);
-    if (customHeader.noRef) delete headers1.referer;
+    Object.assign(headers, customHeader);
+  }
+  if (ctx && ctx.region) {
+    headers["X-MSGR-Region"] = ctx.region;
   }
-  return headers1;
-}
 
-function isReadableStream(obj) {
-  return obj instanceof stream.Stream && typeof obj._read === "function" && getType(obj._readableState) === "Object";
+  return headers;
 }
 
-function cleanGet(url) {
-  return new Promise(function(resolve, reject) {
-    request.get(url, { timeout: 60000 }, (error, res) => error ? reject(error) : resolve(res));
-  });
+function isReadableStream(obj) {
+  return (
+    obj instanceof stream.Stream &&
+    (getType(obj._read) === "Function" ||
+      getType(obj._read) === "AsyncFunction") &&
+    getType(obj._readableState) === "Object"
+  );
 }
 
-function get(url, jar, qs, options, ctx, customHeader) {
+function get(url, jar, qs, options, ctx) {
+  // I'm still confused about this
   if (getType(qs) === "Object") {
-    Object.keys(qs).forEach(prop => {
-      if (getType(qs[prop]) === 'Object') {
+    for (var prop in qs) {
+      if (qs.hasOwnProperty(prop) && getType(qs[prop]) === "Object") {
         qs[prop] = JSON.stringify(qs[prop]);
       }
-    });
+    }
   }
-  const op = {
-    headers: getHeaders(url, options, ctx, customHeader),
+  var op = {
+    headers: getHeaders(url, options, ctx),
     timeout: 60000,
-    qs,
-    jar,
-    gzip: true
+    qs: qs,
+    url: url,
+    method: "GET",
+    jar: jar,
+    gzip: true,
   };
-  return new Promise(function (resolve, reject) {
-    request.get(url, op, (error, res) => error ? reject(error) : resolve(res));
+
+  return request(op).then(function (res) {
+    return res[0];
   });
 }
 
 function post(url, jar, form, options, ctx, customHeader) {
-  const op = {
+  var op = {
     headers: getHeaders(url, options, ctx, customHeader),
     timeout: 60000,
-    form,
-    jar,
-    gzip: true
+    url: url,
+    method: "POST",
+    form: form,
+    jar: jar,
+    gzip: true,
   };
-  return new Promise(function (resolve, reject) {
-    request.post(url, op, (error, res) => error ? reject(error) : resolve(res));
+
+  return request(op).then(function (res) {
+    return res[0];
   });
 }
 
 function postFormData(url, jar, form, qs, options, ctx) {
-  if (getType(qs) === "Object") {
-    Object.keys(qs).forEach(prop => {
-      if (getType(qs[prop]) === 'Object') {
-        qs[prop] = JSON.stringify(qs[prop]);
-      }
-    });
-  }
-  const op = {
-    headers: getHeaders(url, options, ctx, { 'content-type': 'multipart/form-data' }),
+  var headers = getHeaders(url, options, ctx);
+  headers["Content-Type"] = "multipart/form-data";
+  var op = {
+    headers: headers,
     timeout: 60000,
+    url: url,
+    method: "POST",
     formData: form,
-    qs,
-    jar,
-    gzip: true
+    qs: qs,
+    jar: jar,
+    gzip: true,
   };
-  return new Promise(function (resolve, reject) {
-    request.post(url, op, (error, res) => error ? reject(error) : resolve(res));
+
+  return request(op).then(function (res) {
+    return res[0];
   });
 }
 
-function padZeros(val, len = 2) {
-  return String(val).padStart(len, "0");
+function padZeros(val, len) {
+  val = String(val);
+  len = len || 2;
+  while (val.length < len) val = "0" + val;
+  return val;
 }
 
 function generateThreadingID(clientID) {
-  const k = Date.now();
-  const l = Math.floor(Math.random() * 4294967295);
-  return `<${k}:${l}-${clientID}@mail.projektitan.com>`;
+  var k = Date.now();
+  var l = Math.floor(Math.random() * 4294967295);
+  var m = clientID;
+  return "<" + k + ":" + l + "-" + m + "@mail.projektitan.com>";
+}
+
+function getCurrentTimestamp() {
+  const date = new Date();
+  const unixTime = date.getTime();
+  return unixTime;
 }
 
 function binaryToDecimal(data) {
-  let ret = "";
+  var ret = "";
   while (data !== "0") {
-    let end = 0;
-    let fullName = "";
-    for (let i = 0; i < data.length; i++) {
+    var end = 0;
+    var fullName = "";
+    var i = 0;
+    for (; i < data.length; i++) {
       end = 2 * end + parseInt(data[i], 10);
       if (end >= 10) {
         fullName += "1";
@@ -169,36 +155,53 @@ function binaryToDecimal(data) {
       }
     }
     ret = end.toString() + ret;
-    const firstOne = fullName.indexOf("1");
-    data = firstOne === -1 ? "0" : fullName.slice(firstOne);
+    data = fullName.slice(fullName.indexOf("1"));
   }
   return ret;
 }
 
 function generateOfflineThreadingID() {
-  const ret = Date.now();
-  const value = Math.floor(Math.random() * 4294967295);
-  const str = value.toString(2).padStart(22, "0");
-  return binaryToDecimal(ret.toString(2) + str);
-}
-
-let h;
-const i = {};
-const j = {
-  _: "%", A: "%2", B: "000", C: "%7d", D: "%7b%22", E: "%2c%22", F: "%22%3a", G: "%2c%22ut%22%3a1",
-  H: "%2c%22bls%22%3a", I: "%2c%22n%22%3a%22%", J: "%22%3a%7b%22i%22%3a0%7d", K: "%2c%22pt%22%3a0%2c%22vis%22%3a",
-  L: "%2c%22ch%22%3a%7b%22h%22%3a%22", M: "%7b%22v%22%3a2%2c%22time%22%3a1", N: ".channel%22%2c%22sub%22%3a%5b",
-  O: "%2c%22sb%22%3a1%2c%22t%22%3a%5b", P: "%2c%22ud%22%3a100%2c%22lc%22%3a0", Q: "%5d%2c%22f%22%3anull%2c%22uct%22%3a",
-  R: ".channel%22%2c%22sub%22%3a%5b1%5d", S: "%22%2c%22m%22%3a0%7d%2c%7b%22i%22%3a", T: "%2c%22blc%22%3a1%2c%22snd%22%3a1%2c%22ct%22%3a",
-  U: "%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a", V: "%2c%22blc%22%3a0%2c%22snd%22%3a0%2c%22ct%22%3a",
-  W: "%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a", X: "%2c%22ri%22%3a0%7d%2c%22state%22%3a%7b%22p%22%3a0%2c%22ut%22%3a1",
+  var ret = Date.now();
+  var value = Math.floor(Math.random() * 4294967295);
+  var str = ("0000000000000000000000" + value.toString(2)).slice(-22);
+  var msgs = ret.toString(2) + str;
+  return binaryToDecimal(msgs);
+}
+
+var h;
+var i = {};
+var j = {
+  _: "%",
+  A: "%2",
+  B: "000",
+  C: "%7d",
+  D: "%7b%22",
+  E: "%2c%22",
+  F: "%22%3a",
+  G: "%2c%22ut%22%3a1",
+  H: "%2c%22bls%22%3a",
+  I: "%2c%22n%22%3a%22%",
+  J: "%22%3a%7b%22i%22%3a0%7d",
+  K: "%2c%22pt%22%3a0%2c%22vis%22%3a",
+  L: "%2c%22ch%22%3a%7b%22h%22%3a%22",
+  M: "%7b%22v%22%3a2%2c%22time%22%3a1",
+  N: ".channel%22%2c%22sub%22%3a%5b",
+  O: "%2c%22sb%22%3a1%2c%22t%22%3a%5b",
+  P: "%2c%22ud%22%3a100%2c%22lc%22%3a0",
+  Q: "%5d%2c%22f%22%3anull%2c%22uct%22%3a",
+  R: ".channel%22%2c%22sub%22%3a%5b1%5d",
+  S: "%22%2c%22m%22%3a0%7d%2c%7b%22i%22%3a",
+  T: "%2c%22blc%22%3a1%2c%22snd%22%3a1%2c%22ct%22%3a",
+  U: "%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a",
+  V: "%2c%22blc%22%3a0%2c%22snd%22%3a0%2c%22ct%22%3a",
+  W: "%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a",
+  X: "%2c%22ri%22%3a0%7d%2c%22state%22%3a%7b%22p%22%3a0%2c%22ut%22%3a1",
   Y: "%2c%22pt%22%3a0%2c%22vis%22%3a1%2c%22bls%22%3a0%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a",
-  Z: "%2c%22sb%22%3a1%2c%22t%22%3a%5b%5d%2c%22f%22%3anull%2c%22uct%22%3a0%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a"
+  Z: "%2c%22sb%22%3a1%2c%22t%22%3a%5b%5d%2c%22f%22%3anull%2c%22uct%22%3a0%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a",
 };
-
-(function() {
-  const l = [];
-  for (const m in j) {
+(function () {
+  var l = [];
+  for (var m in j) {
     i[j[m]] = m;
     l.push(j[m]);
   }
@@ -208,286 +211,593 @@ const j = {
 
 function presenceEncode(str) {
   return encodeURIComponent(str)
-    .replace(/([_A-Z])|%../g, (m, n) => n ? "%" + n.charCodeAt(0).toString(16) : m)
+    .replace(/([_A-Z])|%../g, function (m, n) {
+      return n ? "%" + n.charCodeAt(0).toString(16) : m;
+    })
     .toLowerCase()
-    .replace(h, m => i[m]);
+    .replace(h, function (m) {
+      return i[m];
+    });
 }
 
+// eslint-disable-next-line no-unused-vars
 function presenceDecode(str) {
-  return decodeURIComponent(str.replace(/[_A-Z]/g, m => j[m]));
+  return decodeURIComponent(
+    str.replace(/[_A-Z]/g, function (m) {
+      return j[m];
+    }),
+  );
 }
 
 function generatePresence(userID) {
-  const time = Date.now();
-  return "E" + presenceEncode(JSON.stringify({
-    v: 3,
-    time: Math.floor(time / 1000),
-    user: userID,
-    state: {
-      ut: 0, t2: [], lm2: null, uct2: time, tr: null,
-      tw: Math.floor(Math.random() * 4294967295) + 1, at: time
-    },
-    ch: { ["p_" + userID]: 0 }
-  }));
+  var time = Date.now();
+  return (
+    "E" +
+    presenceEncode(
+      JSON.stringify({
+        v: 3,
+        time: parseInt(time / 1000, 10),
+        user: userID,
+        state: {
+          ut: 0,
+          t2: [],
+          lm2: null,
+          uct2: time,
+          tr: null,
+          tw: Math.floor(Math.random() * 4294967295) + 1,
+          at: time,
+        },
+        ch: {
+          ["p_" + userID]: 0,
+        },
+      }),
+    )
+  );
 }
 
 function generateAccessiblityCookie() {
-  const time = Date.now();
-  return encodeURIComponent(JSON.stringify({ sr: 0, "sr-ts": time, jk: 0, "jk-ts": time, kb: 0, "kb-ts": time, hcm: 0, "hcm-ts": time }));
+  var time = Date.now();
+  return encodeURIComponent(
+    JSON.stringify({
+      sr: 0,
+      "sr-ts": time,
+      jk: 0,
+      "jk-ts": time,
+      kb: 0,
+      "kb-ts": time,
+      hcm: 0,
+      "hcm-ts": time,
+    }),
+  );
 }
 
 function getGUID() {
-  let sectionLength = Date.now();
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-    const r = Math.floor((sectionLength + Math.random() * 16) % 16);
-    sectionLength = Math.floor(sectionLength / 16);
-    return (c === "x" ? r : (r & 7) | 8).toString(16);
-  });
-}
-
-function getExtension(original_extension, fullFileName = "") {
-  if (original_extension) return original_extension;
-  const extension = fullFileName.split(".").pop();
-  return extension === fullFileName ? "" : extension;
+  /** @type {number} */
+  var sectionLength = Date.now();
+  /** @type {string} */
+  var id = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
+    /[xy]/g,
+    function (c) {
+      /** @type {number} */
+      var r = Math.floor((sectionLength + Math.random() * 16) % 16);
+      /** @type {number} */
+      sectionLength = Math.floor(sectionLength / 16);
+      /** @type {string} */
+      var _guid = (c == "x" ? r : (r & 7) | 8).toString(16);
+      return _guid;
+    },
+  );
+  return id;
 }
 
 function _formatAttachment(attachment1, attachment2) {
-  const fullFileName = attachment1.filename;
-  const fileSize = Number(attachment1.fileSize || 0);
-  const durationVideo = attachment1.genericMetadata ? Number(attachment1.genericMetadata.videoLength) : undefined;
-  const durationAudio = attachment1.genericMetadata ? Number(attachment1.genericMetadata.duration) : undefined;
-  const mimeType = attachment1.mimeType;
-
+  // TODO: THIS IS REALLY BAD
+  // This is an attempt at fixing Facebook's inconsistencies. Sometimes they give us
+  // two attachment objects, but sometimes only one. They each contain part of the
+  // data that you'd want so we merge them for convenience.
+  // Instead of having a bunch of if statements guarding every access to image_data,
+  // we set it to empty object and use the fact that it'll return undefined.
   attachment2 = attachment2 || { id: "", image_data: {} };
-  attachment1 = attachment1.mercury || attachment1;
-  let blob = attachment1.blob_attachment || attachment1.sticker_attachment;
-  let type = blob && blob.__typename ? blob.__typename : attachment1.attach_type;
-  
+  attachment1 = attachment1.mercury ? attachment1.mercury : attachment1;
+  var blob = attachment1.blob_attachment;
+  var type =
+    blob && blob.__typename ? blob.__typename : attachment1.attach_type;
   if (!type && attachment1.sticker_attachment) {
     type = "StickerAttachment";
     blob = attachment1.sticker_attachment;
   } else if (!type && attachment1.extensible_attachment) {
-    if (attachment1.extensible_attachment.story_attachment?.target?.__typename === "MessageLocation") {
+    if (
+      attachment1.extensible_attachment.story_attachment &&
+      attachment1.extensible_attachment.story_attachment.target &&
+      attachment1.extensible_attachment.story_attachment.target.__typename &&
+      attachment1.extensible_attachment.story_attachment.target.__typename ===
+        "MessageLocation"
+    ) {
       type = "MessageLocation";
     } else {
       type = "ExtensibleAttachment";
     }
+
     blob = attachment1.extensible_attachment;
   }
-
+  // TODO: Determine whether "sticker", "photo", "file" etc are still used
+  // KEEP IN SYNC WITH getThreadHistory
   switch (type) {
     case "sticker":
       return {
-        type: "sticker", ID: attachment1.metadata.stickerID.toString(), url: attachment1.url,
-        packID: attachment1.metadata.packID.toString(), spriteUrl: attachment1.metadata.spriteURI,
-        spriteUrl2x: attachment1.metadata.spriteURI2x, width: attachment1.metadata.width, height: attachment1.metadata.height,
-        caption: attachment2.caption, description: attachment2.description, frameCount: attachment1.metadata.frameCount,
-        frameRate: attachment1.metadata.frameRate, framesPerRow: attachment1.metadata.framesPerRow, framesPerCol: attachment1.metadata.framesPerCol,
-        stickerID: attachment1.metadata.stickerID.toString(), spriteURI: attachment1.metadata.spriteURI, spriteURI2x: attachment1.metadata.spriteURI2x
+        type: "sticker",
+        ID: attachment1.metadata.stickerID.toString(),
+        url: attachment1.url,
+
+        packID: attachment1.metadata.packID.toString(),
+        spriteUrl: attachment1.metadata.spriteURI,
+        spriteUrl2x: attachment1.metadata.spriteURI2x,
+        width: attachment1.metadata.width,
+        height: attachment1.metadata.height,
+
+        caption: attachment2.caption,
+        description: attachment2.description,
+
+        frameCount: attachment1.metadata.frameCount,
+        frameRate: attachment1.metadata.frameRate,
+        framesPerRow: attachment1.metadata.framesPerRow,
+        framesPerCol: attachment1.metadata.framesPerCol,
+
+        stickerID: attachment1.metadata.stickerID.toString(), // @Legacy
+        spriteURI: attachment1.metadata.spriteURI, // @Legacy
+        spriteURI2x: attachment1.metadata.spriteURI2x, // @Legacy
       };
     case "file":
       return {
-        type: "file", ID: attachment2.id.toString(), fullFileName: fullFileName, filename: attachment1.name,
-        fileSize: fileSize, original_extension: getExtension(attachment1.original_extension, fullFileName),
-        mimeType: mimeType, url: attachment1.url, isMalicious: attachment2.is_malicious, contentType: attachment2.mime_type, name: attachment1.name
+        type: "file",
+        filename: attachment1.name,
+        ID: attachment2.id.toString(),
+        url: attachment1.url,
+
+        isMalicious: attachment2.is_malicious,
+        contentType: attachment2.mime_type,
+
+        name: attachment1.name, // @Legacy
+        mimeType: attachment2.mime_type, // @Legacy
+        fileSize: attachment2.file_size, // @Legacy
       };
     case "photo":
       return {
-        type: "photo", ID: attachment1.metadata.fbid.toString(), filename: attachment1.fileName, fullFileName: fullFileName,
-        fileSize: fileSize, original_extension: getExtension(attachment1.original_extension, fullFileName), mimeType: mimeType,
-        thumbnailUrl: attachment1.thumbnail_url, previewUrl: attachment1.preview_url, previewWidth: attachment1.preview_width,
-        previewHeight: attachment1.preview_height, largePreviewUrl: attachment1.large_preview_url, largePreviewWidth: attachment1.large_preview_width,
-        largePreviewHeight: attachment1.large_preview_height, url: attachment1.metadata.url, width: attachment1.metadata.dimensions.split(",")[0],
-        height: attachment1.metadata.dimensions.split(",")[1], name: fullFileName
+        type: "photo",
+        ID: attachment1.metadata.fbid.toString(),
+        filename: attachment1.fileName,
+        thumbnailUrl: attachment1.thumbnail_url,
+
+        previewUrl: attachment1.preview_url,
+        previewWidth: attachment1.preview_width,
+        previewHeight: attachment1.preview_height,
+
+        largePreviewUrl: attachment1.large_preview_url,
+        largePreviewWidth: attachment1.large_preview_width,
+        largePreviewHeight: attachment1.large_preview_height,
+
+        url: attachment1.metadata.url, // @Legacy
+        width: attachment1.metadata.dimensions.split(",")[0], // @Legacy
+        height: attachment1.metadata.dimensions.split(",")[1], // @Legacy
+        name: attachment1.fileName, // @Legacy
       };
     case "animated_image":
       return {
-        type: "animated_image", ID: attachment2.id.toString(), filename: attachment2.filename, fullFileName: fullFileName,
-        original_extension: getExtension(attachment2.original_extension, fullFileName), mimeType: mimeType, previewUrl: attachment1.preview_url,
-        previewWidth: attachment1.preview_width, previewHeight: attachment1.preview_height, url: attachment2.image_data.url,
-        width: attachment2.image_data.width, height: attachment2.image_data.height, name: attachment1.name, facebookUrl: attachment1.url,
-        thumbnailUrl: attachment1.thumbnail_url, rawGifImage: attachment2.image_data.raw_gif_image, rawWebpImage: attachment2.image_data.raw_webp_image,
-        animatedGifUrl: attachment2.image_data.animated_gif_url, animatedGifPreviewUrl: attachment2.image_data.animated_gif_preview_url,
-        animatedWebpUrl: attachment2.image_data.animated_webp_url, animatedWebpPreviewUrl: attachment2.image_data.animated_webp_preview_url
+        type: "animated_image",
+        ID: attachment2.id.toString(),
+        filename: attachment2.filename,
+
+        previewUrl: attachment1.preview_url,
+        previewWidth: attachment1.preview_width,
+        previewHeight: attachment1.preview_height,
+
+        url: attachment2.image_data.url,
+        width: attachment2.image_data.width,
+        height: attachment2.image_data.height,
+
+        name: attachment1.name, // @Legacy
+        facebookUrl: attachment1.url, // @Legacy
+        thumbnailUrl: attachment1.thumbnail_url, // @Legacy
+        mimeType: attachment2.mime_type, // @Legacy
+        rawGifImage: attachment2.image_data.raw_gif_image, // @Legacy
+        rawWebpImage: attachment2.image_data.raw_webp_image, // @Legacy
+        animatedGifUrl: attachment2.image_data.animated_gif_url, // @Legacy
+        animatedGifPreviewUrl: attachment2.image_data.animated_gif_preview_url, // @Legacy
+        animatedWebpUrl: attachment2.image_data.animated_webp_url, // @Legacy
+        animatedWebpPreviewUrl:
+          attachment2.image_data.animated_webp_preview_url, // @Legacy
       };
     case "share":
       return {
-        type: "share", ID: attachment1.share.share_id.toString(), url: attachment2.href, title: attachment1.share.title,
-        description: attachment1.share.description, source: attachment1.share.source, image: attachment1.share.media.image,
-        width: attachment1.share.media.image_size.width, height: attachment1.share.media.image_size.height, playable: attachment1.share.media.playable,
-        duration: attachment1.share.media.duration, subattachments: attachment1.share.subattachments, properties: {},
-        animatedImageSize: attachment1.share.media.animated_image_size, facebookUrl: attachment1.share.uri, target: attachment1.share.target, styleList: attachment1.share.style_list
+        type: "share",
+        ID: attachment1.share.share_id.toString(),
+        url: attachment2.href,
+
+        title: attachment1.share.title,
+        description: attachment1.share.description,
+        source: attachment1.share.source,
+
+        image: attachment1.share.media.image,
+        width: attachment1.share.media.image_size.width,
+        height: attachment1.share.media.image_size.height,
+        playable: attachment1.share.media.playable,
+        duration: attachment1.share.media.duration,
+
+        subattachments: attachment1.share.subattachments,
+        properties: {},
+
+        animatedImageSize: attachment1.share.media.animated_image_size, // @Legacy
+        facebookUrl: attachment1.share.uri, // @Legacy
+        target: attachment1.share.target, // @Legacy
+        styleList: attachment1.share.style_list, // @Legacy
       };
     case "video":
       return {
-        type: "video", ID: attachment1.metadata.fbid.toString(), filename: attachment1.name, fullFileName: fullFileName,
-        original_extension: getExtension(attachment1.original_extension, fullFileName), mimeType: mimeType, duration: durationVideo,
-        previewUrl: attachment1.preview_url, previewWidth: attachment1.preview_width, previewHeight: attachment1.preview_height,
-        url: attachment1.url, width: attachment1.metadata.dimensions.width, height: attachment1.metadata.dimensions.height,
-        videoType: "unknown", thumbnailUrl: attachment1.thumbnail_url
+        type: "video",
+        ID: attachment1.metadata.fbid.toString(),
+        filename: attachment1.name,
+
+        previewUrl: attachment1.preview_url,
+        previewWidth: attachment1.preview_width,
+        previewHeight: attachment1.preview_height,
+
+        url: attachment1.url,
+        width: attachment1.metadata.dimensions.width,
+        height: attachment1.metadata.dimensions.height,
+
+        duration: attachment1.metadata.duration,
+        videoType: "unknown",
+
+        thumbnailUrl: attachment1.thumbnail_url, // @Legacy
       };
     case "error":
-      return { type: "error", attachment1: attachment1, attachment2: attachment2 };
+      return {
+        type: "error",
+
+        // Save error attachments because we're unsure of their format,
+        // and whether there are cases they contain something useful for debugging.
+        attachment1: attachment1,
+        attachment2: attachment2,
+      };
     case "MessageImage":
       return {
-        type: "photo", ID: blob.legacy_attachment_id, filename: blob.filename, fullFileName: fullFileName, fileSize: fileSize,
-        original_extension: getExtension(blob.original_extension, fullFileName), mimeType: mimeType, thumbnailUrl: blob.thumbnail.uri,
-        previewUrl: blob.preview.uri, previewWidth: blob.preview.width, previewHeight: blob.preview.height, largePreviewUrl: blob.large_preview.uri,
-        largePreviewWidth: blob.large_preview.width, largePreviewHeight: blob.large_preview.height, url: blob.large_preview.uri,
-        width: blob.original_dimensions.x, height: blob.original_dimensions.y, name: blob.filename
+        type: "photo",
+        ID: blob.legacy_attachment_id,
+        filename: blob.filename,
+        thumbnailUrl: blob.thumbnail.uri,
+
+        previewUrl: blob.preview.uri,
+        previewWidth: blob.preview.width,
+        previewHeight: blob.preview.height,
+
+        largePreviewUrl: blob.large_preview.uri,
+        largePreviewWidth: blob.large_preview.width,
+        largePreviewHeight: blob.large_preview.height,
+
+        url: blob.large_preview.uri, // @Legacy
+        width: blob.original_dimensions.x, // @Legacy
+        height: blob.original_dimensions.y, // @Legacy
+        name: blob.filename, // @Legacy
       };
     case "MessageAnimatedImage":
       return {
-        type: "animated_image", ID: blob.legacy_attachment_id, filename: blob.filename, fullFileName: fullFileName,
-        original_extension: getExtension(blob.original_extension, fullFileName), mimeType: mimeType, previewUrl: blob.preview_image.uri,
-        previewWidth: blob.preview_image.width, previewHeight: blob.preview_image.height, url: blob.animated_image.uri,
-        width: blob.animated_image.width, height: blob.animated_image.height, thumbnailUrl: blob.preview_image.uri, name: blob.filename,
-        facebookUrl: blob.animated_image.uri, rawGifImage: blob.animated_image.uri, animatedGifUrl: blob.animated_image.uri,
-        animatedGifPreviewUrl: blob.preview_image.uri, animatedWebpUrl: blob.animated_image.uri, animatedWebpPreviewUrl: blob.preview_image.uri
+        type: "animated_image",
+        ID: blob.legacy_attachment_id,
+        filename: blob.filename,
+
+        previewUrl: blob.preview_image.uri,
+        previewWidth: blob.preview_image.width,
+        previewHeight: blob.preview_image.height,
+
+        url: blob.animated_image.uri,
+        width: blob.animated_image.width,
+        height: blob.animated_image.height,
+
+        thumbnailUrl: blob.preview_image.uri, // @Legacy
+        name: blob.filename, // @Legacy
+        facebookUrl: blob.animated_image.uri, // @Legacy
+        rawGifImage: blob.animated_image.uri, // @Legacy
+        animatedGifUrl: blob.animated_image.uri, // @Legacy
+        animatedGifPreviewUrl: blob.preview_image.uri, // @Legacy
+        animatedWebpUrl: blob.animated_image.uri, // @Legacy
+        animatedWebpPreviewUrl: blob.preview_image.uri, // @Legacy
       };
     case "MessageVideo":
       return {
-        type: "video", ID: blob.legacy_attachment_id, filename: blob.filename, fullFileName: fullFileName,
-        original_extension: getExtension(blob.original_extension, fullFileName), fileSize: fileSize, duration: durationVideo,
-        mimeType: mimeType, previewUrl: blob.large_image.uri, previewWidth: blob.large_image.width, previewHeight: blob.large_image.height,
-        url: blob.playable_url, width: blob.original_dimensions.x, height: blob.original_dimensions.y, videoType: blob.video_type.toLowerCase(),
-        thumbnailUrl: blob.large_image.uri
+        type: "video",
+        filename: blob.filename,
+        ID: blob.legacy_attachment_id,
+
+        previewUrl: blob.large_image.uri,
+        previewWidth: blob.large_image.width,
+        previewHeight: blob.large_image.height,
+
+        url: blob.playable_url,
+        width: blob.original_dimensions.x,
+        height: blob.original_dimensions.y,
+
+        duration: blob.playable_duration_in_ms,
+        videoType: blob.video_type.toLowerCase(),
+
+        thumbnailUrl: blob.large_image.uri, // @Legacy
       };
     case "MessageAudio":
       return {
-        type: "audio", ID: blob.url_shimhash, filename: blob.filename, fullFileName: fullFileName, fileSize: fileSize,
-        duration: durationAudio, original_extension: getExtension(blob.original_extension, fullFileName), mimeType: mimeType,
-        audioType: blob.audio_type, url: blob.playable_url, isVoiceMail: blob.is_voicemail
+        type: "audio",
+        filename: blob.filename,
+        ID: blob.url_shimhash,
+
+        audioType: blob.audio_type,
+        duration: blob.playable_duration_in_ms,
+        url: blob.playable_url,
+
+        isVoiceMail: blob.is_voicemail,
       };
     case "StickerAttachment":
-    case "Sticker":
       return {
-        type: "sticker", ID: blob.id, url: blob.url, packID: blob.pack ? blob.pack.id : null, spriteUrl: blob.sprite_image,
-        spriteUrl2x: blob.sprite_image_2x, width: blob.width, height: blob.height, caption: blob.label, description: blob.label,
-        frameCount: blob.frame_count, frameRate: blob.frame_rate, framesPerRow: blob.frames_per_row, framesPerCol: blob.frames_per_column,
-        stickerID: blob.id, spriteURI: blob.sprite_image, spriteURI2x: blob.sprite_image_2x
+        type: "sticker",
+        ID: blob.id,
+        url: blob.url,
+
+        packID: blob.pack ? blob.pack.id : null,
+        spriteUrl: blob.sprite_image,
+        spriteUrl2x: blob.sprite_image_2x,
+        width: blob.width,
+        height: blob.height,
+
+        caption: blob.label,
+        description: blob.label,
+
+        frameCount: blob.frame_count,
+        frameRate: blob.frame_rate,
+        framesPerRow: blob.frames_per_row,
+        framesPerCol: blob.frames_per_column,
+
+        stickerID: blob.id, // @Legacy
+        spriteURI: blob.sprite_image, // @Legacy
+        spriteURI2x: blob.sprite_image_2x, // @Legacy
       };
     case "MessageLocation":
+      var urlAttach = blob.story_attachment.url;
+      var mediaAttach = blob.story_attachment.media;
+
+      var u = querystring.parse(url.parse(urlAttach).query).u;
+      var where1 = querystring.parse(url.parse(u).query).where1;
+      var address = where1.split(", ");
+
+      var latitude;
+      var longitude;
+
       try {
-        const urlAttach = blob.story_attachment.url;
-        const mediaAttach = blob.story_attachment.media;
-        const u = querystring.parse(url.parse(urlAttach).query).u;
-        const where1 = querystring.parse(url.parse(u).query).where1;
-        const address = where1.split(", ");
-        let latitude = Number.parseFloat(address[0]);
-        let longitude = Number.parseFloat(address[1]);
-        let imageUrl, width, height;
-        if (mediaAttach?.image) {
-          imageUrl = mediaAttach.image.uri;
-          width = mediaAttach.image.width;
-          height = mediaAttach.image.height;
-        }
-        return {
-          type: "location", ID: blob.legacy_attachment_id, latitude, longitude, image: imageUrl, width, height,
-          url: u || urlAttach, address: where1, facebookUrl: blob.story_attachment.url, target: blob.story_attachment.target,
-          styleList: blob.story_attachment.style_list
-        };
+        latitude = Number.parseFloat(address[0]);
+        longitude = Number.parseFloat(address[1]);
       } catch (err) {
-        return { type: "error", error: "Failed to parse location", detail: err };
+        /* empty */
+      }
+
+      var imageUrl;
+      var width;
+      var height;
+
+      if (mediaAttach && mediaAttach.image) {
+        imageUrl = mediaAttach.image.uri;
+        width = mediaAttach.image.width;
+        height = mediaAttach.image.height;
       }
+
+      return {
+        type: "location",
+        ID: blob.legacy_attachment_id,
+        latitude: latitude,
+        longitude: longitude,
+        image: imageUrl,
+        width: width,
+        height: height,
+        url: u || urlAttach,
+        address: where1,
+
+        facebookUrl: blob.story_attachment.url, // @Legacy
+        target: blob.story_attachment.target, // @Legacy
+        styleList: blob.story_attachment.style_list, // @Legacy
+      };
     case "ExtensibleAttachment":
       return {
-        type: "share", ID: blob.legacy_attachment_id, url: blob.story_attachment.url, title: blob.story_attachment.title_with_entities.text,
-        description: blob.story_attachment.description?.text, source: blob.story_attachment.source?.text || null,
-        image: blob.story_attachment.media?.image?.uri, width: blob.story_attachment.media?.image?.width, height: blob.story_attachment.media?.image?.height,
-        playable: blob.story_attachment.media?.is_playable, duration: blob.story_attachment.media?.playable_duration_in_ms,
-        playableUrl: blob.story_attachment.media?.playable_url || null, subattachments: blob.story_attachment.subattachments,
-        properties: (blob.story_attachment.properties || []).reduce(function(obj, cur) {
+        type: "share",
+        ID: blob.legacy_attachment_id,
+        url: blob.story_attachment.url,
+
+        title: blob.story_attachment.title_with_entities.text,
+        description:
+          blob.story_attachment.description &&
+          blob.story_attachment.description.text,
+        source: blob.story_attachment.source
+          ? blob.story_attachment.source.text
+          : null,
+
+        image:
+          blob.story_attachment.media &&
+          blob.story_attachment.media.image &&
+          blob.story_attachment.media.image.uri,
+        width:
+          blob.story_attachment.media &&
+          blob.story_attachment.media.image &&
+          blob.story_attachment.media.image.width,
+        height:
+          blob.story_attachment.media &&
+          blob.story_attachment.media.image &&
+          blob.story_attachment.media.image.height,
+        playable:
+          blob.story_attachment.media &&
+          blob.story_attachment.media.is_playable,
+        duration:
+          blob.story_attachment.media &&
+          blob.story_attachment.media.playable_duration_in_ms,
+        playableUrl:
+          blob.story_attachment.media == null
+            ? null
+            : blob.story_attachment.media.playable_url,
+
+        subattachments: blob.story_attachment.subattachments,
+        properties: blob.story_attachment.properties.reduce(function (
+          obj,
+          cur,
+        ) {
           obj[cur.key] = cur.value.text;
           return obj;
         }, {}),
-        facebookUrl: blob.story_attachment.url, target: blob.story_attachment.target, styleList: blob.story_attachment.style_list
+
+        facebookUrl: blob.story_attachment.url, // @Legacy
+        target: blob.story_attachment.target, // @Legacy
+        styleList: blob.story_attachment.style_list, // @Legacy
       };
     case "MessageFile":
       return {
-        type: "file", ID: blob.message_file_fbid, fullFileName: fullFileName, filename: blob.filename, fileSize: fileSize,
-        mimeType: blob.mimetype, original_extension: blob.original_extension || fullFileName.split(".").pop(), url: blob.url,
-        isMalicious: blob.is_malicious, contentType: blob.content_type, name: blob.filename
+        type: "file",
+        filename: blob.filename,
+        ID: blob.message_file_fbid,
+
+        url: blob.url,
+        isMalicious: blob.is_malicious,
+        contentType: blob.content_type,
+
+        name: blob.filename,
+        mimeType: "",
+        fileSize: -1,
       };
     default:
-      throw new Error("unrecognized attach_file of type " + type + "`" + JSON.stringify(attachment1, null, 4) + " attachment2: " + JSON.stringify(attachment2, null, 4) + "`");
+      throw new Error(
+        "unrecognized attach_file of type " +
+          type +
+          "`" +
+          JSON.stringify(attachment1, null, 4) +
+          " attachment2: " +
+          JSON.stringify(attachment2, null, 4) +
+          "`",
+      );
   }
 }
 
 function formatAttachment(attachments, attachmentIds, attachmentMap, shareMap) {
-  const mapToUse = shareMap || attachmentMap;
-  return attachments ? attachments.map(function(val, i) {
-      if (!mapToUse || !attachmentIds || !mapToUse[attachmentIds[i]]) {
-        return _formatAttachment(val);
-      }
-      return _formatAttachment(val, mapToUse[attachmentIds[i]]);
-    }) : [];
+  attachmentMap = shareMap || attachmentMap;
+  return attachments
+    ? attachments.map(function (val, i) {
+        if (
+          !attachmentMap ||
+          !attachmentIds ||
+          !attachmentMap[attachmentIds[i]]
+        ) {
+          return _formatAttachment(val);
+        }
+        return _formatAttachment(val, attachmentMap[attachmentIds[i]]);
+      })
+    : [];
 }
 
 function formatDeltaMessage(m) {
-  const md = m.delta.messageMetadata;
-  const mdata = m.delta.data?.prng ? JSON.parse(m.delta.data.prng) : [];
-  const mentions = {};
-  
-  for (let i = 0; i < mdata.length; i++) {
-    if (mdata[i].i && mdata[i].o !== undefined && mdata[i].l) {
-      mentions[mdata[i].i] = m.delta.body.substring(mdata[i].o, mdata[i].o + mdata[i].l);
-    }
+  var md = m.delta.messageMetadata;
+
+  var mdata =
+    m.delta.data === undefined
+      ? []
+      : m.delta.data.prng === undefined
+        ? []
+        : JSON.parse(m.delta.data.prng);
+  var m_id = mdata.map((u) => u.i);
+  var m_offset = mdata.map((u) => u.o);
+  var m_length = mdata.map((u) => u.l);
+  var mentions = {};
+  var body = m.delta.body || "";
+  var args = body == "" ? [] : body.trim().split(/\s+/);
+  for (var i = 0; i < m_id.length; i++) {
+    mentions[m_id[i]] = m.delta.body.substring(
+      m_offset[i],
+      m_offset[i] + m_length[i],
+    );
   }
 
   return {
     type: "message",
     senderID: formatID(md.actorFbId.toString()),
-    body: m.delta.body || "",
-    threadID: formatID((md.threadKey.threadFbId || md.threadKey.otherUserFbId).toString()),
+    threadID: formatID(
+      (md.threadKey.threadFbId || md.threadKey.otherUserFbId).toString(),
+    ),
+    args: args,
+    body: body,
     messageID: md.messageId,
-    attachments: (m.delta.attachments || []).map(v => _formatAttachment(v)),
+    attachments: (m.delta.attachments || []).map((v) => _formatAttachment(v)),
     mentions: mentions,
     timestamp: md.timestamp,
     isGroup: !!md.threadKey.threadFbId,
-    participantIDs: m.delta.participants
+    participantIDs: m.delta.participants || [],
   };
 }
 
 function formatID(id) {
-  return (id != null) ? id.replace(/(fb)?id[:.]/, "") : id;
+  if (id != undefined && id != null) {
+    return id.replace(/(fb)?id[:.]/, "");
+  } else {
+    return id;
+  }
 }
 
 function formatMessage(m) {
-  const originalMessage = m.message ? m.message : m;
-  const obj = {
+  var originalMessage = m.message ? m.message : m;
+  var obj = {
     type: "message",
     senderName: originalMessage.sender_name,
     senderID: formatID(originalMessage.sender_fbid.toString()),
-    participantNames: originalMessage.group_thread_info ? originalMessage.group_thread_info.participant_names : [originalMessage.sender_name.split(" ")[0]],
-    participantIDs: originalMessage.group_thread_info ? originalMessage.group_thread_info.participant_ids.map(v => formatID(v.toString())) : [formatID(originalMessage.sender_fbid)],
+    participantNames: originalMessage.group_thread_info
+      ? originalMessage.group_thread_info.participant_names
+      : [originalMessage.sender_name.split(" ")[0]],
+    participantIDs: originalMessage.group_thread_info
+      ? originalMessage.group_thread_info.participant_ids.map(function (v) {
+          return formatID(v.toString());
+        })
+      : [formatID(originalMessage.sender_fbid)],
     body: originalMessage.body || "",
-    threadID: formatID((originalMessage.thread_fbid || originalMessage.other_user_fbid).toString()),
-    threadName: originalMessage.group_thread_info ? originalMessage.group_thread_info.name : originalMessage.sender_name,
+    threadID: formatID(
+      (
+        originalMessage.thread_fbid || originalMessage.other_user_fbid
+      ).toString(),
+    ),
+    threadName: originalMessage.group_thread_info
+      ? originalMessage.group_thread_info.name
+      : originalMessage.sender_name,
     location: originalMessage.coordinates ? originalMessage.coordinates : null,
-    messageID: originalMessage.mid ? originalMessage.mid.toString() : originalMessage.message_id,
-    attachments: formatAttachment(originalMessage.attachments, originalMessage.attachmentIds, originalMessage.attachment_map, originalMessage.share_map),
+    messageID: originalMessage.mid
+      ? originalMessage.mid.toString()
+      : originalMessage.message_id,
+    attachments: formatAttachment(
+      originalMessage.attachments,
+      originalMessage.attachmentIds,
+      originalMessage.attachment_map,
+      originalMessage.share_map,
+    ),
     timestamp: originalMessage.timestamp,
     timestampAbsolute: originalMessage.timestamp_absolute,
     timestampRelative: originalMessage.timestamp_relative,
     timestampDatetime: originalMessage.timestamp_datetime,
     tags: originalMessage.tags,
     reactions: originalMessage.reactions ? originalMessage.reactions : [],
-    isUnread: originalMessage.is_unread
+    isUnread: originalMessage.is_unread,
   };
 
-  if (m.type === "pages_messaging") obj.pageID = m.realtime_viewer_fbid.toString();
+  if (m.type === "pages_messaging")
+    obj.pageID = m.realtime_viewer_fbid.toString();
   obj.isGroup = obj.participantIDs.length > 2;
+
   return obj;
 }
 
 function formatEvent(m) {
-  const originalMessage = m.message ? m.message : m;
-  let logMessageType = originalMessage.log_message_type;
-  let logMessageData;
+  var originalMessage = m.message ? m.message : m;
+  var logMessageType = originalMessage.log_message_type;
+  var logMessageData;
   if (logMessageType === "log:generic-admin-text") {
     logMessageData = originalMessage.log_message_data.untypedData;
-    logMessageType = getAdminTextMessageType(originalMessage.log_message_data.message_type);
+    logMessageType = getAdminTextMessageType(
+      originalMessage.log_message_data.message_type,
+    );
   } else {
     logMessageData = originalMessage.log_message_data;
   }
@@ -496,39 +806,58 @@ function formatEvent(m) {
     type: "event",
     logMessageType: logMessageType,
     logMessageData: logMessageData,
-    logMessageBody: originalMessage.log_message_body
+    logMessageBody: originalMessage.log_message_body,
   });
 }
 
 function formatHistoryMessage(m) {
-  return m.action_type === "ma-type:log-message" ? formatEvent(m) : formatMessage(m);
+  switch (m.action_type) {
+    case "ma-type:log-message":
+      return formatEvent(m);
+    default:
+      return formatMessage(m);
+  }
 }
 
+// Get a more readable message type for AdminTextMessages
 function getAdminTextMessageType(type) {
   switch (type) {
-    case 'unpin_messages_v2': return 'log:unpin-message';
-    case 'pin_messages_v2': return 'log:pin-message';
-    case "change_thread_theme": return "log:thread-color";
-    case "change_thread_icon":
-    case 'change_thread_quick_reaction': return "log:thread-icon";
-    case "change_thread_nickname": return "log:user-nickname";
-    case "change_thread_admins": return "log:thread-admins";
-    case "group_poll": return "log:thread-poll";
-    case "change_thread_approval_mode": return "log:thread-approval-mode";
+    case "change_thread_theme":
+      return "log:thread-color";
+    // case "change_thread_icon": deprecated
+    case "change_thread_quick_reaction":
+      return "log:thread-icon";
+    case "change_thread_nickname":
+      return "log:user-nickname";
+    case "change_thread_admins":
+      return "log:thread-admins";
+    case "group_poll":
+      return "log:thread-poll";
+    case "change_thread_approval_mode":
+      return "log:thread-approval-mode";
     case "messenger_call_log":
-    case "participant_joined_group_call": return "log:thread-call";
-    default: return type;
+    case "participant_joined_group_call":
+      return "log:thread-call";
+    default:
+      return type;
   }
 }
 
 function formatDeltaEvent(m) {
-  let logMessageType;
-  let logMessageData;
+  var logMessageType;
+  var logMessageData;
+
+  // log:thread-color => {theme_color}
+  // log:user-nickname => {participant_id, nickname}
+  // log:thread-icon => {thread_icon}
+  // log:thread-name => {name}
+  // log:subscribe => {addedParticipants - [Array]}
+  // log:unsubscribe => {leftParticipantFbId}
 
   switch (m.class) {
     case "AdminTextMessage":
-      logMessageData = m.untypedData;
       logMessageType = getAdminTextMessageType(m.type);
+      logMessageData = m.untypedData;
       break;
     case "ThreadName":
       logMessageType = "log:thread-name";
@@ -542,28 +871,21 @@ function formatDeltaEvent(m) {
       logMessageType = "log:unsubscribe";
       logMessageData = { leftParticipantFbId: m.leftParticipantFbId };
       break;
-    case "ApprovalQueue":
-      logMessageType = "log:approval-queue";
-      logMessageData = {
-        approvalQueue: {
-          action: m.action,
-          recipientFbId: m.recipientFbId,
-          requestSource: m.requestSource,
-          ...m.messageMetadata
-        }
-      };
-      break;
   }
+
   return {
     type: "event",
-    threadID: formatID((m.messageMetadata.threadKey.threadFbId || m.messageMetadata.threadKey.otherUserFbId).toString()),
-    messageID: m.messageMetadata.messageId.toString(),
-    logMessageType,
-    logMessageData,
+    threadID: formatID(
+      (
+        m.messageMetadata.threadKey.threadFbId ||
+        m.messageMetadata.threadKey.otherUserFbId
+      ).toString(),
+    ),
+    logMessageType: logMessageType,
+    logMessageData: logMessageData,
     logMessageBody: m.messageMetadata.adminText,
-    timestamp: m.messageMetadata.timestamp,
     author: m.messageMetadata.actorFbId,
-    participantIDs: m.participants
+    participantIDs: m.participants || [],
   };
 }
 
@@ -571,19 +893,27 @@ function formatTyp(event) {
   return {
     isTyping: !!event.st,
     from: event.from.toString(),
-    threadID: formatID((event.to || event.thread_fbid || event.from).toString()),
+    threadID: formatID(
+      (event.to || event.thread_fbid || event.from).toString(),
+    ),
+    // When receiving typ indication from mobile, `from_mobile` isn't set.
+    // If it is, we just use that value.
     fromMobile: event.hasOwnProperty("from_mobile") ? event.from_mobile : true,
     userID: (event.realtime_viewer_fbid || event.from).toString(),
-    type: "typ"
+    type: "typ",
   };
 }
 
 function formatDeltaReadReceipt(delta) {
+  // otherUserFbId seems to be used as both the readerID and the threadID in a 1-1 chat.
+  // In a group chat actorFbId is used for the reader and threadFbId for the thread.
   return {
     reader: (delta.threadKey.otherUserFbId || delta.actorFbId).toString(),
     time: delta.actionTimestampMs,
-    threadID: formatID((delta.threadKey.otherUserFbId || delta.threadKey.threadFbId).toString()),
-    type: "read_receipt"
+    threadID: formatID(
+      (delta.threadKey.otherUserFbId || delta.threadKey.threadFbId).toString(),
+    ),
+    type: "read_receipt",
   };
 }
 
@@ -592,42 +922,69 @@ function formatReadReceipt(event) {
     reader: event.reader.toString(),
     time: event.time,
     threadID: formatID((event.thread_fbid || event.reader).toString()),
-    type: "read_receipt"
+    type: "read_receipt",
   };
 }
 
 function formatRead(event) {
   return {
-    threadID: formatID(((event.chat_ids && event.chat_ids[0]) || (event.thread_fbids && event.thread_fbids[0])).toString()),
+    threadID: formatID(
+      (
+        (event.chat_ids && event.chat_ids[0]) ||
+        (event.thread_fbids && event.thread_fbids[0])
+      ).toString(),
+    ),
     time: event.timestamp,
-    type: "read"
+    type: "read",
   };
 }
 
 function getFrom(str, startToken, endToken) {
-  const start = str.indexOf(startToken) + startToken.length;
+  var start = str.indexOf(startToken) + startToken.length;
   if (start < startToken.length) return "";
-  const lastHalf = str.substring(start);
-  const end = lastHalf.indexOf(endToken);
+
+  var lastHalf = str.substring(start);
+  var end = lastHalf.indexOf(endToken);
   if (end === -1) {
-    throw Error("Could not find endTime `" + endToken + "` in the given string.");
+    throw Error(
+      "Could not find endTime `" + endToken + "` in the given string.",
+    );
   }
   return lastHalf.substring(0, end);
 }
 
 function makeParsable(html) {
-  const withoutForLoop = html.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*/, "");
-  const maybeMultipleObjects = withoutForLoop.split(/\}\r\n *\{/);
+  let withoutForLoop = html.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*/, "");
+
+  // (What the fuck FB, why windows style newlines?)
+  // So sometimes FB will send us base multiple objects in the same response.
+  // They're all valid JSON, one after the other, at the top level. We detect
+  // that and make it parse-able by JSON.parse.
+  //       Ben - July 15th 2017
+  //
+  // It turns out that Facebook may insert random number of spaces before
+  // next object begins (issue #616)
+  //       rav_kr - 2018-03-19
+  let maybeMultipleObjects = withoutForLoop.split(/\}\r\n *\{/);
   if (maybeMultipleObjects.length === 1) return maybeMultipleObjects;
+
   return "[" + maybeMultipleObjects.join("},{") + "]";
 }
 
 function arrToForm(form) {
-  return arrayToObject(form, v => v.name, v => v.val);
+  return arrayToObject(
+    form,
+    function (v) {
+      return v.name;
+    },
+    function (v) {
+      return v.val;
+    },
+  );
 }
 
 function arrayToObject(arr, getKey, getValue) {
-  return arr.reduce(function(acc, val) {
+  return arr.reduce(function (acc, val) {
     acc[getKey(val)] = getValue(val);
     return acc;
   }, {});
@@ -638,113 +995,223 @@ function getSignatureID() {
 }
 
 function generateTimestampRelative() {
-  const d = new Date();
+  var d = new Date();
   return d.getHours() + ":" + padZeros(d.getMinutes());
 }
 
 function makeDefaults(html, userID, ctx) {
-  let reqCounter = 1;
-  const revision = getFrom(html, 'revision":', ",");
+  var reqCounter = 1;
+  var fb_dtsg = getFrom(html, 'name="fb_dtsg" value="', '"');
+
+  // @Hack Ok we've done hacky things, this is definitely on top 5.
+  // We totally assume the object is flat and try parsing until a }.
+  // If it works though it's cool because we get a bunch of extra data things.
+  //
+  // Update: we don't need this. Leaving it in in case we ever do.
+  //       Ben - July 15th 2017
+
+  // var siteData = getFrom(html, "[\"SiteData\",[],", "},");
+  // try {
+  //   siteData = JSON.parse(siteData + "}");
+  // } catch(e) {
+  //   log.warn("makeDefaults", "Couldn't parse SiteData. Won't have access to some variables.");
+  //   siteData = {};
+  // }
+
+  var ttstamp = "2";
+  for (var i = 0; i < fb_dtsg.length; i++) {
+    ttstamp += fb_dtsg.charCodeAt(i);
+  }
+  var revision = getFrom(html, 'revision":', ",");
+
   function mergeWithDefaults(obj) {
-    const newObj = {
-      av: userID,
+    // @TODO This is missing a key called __dyn.
+    // After some investigation it seems like __dyn is some sort of set that FB
+    // calls BitMap. It seems like certain responses have a "define" key in the
+    // res.jsmods arrays. I think the code iterates over those and calls `set`
+    // on the bitmap for each of those keys. Then it calls
+    // bitmap.toCompressedString() which returns what __dyn is.
+    //
+    // So far the API has been working without this.
+    //
+    //              Ben - July 15th 2017
+    var newObj = {
       __user: userID,
       __req: (reqCounter++).toString(36),
       __rev: revision,
       __a: 1,
-      ...(ctx && {
-       fb_dtsg: ctx.fb_dtsg,
-       jazoest: ctx.jazoest
-      })
+      // __af: siteData.features,
+      fb_dtsg: ctx.fb_dtsg ? ctx.fb_dtsg : fb_dtsg,
+      jazoest: ctx.ttstamp ? ctx.ttstamp : ttstamp,
+      // __spin_r: siteData.__spin_r,
+      // __spin_b: siteData.__spin_b,
+      // __spin_t: siteData.__spin_t,
     };
 
+    // @TODO this is probably not needed.
+    //         Ben - July 15th 2017
+    // if (siteData.be_key) {
+    //   newObj[siteData.be_key] = siteData.be_mode;
+    // }
+    // if (siteData.pkg_cohort_key) {
+    //   newObj[siteData.pkg_cohort_key] = siteData.pkg_cohort;
+    // }
+
     if (!obj) return newObj;
-    
-    Object.keys(obj).forEach(prop => {
-      if (obj.hasOwnProperty(prop) && !newObj.hasOwnProperty(prop)) {
-        newObj[prop] = obj[prop];
+
+    for (var prop in obj) {
+      if (obj.hasOwnProperty(prop)) {
+        if (!newObj[prop]) {
+          newObj[prop] = obj[prop];
+        }
       }
-    });
+    }
+
     return newObj;
   }
 
+  function postWithDefaults(url, jar, form, ctxx) {
+    return post(
+      url,
+      jar,
+      mergeWithDefaults(form),
+      ctx.globalOptions,
+      ctxx || ctx,
+    );
+  }
+
+  function getWithDefaults(url, jar, qs, ctxx) {
+    return get(url, jar, mergeWithDefaults(qs), ctx.globalOptions, ctxx || ctx);
+  }
+
+  function postFormDataWithDefault(url, jar, form, qs, ctxx) {
+    return postFormData(
+      url,
+      jar,
+      mergeWithDefaults(form),
+      mergeWithDefaults(qs),
+      ctx.globalOptions,
+      ctxx || ctx,
+    );
+  }
+
   return {
-    get: (url, jar, qs, ctxx, customHeader = {}) => get(url, jar, mergeWithDefaults(qs), ctx.globalOptions, ctxx || ctx, customHeader),
-    post: (url, jar, form, ctxx, customHeader = {}) => post(url, jar, mergeWithDefaults(form), ctx.globalOptions, ctxx || ctx, customHeader),
-    postFormData: (url, jar, form, qs, ctxx) => postFormData(url, jar, mergeWithDefaults(form), mergeWithDefaults(qs), ctx.globalOptions, ctxx || ctx)
+    get: getWithDefaults,
+    post: postWithDefaults,
+    postFormData: postFormDataWithDefault,
   };
 }
 
-function parseAndCheckLogin(ctx, http, retryCount = 0) {
-  const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-  const _try = (tryData) => new Promise(function(resolve, reject) {
-    try {
-      resolve(tryData());
-    } catch (error) {
-      reject(error);
-    }
-  });
-
-  return function(data) {
-    function any() {
+function parseAndCheckLogin(ctx, defaultFuncs, retryCount) {
+  if (retryCount == undefined) {
+    retryCount = 0;
+  }
+  return function (data) {
+    return bluebird.try(function () {
+      log.verbose("parseAndCheckLogin", data.body);
       if (data.statusCode >= 500 && data.statusCode < 600) {
         if (retryCount >= 5) {
-          const err = new Error("Request retry failed. Check the `res` and `statusCode` property on this error.");
-          err.statusCode = data.statusCode;
-          err.res = data.body;
-          err.error = "Request retry failed. Check the `res` and `statusCode` property on this error.";
-          throw err;
+          throw {
+            error:
+              "Request retry failed. Check the `res` and `statusCode` property on this error.",
+            statusCode: data.statusCode,
+            res: data.body,
+          };
         }
         retryCount++;
-        const retryTime = Math.floor(Math.random() * 5000);
-        console.warn("parseAndCheckLogin", "Got status code " + data.statusCode + " - " + retryCount + ". attempt to retry in " + retryTime + " milliseconds...");
-        const url = data.request.uri.protocol + "//" + data.request.uri.hostname + data.request.uri.pathname;
-        
-        const contentType = data.request.headers?.["content-type"] || "";
-        if (contentType.split(";")[0] === "multipart/form-data") {
-          return delay(retryTime)
-            .then(() => http.postFormData(url, ctx.jar, data.request.formData))
-            .then(parseAndCheckLogin(ctx, http, retryCount));
+        var retryTime = Math.floor(Math.random() * 5000);
+        log.warn(
+          "parseAndCheckLogin",
+          "Got status code " +
+            data.statusCode +
+            " - " +
+            retryCount +
+            ". attempt to retry in " +
+            retryTime +
+            " milliseconds...",
+        );
+        var url =
+          data.request.uri.protocol +
+          "//" +
+          data.request.uri.hostname +
+          data.request.uri.pathname;
+        if (
+          data.request.headers["Content-Type"].split(";")[0] ===
+          "multipart/form-data"
+        ) {
+          return bluebird
+            .delay(retryTime)
+            .then(function () {
+              return defaultFuncs.postFormData(
+                url,
+                ctx.jar,
+                data.request.formData,
+                {},
+              );
+            })
+            .then(parseAndCheckLogin(ctx, defaultFuncs, retryCount));
         } else {
-          return delay(retryTime)
-            .then(() => http.post(url, ctx.jar, data.request.formData))
-            .then(parseAndCheckLogin(ctx, http, retryCount));
+          return bluebird
+            .delay(retryTime)
+            .then(function () {
+              return defaultFuncs.post(url, ctx.jar, data.request.formData);
+            })
+            .then(parseAndCheckLogin(ctx, defaultFuncs, retryCount));
         }
       }
-
-      if (data.statusCode === 404) return;
       if (data.statusCode !== 200)
-        throw new Error("parseAndCheckLogin got status code: " + data.statusCode + ". Bailing out of trying to parse response.");
+        throw new Error(
+          "parseAndCheckLogin got status code: " +
+            data.statusCode +
+            ". Bailing out of trying to parse response.",
+        );
 
-      let res = null;
+      var res = null;
       try {
         res = JSON.parse(makeParsable(data.body));
       } catch (e) {
-        const err = new Error("JSON.parse error. Check the `detail` property on this error.");
-        err.error = "JSON.parse error. Check the `detail` property on this error.";
-        err.detail = e;
-        err.res = data.body;
-        throw err;
+        throw {
+          error: "JSON.parse error. Check the `detail` property on this error.",
+          detail: e,
+          res: data.body,
+        };
       }
 
+      // In some cases the response contains only a redirect URL which should be followed
       if (res.redirect && data.request.method === "GET") {
-        return http.get(res.redirect, ctx.jar).then(parseAndCheckLogin(ctx, http));
+        return defaultFuncs
+          .get(res.redirect, ctx.jar)
+          .then(parseAndCheckLogin(ctx, defaultFuncs));
       }
 
-      if (res.jsmods?.require && Array.isArray(res.jsmods.require[0]) && res.jsmods.require[0][0] === "Cookie") {
-        res.jsmods.require[0][3][0] = res.jsmods.require[0][3][0].replace("_js_", "");
-        const requireCookie = res.jsmods.require[0][3];
-        ctx.jar.setCookie(formatCookie(requireCookie, "facebook"), "https://www.facebook.com");
-        ctx.jar.setCookie(formatCookie(requireCookie, "messenger"), "https://www.messenger.com");
+      // TODO: handle multiple cookies?
+      if (
+        res.jsmods &&
+        res.jsmods.require &&
+        Array.isArray(res.jsmods.require[0]) &&
+        res.jsmods.require[0][0] === "Cookie"
+      ) {
+        res.jsmods.require[0][3][0] = res.jsmods.require[0][3][0].replace(
+          "_js_",
+          "",
+        );
+        var cookie = formatCookie(res.jsmods.require[0][3], "facebook");
+        var cookie2 = formatCookie(res.jsmods.require[0][3], "messenger");
+        ctx.jar.setCookie(cookie, "https://www.facebook.com");
+        ctx.jar.setCookie(cookie2, "https://www.messenger.com");
       }
 
+      // On every request we check if we got a DTSG and we mutate the context so that we use the latest
+      // one for the next requests.
       if (res.jsmods && Array.isArray(res.jsmods.require)) {
-        const arr = res.jsmods.require;
-        for (const i in arr) {
+        var arr = res.jsmods.require;
+        for (var i in arr) {
           if (arr[i][0] === "DTSG" && arr[i][1] === "setToken") {
             ctx.fb_dtsg = arr[i][3][0];
+
+            // Update ttstamp since that depends on fb_dtsg
             ctx.ttstamp = "2";
-            for (let j = 0; j < ctx.fb_dtsg.length; j++) {
+            for (var j = 0; j < ctx.fb_dtsg.length; j++) {
               ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
             }
           }
@@ -752,43 +1219,73 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       }
 
       if (res.error === 1357001) {
-        const err = new Error('Facebook blocked the login');
-        err.error = "Not logged in.";
-        throw err;
+        throw { error: "Not logged in." };
       }
       return res;
-    }
-    return _try(any);
+    });
   };
 }
 
 function saveCookies(jar) {
-  return function(res) {
-    const cookies = res.headers?.["set-cookie"] || [];
-    cookies.forEach(function(c) {
+  return function (res) {
+    var cookies = res.headers["set-cookie"] || [];
+    cookies.forEach(function (c) {
       if (c.indexOf(".facebook.com") > -1) {
         jar.setCookie(c, "https://www.facebook.com");
       }
-      const c2 = c.replace(/domain=\.facebook\.com/, "domain=.messenger.com");
+      var c2 = c.replace(/domain=\.facebook\.com/, "domain=.messenger.com");
       jar.setCookie(c2, "https://www.messenger.com");
     });
     return res;
   };
 }
 
-const NUM_TO_MONTH = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-const NUM_TO_DAY = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-
+var NUM_TO_MONTH = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+var NUM_TO_DAY = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 function formatDate(date) {
-  const d = padZeros(date.getUTCDate());
-  const h = padZeros(date.getUTCHours());
-  const m = padZeros(date.getUTCMinutes());
-  const s = padZeros(date.getUTCSeconds());
-  return `${NUM_TO_DAY[date.getUTCDay()]}, ${d} ${NUM_TO_MONTH[date.getUTCMonth()]} ${date.getUTCFullYear()} ${h}:${m}:${s} GMT`;
+  var d = date.getUTCDate();
+  d = d >= 10 ? d : "0" + d;
+  var h = date.getUTCHours();
+  h = h >= 10 ? h : "0" + h;
+  var m = date.getUTCMinutes();
+  m = m >= 10 ? m : "0" + m;
+  var s = date.getUTCSeconds();
+  s = s >= 10 ? s : "0" + s;
+  return (
+    NUM_TO_DAY[date.getUTCDay()] +
+    ", " +
+    d +
+    " " +
+    NUM_TO_MONTH[date.getUTCMonth()] +
+    " " +
+    date.getUTCFullYear() +
+    " " +
+    h +
+    ":" +
+    m +
+    ":" +
+    s +
+    " GMT"
+  );
 }
 
-function formatCookie(arr, urlStr) {
-  return arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + urlStr + ".com";
+function formatCookie(arr, url) {
+  return (
+    arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + url + ".com"
+  );
 }
 
 function formatThread(data) {
@@ -805,7 +1302,7 @@ function formatThread(data) {
     messageCount: data.message_count,
     imageSrc: data.image_src,
     timestamp: data.timestamp,
-    serverTimestamp: data.server_timestamp,
+    serverTimestamp: data.server_timestamp, // what is this?
     muteUntil: data.mute_until,
     isCanonicalUser: data.is_canonical_user,
     isCanonical: data.is_canonical,
@@ -823,54 +1320,88 @@ function formatThread(data) {
     emoji: data.custom_like_icon,
     color: data.custom_color,
     adminIDs: data.admin_ids,
-    threadType: data.thread_type
+    threadType: data.thread_type,
   };
 }
 
+function getType(obj) {
+  return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
 function formatProxyPresence(presence, userID) {
   if (presence.lat === undefined || presence.p === undefined) return null;
-  return { type: "presence", timestamp: presence.lat * 1000, userID: userID, statuses: presence.p };
+  return {
+    type: "presence",
+    timestamp: presence.lat * 1000,
+    userID: userID || "",
+    statuses: presence.p,
+  };
 }
 
 function formatPresence(presence, userID) {
-  return { type: "presence", timestamp: presence.la * 1000, userID: userID, statuses: presence.a };
+  return {
+    type: "presence",
+    timestamp: presence.la * 1000,
+    userID: userID || "",
+    statuses: presence.a,
+  };
 }
 
 function decodeClientPayload(payload) {
-  try {
-    return JSON.parse(Buffer.from(payload).toString('utf8'));
-  } catch (e) {
-    return JSON.parse(String.fromCharCode.apply(null, payload));
+  /*
+  Special function which Client using to "encode" clients JSON payload
+  */
+  function Utf8ArrayToStr(array) {
+    var out, i, len, c;
+    var char2, char3;
+    out = "";
+    len = array.length;
+    i = 0;
+    while (i < len) {
+      c = array[i++];
+      switch (c >> 4) {
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+          out += String.fromCharCode(c);
+          break;
+        case 12:
+        case 13:
+          char2 = array[i++];
+          out += String.fromCharCode(((c & 0x1f) << 6) | (char2 & 0x3f));
+          break;
+        case 14:
+          char2 = array[i++];
+          char3 = array[i++];
+          out += String.fromCharCode(
+            ((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0),
+          );
+          break;
+      }
+    }
+    return out;
   }
-}
 
-function getAppState(jar) {
-  return jar.getCookies("https://www.facebook.com").concat(jar.getCookies("https://www.messenger.com"));
+  return JSON.parse(Utf8ArrayToStr(payload));
 }
 
-function getAccessFromBusiness(jar, Options) {
-  return function(res) {
-    const html = res ? res.body : null;
-    return get('https://business.facebook.com/content_management', jar, null, Options, null, { noRef: true })
-      .then(function(resData) {
-        const match = /"accessToken":"([^.]+)","clientID":/g.exec(resData.body);
-        const token = match ? match[1] : null;
-        return [html, token];
-      })
-      .catch(function() {
-        return [html, null];
-      });
-  };
+function getAppState(jar) {
+  return jar
+    .getCookies("https://www.facebook.com")
+    .concat(jar.getCookies("https://facebook.com"))
+    .concat(jar.getCookies("https://www.messenger.com"));
 }
 
-const meta = prop => new RegExp(`<meta property="${prop}" content="([^"]*)"`);
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 module.exports = {
-  log(...args) { console.log(ws, chalk.green.bold("[LOG]"), ...args); },
-  error(...args) { console.error(ws, chalk.red.bold("[ERROR]"), ...args); },
-  warn(...args) { console.warn(ws, chalk.yellow.bold("[WARNING]"), ...args); },
+  delay,
   isReadableStream,
-  cleanGet,
   get,
   post,
   postFormData,
@@ -908,12 +1439,9 @@ module.exports = {
   getAppState,
   getAdminTextMessageType,
   setProxy,
-  getAccessFromBusiness,
-  presenceDecode,
-  presenceEncode,
-  headers,
-  defaultUserAgent,
-  windowsUserAgent,
-  randomUserAgent,
-  meta
+  getCurrentTimestamp,
+  // Database / cache
+  database,
+  usersCache,
+  groupsCache,
 };