@cexy/hoonfca 1.0.0

package/utils.js

@@ -0,0 +1,919 @@
+"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);
+}
+
+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
+  };
+  if (ctx && ctx.region) headers1["X-MSGR-Region"] = ctx.region;
+  if (customHeader) {
+    Object.assign(headers1, customHeader);
+    if (customHeader.noRef) delete headers1.referer;
+  }
+  return headers1;
+}
+
+function isReadableStream(obj) {
+  return obj instanceof stream.Stream && typeof obj._read === "function" && getType(obj._readableState) === "Object";
+}
+
+function cleanGet(url) {
+  return new Promise(function(resolve, reject) {
+    request.get(url, { timeout: 60000 }, (error, res) => error ? reject(error) : resolve(res));
+  });
+}
+
+function get(url, jar, qs, options, ctx, customHeader) {
+  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, customHeader),
+    timeout: 60000,
+    qs,
+    jar,
+    gzip: true
+  };
+  return new Promise(function (resolve, reject) {
+    request.get(url, op, (error, res) => error ? reject(error) : resolve(res));
+  });
+}
+
+function post(url, jar, form, options, ctx, customHeader) {
+  const op = {
+    headers: getHeaders(url, options, ctx, customHeader),
+    timeout: 60000,
+    form,
+    jar,
+    gzip: true
+  };
+  return new Promise(function (resolve, reject) {
+    request.post(url, op, (error, res) => error ? reject(error) : resolve(res));
+  });
+}
+
+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' }),
+    timeout: 60000,
+    formData: form,
+    qs,
+    jar,
+    gzip: true
+  };
+  return new Promise(function (resolve, reject) {
+    request.post(url, op, (error, res) => error ? reject(error) : resolve(res));
+  });
+}
+
+function padZeros(val, len = 2) {
+  return String(val).padStart(len, "0");
+}
+
+function generateThreadingID(clientID) {
+  const k = Date.now();
+  const l = Math.floor(Math.random() * 4294967295);
+  return `<${k}:${l}-${clientID}@mail.projektitan.com>`;
+}
+
+function binaryToDecimal(data) {
+  let ret = "";
+  while (data !== "0") {
+    let end = 0;
+    let fullName = "";
+    for (let i = 0; i < data.length; i++) {
+      end = 2 * end + parseInt(data[i], 10);
+      if (end >= 10) {
+        fullName += "1";
+        end -= 10;
+      } else {
+        fullName += "0";
+      }
+    }
+    ret = end.toString() + ret;
+    const firstOne = fullName.indexOf("1");
+    data = firstOne === -1 ? "0" : fullName.slice(firstOne);
+  }
+  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",
+  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"
+};
+
+(function() {
+  const l = [];
+  for (const m in j) {
+    i[j[m]] = m;
+    l.push(j[m]);
+  }
+  l.reverse();
+  h = new RegExp(l.join("|"), "g");
+})();
+
+function presenceEncode(str) {
+  return encodeURIComponent(str)
+    .replace(/([_A-Z])|%../g, (m, n) => n ? "%" + n.charCodeAt(0).toString(16) : m)
+    .toLowerCase()
+    .replace(h, m => i[m]);
+}
+
+function presenceDecode(str) {
+  return decodeURIComponent(str.replace(/[_A-Z]/g, m => 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 }
+  }));
+}
+
+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 }));
+}
+
+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;
+}
+
+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;
+
+  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;
+  
+  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") {
+      type = "MessageLocation";
+    } else {
+      type = "ExtensibleAttachment";
+    }
+    blob = attachment1.extensible_attachment;
+  }
+
+  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
+      };
+    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
+      };
+    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
+      };
+    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
+      };
+    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
+      };
+    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
+      };
+    case "error":
+      return { type: "error", 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
+      };
+    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
+      };
+    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
+      };
+    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
+      };
+    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
+      };
+    case "MessageLocation":
+      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
+        };
+      } catch (err) {
+        return { type: "error", error: "Failed to parse location", detail: err };
+      }
+    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) {
+          obj[cur.key] = cur.value.text;
+          return obj;
+        }, {}),
+        facebookUrl: blob.story_attachment.url, target: blob.story_attachment.target, styleList: blob.story_attachment.style_list
+      };
+    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
+      };
+    default:
+      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]]);
+    }) : [];
+}
+
+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);
+    }
+  }
+
+  return {
+    type: "message",
+    senderID: formatID(md.actorFbId.toString()),
+    body: m.delta.body || "",
+    threadID: formatID((md.threadKey.threadFbId || md.threadKey.otherUserFbId).toString()),
+    messageID: md.messageId,
+    attachments: (m.delta.attachments || []).map(v => _formatAttachment(v)),
+    mentions: mentions,
+    timestamp: md.timestamp,
+    isGroup: !!md.threadKey.threadFbId,
+    participantIDs: m.delta.participants
+  };
+}
+
+function formatID(id) {
+  return (id != null) ? id.replace(/(fb)?id[:.]/, "") : id;
+}
+
+function formatMessage(m) {
+  const originalMessage = m.message ? m.message : m;
+  const 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)],
+    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,
+    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),
+    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
+  };
+
+  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;
+  if (logMessageType === "log:generic-admin-text") {
+    logMessageData = originalMessage.log_message_data.untypedData;
+    logMessageType = getAdminTextMessageType(originalMessage.log_message_data.message_type);
+  } else {
+    logMessageData = originalMessage.log_message_data;
+  }
+
+  return Object.assign(formatMessage(originalMessage), {
+    type: "event",
+    logMessageType: logMessageType,
+    logMessageData: logMessageData,
+    logMessageBody: originalMessage.log_message_body
+  });
+}
+
+function formatHistoryMessage(m) {
+  return m.action_type === "ma-type:log-message" ? formatEvent(m) : formatMessage(m);
+}
+
+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 "messenger_call_log":
+    case "participant_joined_group_call": return "log:thread-call";
+    default: return type;
+  }
+}
+
+function formatDeltaEvent(m) {
+  let logMessageType;
+  let logMessageData;
+
+  switch (m.class) {
+    case "AdminTextMessage":
+      logMessageData = m.untypedData;
+      logMessageType = getAdminTextMessageType(m.type);
+      break;
+    case "ThreadName":
+      logMessageType = "log:thread-name";
+      logMessageData = { name: m.name };
+      break;
+    case "ParticipantsAddedToGroupThread":
+      logMessageType = "log:subscribe";
+      logMessageData = { addedParticipants: m.addedParticipants };
+      break;
+    case "ParticipantLeftGroupThread":
+      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,
+    logMessageBody: m.messageMetadata.adminText,
+    timestamp: m.messageMetadata.timestamp,
+    author: m.messageMetadata.actorFbId,
+    participantIDs: m.participants
+  };
+}
+
+function formatTyp(event) {
+  return {
+    isTyping: !!event.st,
+    from: event.from.toString(),
+    threadID: formatID((event.to || event.thread_fbid || event.from).toString()),
+    fromMobile: event.hasOwnProperty("from_mobile") ? event.from_mobile : true,
+    userID: (event.realtime_viewer_fbid || event.from).toString(),
+    type: "typ"
+  };
+}
+
+function formatDeltaReadReceipt(delta) {
+  return {
+    reader: (delta.threadKey.otherUserFbId || delta.actorFbId).toString(),
+    time: delta.actionTimestampMs,
+    threadID: formatID((delta.threadKey.otherUserFbId || delta.threadKey.threadFbId).toString()),
+    type: "read_receipt"
+  };
+}
+
+function formatReadReceipt(event) {
+  return {
+    reader: event.reader.toString(),
+    time: event.time,
+    threadID: formatID((event.thread_fbid || event.reader).toString()),
+    type: "read_receipt"
+  };
+}
+
+function formatRead(event) {
+  return {
+    threadID: formatID(((event.chat_ids && event.chat_ids[0]) || (event.thread_fbids && event.thread_fbids[0])).toString()),
+    time: event.timestamp,
+    type: "read"
+  };
+}
+
+function getFrom(str, startToken, endToken) {
+  const start = str.indexOf(startToken) + startToken.length;
+  if (start < startToken.length) return "";
+  const lastHalf = str.substring(start);
+  const end = lastHalf.indexOf(endToken);
+  if (end === -1) {
+    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 *\{/);
+  if (maybeMultipleObjects.length === 1) return maybeMultipleObjects;
+  return "[" + maybeMultipleObjects.join("},{") + "]";
+}
+
+function arrToForm(form) {
+  return arrayToObject(form, v => v.name, v => v.val);
+}
+
+function arrayToObject(arr, getKey, getValue) {
+  return arr.reduce(function(acc, val) {
+    acc[getKey(val)] = getValue(val);
+    return acc;
+  }, {});
+}
+
+function getSignatureID() {
+  return Math.floor(Math.random() * 2147483648).toString(16);
+}
+
+function generateTimestampRelative() {
+  const d = new Date();
+  return d.getHours() + ":" + padZeros(d.getMinutes());
+}
+
+function makeDefaults(html, userID, ctx) {
+  let reqCounter = 1;
+  const revision = getFrom(html, 'revision":', ",");
+  function mergeWithDefaults(obj) {
+    const newObj = {
+      av: userID,
+      __user: userID,
+      __req: (reqCounter++).toString(36),
+      __rev: revision,
+      __a: 1,
+      ...(ctx && {
+       fb_dtsg: ctx.fb_dtsg,
+       jazoest: ctx.jazoest
+      })
+    };
+
+    if (!obj) return newObj;
+    
+    Object.keys(obj).forEach(prop => {
+      if (obj.hasOwnProperty(prop) && !newObj.hasOwnProperty(prop)) {
+        newObj[prop] = obj[prop];
+      }
+    });
+    return newObj;
+  }
+
+  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)
+  };
+}
+
+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() {
+      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;
+        }
+        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));
+        } else {
+          return delay(retryTime)
+            .then(() => http.post(url, ctx.jar, data.request.formData))
+            .then(parseAndCheckLogin(ctx, http, 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.");
+
+      let 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;
+      }
+
+      if (res.redirect && data.request.method === "GET") {
+        return http.get(res.redirect, ctx.jar).then(parseAndCheckLogin(ctx, http));
+      }
+
+      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");
+      }
+
+      if (res.jsmods && Array.isArray(res.jsmods.require)) {
+        const arr = res.jsmods.require;
+        for (const i in arr) {
+          if (arr[i][0] === "DTSG" && arr[i][1] === "setToken") {
+            ctx.fb_dtsg = arr[i][3][0];
+            ctx.ttstamp = "2";
+            for (let j = 0; j < ctx.fb_dtsg.length; j++) {
+              ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
+            }
+          }
+        }
+      }
+
+      if (res.error === 1357001) {
+        const err = new Error('Facebook blocked the login');
+        err.error = "Not logged in.";
+        throw err;
+      }
+      return res;
+    }
+    return _try(any);
+  };
+}
+
+function saveCookies(jar) {
+  return function(res) {
+    const 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");
+      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"];
+
+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`;
+}
+
+function formatCookie(arr, urlStr) {
+  return arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + urlStr + ".com";
+}
+
+function formatThread(data) {
+  return {
+    threadID: formatID(data.thread_fbid.toString()),
+    participants: data.participants.map(formatID),
+    participantIDs: data.participants.map(formatID),
+    name: data.name,
+    nicknames: data.custom_nickname,
+    snippet: data.snippet,
+    snippetAttachments: data.snippet_attachments,
+    snippetSender: formatID((data.snippet_sender || "").toString()),
+    unreadCount: data.unread_count,
+    messageCount: data.message_count,
+    imageSrc: data.image_src,
+    timestamp: data.timestamp,
+    serverTimestamp: data.server_timestamp,
+    muteUntil: data.mute_until,
+    isCanonicalUser: data.is_canonical_user,
+    isCanonical: data.is_canonical,
+    isSubscribed: data.is_subscribed,
+    folder: data.folder,
+    isArchived: data.is_archived,
+    recipientsLoadable: data.recipients_loadable,
+    hasEmailParticipant: data.has_email_participant,
+    readOnly: data.read_only,
+    canReply: data.can_reply,
+    cannotReplyReason: data.cannot_reply_reason,
+    lastMessageTimestamp: data.last_message_timestamp,
+    lastReadTimestamp: data.last_read_timestamp,
+    lastMessageType: data.last_message_type,
+    emoji: data.custom_like_icon,
+    color: data.custom_color,
+    adminIDs: data.admin_ids,
+    threadType: data.thread_type
+  };
+}
+
+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 };
+}
+
+function formatPresence(presence, userID) {
+  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));
+  }
+}
+
+function getAppState(jar) {
+  return jar.getCookies("https://www.facebook.com").concat(jar.getCookies("https://www.messenger.com"));
+}
+
+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];
+      });
+  };
+}
+
+const meta = prop => new RegExp(`<meta property="${prop}" content="([^"]*)"`);
+
+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); },
+  isReadableStream,
+  cleanGet,
+  get,
+  post,
+  postFormData,
+  generateThreadingID,
+  generateOfflineThreadingID,
+  getGUID,
+  getFrom,
+  makeParsable,
+  arrToForm,
+  getSignatureID,
+  getJar: request.jar,
+  generateTimestampRelative,
+  makeDefaults,
+  parseAndCheckLogin,
+  saveCookies,
+  getType,
+  _formatAttachment,
+  formatHistoryMessage,
+  formatID,
+  formatMessage,
+  formatDeltaEvent,
+  formatDeltaMessage,
+  formatProxyPresence,
+  formatPresence,
+  formatTyp,
+  formatDeltaReadReceipt,
+  formatCookie,
+  formatThread,
+  formatReadReceipt,
+  formatRead,
+  generatePresence,
+  generateAccessiblityCookie,
+  formatDate,
+  decodeClientPayload,
+  getAppState,
+  getAdminTextMessageType,
+  setProxy,
+  getAccessFromBusiness,
+  presenceDecode,
+  presenceEncode,
+  headers,
+  defaultUserAgent,
+  windowsUserAgent,
+  randomUserAgent,
+  meta
+};