bb-fca 2.0.0

package/src/utils/axios.ts

@@ -0,0 +1,178 @@
+import axios from 'axios';
+import { wrapper } from 'axios-cookiejar-support';
+import FormData from 'form-data';
+import { CookieJar } from 'tough-cookie';
+import { getType } from './constants';
+import { getHeaders } from './headers';
+
+const jar = new CookieJar();
+const client = wrapper(axios.create({ jar } as any));
+
+let proxyConfig: any = {};
+
+const delay = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+function adaptResponse(res: any): any {
+  const response = res.response || res;
+  return {
+    ...response,
+    body: response.data,
+    statusCode: response.status,
+    request: {
+      uri: new URL(response.config.url),
+      headers: response.config.headers,
+      method: response.config.method.toUpperCase(),
+      form: response.config.data,
+      formData: response.config.data,
+    },
+  };
+}
+
+async function requestWithRetry(
+  requestFunction: () => Promise<any>,
+  retries: number = 3,
+): Promise<any> {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const res = await requestFunction();
+      return adaptResponse(res);
+    } catch (error) {
+      if (i === retries - 1) {
+        console.error(
+          `Request failed after ${retries} attempts:`,
+          error.message,
+        );
+        if (error.response) {
+          return adaptResponse(error.response);
+        }
+        throw error;
+      }
+      const backoffTime = Math.pow(2, i) * 1000;
+      console.warn(
+        `Request attempt ${i + 1} failed. Retrying in ${backoffTime}ms...`,
+      );
+      await delay(backoffTime);
+    }
+  }
+}
+
+export function setProxy(proxyUrl?: string): void {
+  if (proxyUrl) {
+    try {
+      const parsedProxy = new URL(proxyUrl);
+      proxyConfig = {
+        proxy: {
+          host: parsedProxy.hostname,
+          port: parsedProxy.port,
+          protocol: parsedProxy.protocol.replace(':', ''),
+          auth:
+            parsedProxy.username && parsedProxy.password
+              ? {
+                  username: parsedProxy.username,
+                  password: parsedProxy.password,
+                }
+              : undefined,
+        },
+      };
+    } catch (e) {
+      console.error('Invalid proxy URL.');
+      proxyConfig = {};
+    }
+  } else {
+    proxyConfig = {};
+  }
+}
+
+export function cleanGet(url: string): Promise<any> {
+  const fn = () => client.get(url, { timeout: 60000, ...proxyConfig });
+  return requestWithRetry(fn as any);
+}
+
+export async function get(
+  url: string,
+  reqJar: any,
+  qs?: any,
+  options?: any,
+  ctx?: any,
+  customHeader?: any,
+): Promise<any> {
+  const config: any = {
+    headers: getHeaders(url, options, ctx, customHeader),
+    timeout: 60000,
+    params: qs,
+    ...proxyConfig,
+    validateStatus: (status: number) => status >= 200 && status < 600,
+  };
+  return requestWithRetry(async () => await client.get(url, config));
+}
+
+export async function post(
+  url: string,
+  reqJar: any,
+  form?: any,
+  options?: any,
+  ctx?: any,
+  customHeader?: any,
+): Promise<any> {
+  const headers = getHeaders(url, options, ctx, customHeader);
+  let data: any = form;
+  let contentType =
+    headers['Content-Type'] || 'application/x-www-form-urlencoded';
+
+  if (contentType.includes('json')) {
+    data = JSON.stringify(form);
+  } else {
+    const transformedForm = new URLSearchParams();
+    for (const key in form) {
+      if (form.hasOwnProperty(key)) {
+        let value = form[key];
+        if (getType(value) === 'Object') {
+          value = JSON.stringify(value);
+        }
+        transformedForm.append(key, value);
+      }
+    }
+    data = transformedForm.toString();
+  }
+  headers['Content-Type'] = contentType;
+
+  const config: any = {
+    headers,
+    timeout: 60000,
+    ...proxyConfig,
+    validateStatus: (status: number) => status >= 200 && status < 600,
+  };
+  return requestWithRetry(async () => await client.post(url, data, config));
+}
+
+export async function postFormData(
+  url: string,
+  reqJar: any,
+  form: any,
+  qs?: any,
+  options?: any,
+  ctx?: any,
+): Promise<any> {
+  const formData = new FormData();
+  for (const key in form) {
+    if (form.hasOwnProperty(key)) {
+      formData.append(key, form[key]);
+    }
+  }
+
+  const customHeader = {
+    'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
+  };
+
+  const config: any = {
+    headers: getHeaders(url, options, ctx, customHeader),
+    timeout: 60000,
+    params: qs,
+    ...proxyConfig,
+    validateStatus: (status: number) => status >= 200 && status < 600,
+  };
+  return requestWithRetry(async () => await client.post(url, formData, config));
+}
+
+export const getJar = (): CookieJar => jar;

package/src/utils/clients.ts

@@ -0,0 +1,125 @@
+import { makeParsable, log, warn } from "./constants";
+
+function formatCookie(arr: any[], url: string): string {
+  return arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + url + ".com";
+}
+
+export function parseAndCheckLogin(ctx: any, http: any, retryCount: number = 0): (data: any) => Promise<any> {
+  const delay = (ms: number): Promise<void> => new Promise<any>((resolve) => setTimeout(resolve, ms));
+
+  return async (data: any): Promise<any> => {
+    if (data.statusCode >= 500 && data.statusCode < 600) {
+      if (retryCount >= 5) {
+        const err: any = new Error("Request retry failed.");
+        err.statusCode = data.statusCode;
+        err.res = data.body;
+        throw err;
+      }
+
+      retryCount++;
+      const retryTime = Math.floor(Math.random() * 5000);
+      const url = data.request.uri.protocol + "//" + data.request.uri.hostname + data.request.uri.pathname;
+
+      await delay(retryTime);
+
+      if (data.request.headers["content-type"].split(";")[0] === "multipart/form-data") {
+        const newData = await http.postFormData(url, ctx.jar, data.request.formData, data.request.qs, ctx.globalOptions, ctx);
+        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      } else {
+        const newData = await http.post(url, ctx.jar, data.request.form, ctx.globalOptions, ctx);
+        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      }
+    }
+
+    if (data.statusCode === 404) return;
+
+    if (data.statusCode !== 200) {
+      throw new Error("parseAndCheckLogin got status code: " + data.statusCode);
+    }
+
+    let res: any = null;
+
+    if (typeof data.body === "object" && data.body !== null) {
+      res = data.body;
+    } else if (typeof data.body === "string") {
+      try {
+        res = JSON.parse(makeParsable(data.body) as string);
+      } catch (e) {
+        const err: any = new Error("JSON.parse error.");
+        err.detail = e;
+        err.res = data.body;
+        throw err;
+      }
+    } else {
+      throw new Error("Unknown response body type: " + typeof data.body);
+    }
+
+    if (res.redirect && data.request.method === "GET") {
+      const redirectRes = await http.get(res.redirect, ctx.jar);
+      return await parseAndCheckLogin(ctx, http)(redirectRes);
+    }
+
+    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_", "");
+      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: any = new Error("Facebook blocked the login");
+      err.error = "Not logged in.";
+      throw err;
+    }
+
+    return res;
+  };
+}
+
+export function saveCookies(jar: any): (res: any) => any {
+  return function (res: any): any {
+    const cookies = res.headers["set-cookie"] || [];
+    cookies.forEach(function (c: string) {
+      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;
+  };
+}
+
+export function getAccessFromBusiness(jar: any, Options: any): (res: any) => Promise<[string | null, string | null]> {
+  return async function (res: any): Promise<[string | null, string | null]> {
+    const html = res ? res.body : null;
+    const { get } = require("./axios");
+    try {
+      const businessRes = await get("https://business.facebook.com/content_management", jar, null, Options, null, { noRef: true });
+      const match = /"accessToken":"([^.]+)","clientID":/g.exec(businessRes.body);
+      const token = match ? match[1] : null;
+      return [html, token];
+    } catch (e) {
+      return [html, null];
+    }
+  };
+}
+
+export function getAppState(jar: any): any[] {
+  return jar
+    .getCookiesSync("https://www.facebook.com")
+    .concat(jar.getCookiesSync("https://www.messenger.com"));
+}

package/src/utils/constants.ts

@@ -0,0 +1,281 @@
+const chalk = require('chalk');
+const gradient = require('gradient-string');
+const echaceb = gradient(['#0061ff', '#681297']);
+const ws = echaceb('bb-fca');
+
+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');
+})();
+
+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 getRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function padZeros(val, len = 2) {
+  val = String(val);
+  while (val.length < len) val = '0' + val;
+  return val;
+}
+
+function generateThreadingID(clientID) {
+  const k = Date.now();
+  const l = Math.floor(Math.random() * 4294967295);
+  const m = clientID;
+  return '<' + k + ':' + l + '-' + m + '@mail.projektitan.com>';
+}
+
+function binaryToDecimal(data) {
+  let ret = '';
+  while (data !== '0') {
+    let end = 0;
+    let fullName = '';
+    let i = 0;
+    for (; 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;
+    data = fullName.slice(fullName.indexOf('1'));
+  }
+  return ret;
+}
+
+function generateOfflineThreadingID() {
+  const ret = Date.now();
+  const value = Math.floor(Math.random() * 4294967295);
+  const str = ('0000000000000000000000' + value.toString(2)).slice(-22);
+  const msgs = ret.toString(2) + str;
+  return binaryToDecimal(msgs);
+}
+
+function presenceEncode(str) {
+  return encodeURIComponent(str)
+    .replace(/([_A-Z])|%../g, function(m, n) {
+      return n ? '%' + n.charCodeAt(0).toString(16) : m;
+    })
+    .toLowerCase()
+    .replace(h, function(m) {
+      return i[m];
+    });
+}
+
+function presenceDecode(str) {
+  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: parseInt(String(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,
+    }),
+  );
+}
+
+function getGUID() {
+  let sectionLength = Date.now();
+  const id = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(
+    c,
+  ) {
+    const r = Math.floor((sectionLength + Math.random() * 16) % 16);
+    sectionLength = Math.floor(sectionLength / 16);
+    const _guid = (c == 'x' ? r : (r & 7) | 8).toString(16);
+    return _guid;
+  });
+  return id;
+}
+
+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,
+    function(v) {
+      return v.name;
+    },
+    function(v) {
+      return 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 getType(obj) {
+  return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+// Logs
+let logging = true;
+function logOptions(bool) {
+  logging = bool;
+}
+function log(...args) {
+  if (logging === false) return;
+  console.log(ws, chalk.green.bold('[LOG]'), ...args);
+}
+function error(...args) {
+  if (logging === false) return;
+  console.error(ws, chalk.red.bold('[ERROR]'), ...args);
+}
+function warn(...args) {
+  if (logging === false) return;
+  console.warn(ws, chalk.yellow.bold('[WARNING]'), ...args);
+}
+
+export {
+  NUM_TO_DAY,
+  NUM_TO_MONTH,
+  arrToForm,
+  arrayToObject,
+  binaryToDecimal,
+  error,
+  generateAccessiblityCookie,
+  generateOfflineThreadingID,
+  generatePresence,
+  generateThreadingID,
+  generateTimestampRelative,
+  getFrom,
+  getGUID,
+  getRandom,
+  getSignatureID,
+  getType,
+  log,
+  logOptions,
+  makeParsable,
+  padZeros,
+  presenceDecode,
+  presenceEncode,
+  warn,
+};

package/src/utils/formatters/data/formatAttachment.ts

@@ -0,0 +1,58 @@
+import * as url from "url";
+import * as querystring from "querystring";
+import { getType } from "../../constants";
+
+function getExtension(original_extension: string | null, fullFileName: string = ""): string {
+  if (original_extension) {
+    return original_extension;
+  } else {
+    const extension = fullFileName.split(".").pop();
+    return extension === fullFileName ? "" : extension || "";
+  }
+}
+
+export function _formatAttachment(attachment1: any, attachment2?: any): any {
+  const blob_attachment = attachment1.mercury || attachment1.blob_attachment || attachment1.sticker_attachment;
+  let type_attachment = blob_attachment && blob_attachment.__typename ? blob_attachment.__typename : attachment1.attach_type;
+
+  if (type_attachment == null && attachment1.id != null && attachment1.extensible_attachment == null) {
+    return { type: "share", ID: attachment1.id, url: attachment1.href, title: "Shared Content", description: "Unsupported shared content.", source: null, isUnrecognized: true };
+  }
+
+  if (!attachment1.attach_type && attachment1.imageMetadata) {
+    return { type: "photo", ID: attachment1.fbid, filename: attachment1.filename, fileSize: Number(attachment1.fileSize || 0), mimeType: attachment1.mimeType, width: attachment1.imageMetadata.width, height: attachment1.imageMetadata.height, url: null, thumbnailUrl: null, previewUrl: null, largePreviewUrl: null, name: attachment1.filename };
+  }
+
+  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 "MessageImage": return { 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, width: blob.original_dimensions.x, height: blob.original_dimensions.y, name: blob.filename };
+    case "MessageAnimatedImage": return { type: "animated_image", ID: blob.legacy_attachment_id, name: 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, facebookUrl: blob.animated_image.uri };
+    case "MessageVideo": return { type: "video", ID: blob.legacy_attachment_id, filename: blob.filename, duration: blob.playable_duration_in_ms, thumbnailUrl: blob.large_image.uri, 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() };
+    case "MessageFile": return { type: "file", ID: blob.message_file_fbid, filename: blob.filename, url: blob.url, isMalicious: blob.is_malicious, contentType: blob.content_type, name: blob.filename };
+    case "MessageAudio": return { type: "audio", ID: blob.url_shimhash, filename: blob.filename, duration: blob.playable_duration_in_ms, audioType: blob.audio_type, url: blob.playable_url, isVoiceMail: blob.is_voicemail };
+    case "Sticker": case "StickerAttachment": return { type: "sticker", ID: blob.id, url: blob.url, packID: blob.pack?.id, 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 };
+    case "ExtensibleAttachment": { const story = blob.story_attachment; return { type: "share", ID: blob.legacy_attachment_id, url: story.url, title: story.title_with_entities.text, description: story.description?.text, source: story.source?.text, image: story.media?.image?.uri, width: story.media?.image?.width, height: story.media?.image?.height, playable: story.media?.is_playable, duration: story.media?.playable_duration_in_ms, playableUrl: story.media?.playable_url, subattachments: story.subattachments, properties: story.properties.reduce((obj: any, cur: any) => ({ ...obj, [cur.key]: cur.value.text }), {}) }; }
+    default: return { type: "unknown", error: `Unrecognized attachment type: ${type}` };
+  }
+}
+
+export function formatAttachment(attachments: any[], attachmentIds?: any[], attachmentMap?: any, shareMap?: any): any[] {
+  attachmentMap = shareMap || attachmentMap;
+  return attachments ? attachments.map((val, i) => { if (!attachmentMap || !attachmentIds || !attachmentMap[attachmentIds[i]]) { return _formatAttachment(val); } return _formatAttachment(val, attachmentMap[attachmentIds[i]]); }) : [];
+}

package/src/utils/formatters/data/formatDelta.ts

@@ -0,0 +1,45 @@
+import formatID from "../value/formatID";
+import { _formatAttachment } from "./formatAttachment";
+
+export function getAdminTextMessageType(type: string): string {
+  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;
+  }
+}
+
+export function formatDeltaMessage(m: any): any {
+  const md = m.delta.messageMetadata;
+  const mdata = m.delta.data?.prng ? JSON.parse(m.delta.data.prng) : [];
+  const mentions: Record<string, string> = {};
+  for (const mention of mdata) {
+    mentions[mention.i] = m.delta.body.substring(mention.o, mention.o + mention.l);
+  }
+  const messageReply = m.delta.messageReply ? { messageID: m.delta.messageReply.messageID, senderID: formatID(m.delta.messageReply.senderID), body: m.delta.messageReply.body, attachments: m.delta.messageReply.attachments, timestamp: m.delta.messageReply.timestamp, isReply: true } : null;
+  return { type: "message", senderID: formatID(md.actorFbId.toString()), body: m.delta.body || "", threadID: formatID((md.threadKey.threadFbId || md.threadKey.otherUserFbId).toString()), messageID: md.messageId, offlineThreadingId: md.offlineThreadingId, attachments: (m.delta.attachments || []).map((v: any) => _formatAttachment(v)), mentions, timestamp: md.timestamp, isGroup: !!md.threadKey.threadFbId, participantIDs: m.delta.participants, messageReply };
+}
+
+export function formatDeltaEvent(m: any): any {
+  let logMessageType: string;
+  let logMessageData: any;
+  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;
+    default: logMessageType = m.class; logMessageData = m;
+  }
+  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 };
+}
+
+export function formatDeltaReadReceipt(delta: any): any {
+  return { reader: (delta.threadKey.otherUserFbId || delta.actorFbId).toString(), time: delta.actionTimestampMs, threadID: formatID((delta.threadKey.otherUserFbId || delta.threadKey.threadFbId).toString()), type: "read_receipt" };
+}