Upload 3 files

includes/login/DOCS.md

@@ -0,0 +1,1948 @@
+# Documentation
+### You can use callback or .then() .catch() or async/await
+
+* [`login(credentials, options, [callback])`](#logincredentials-options-callback) ⇒ <code>Promise</code>
+* [`api.addExternalModule(moduleObj)`](#apiaddexternalmodulemoduleobj)
+* [`api.addUserToGroup(userID, threadID, [callback])`](#apiaddusertogroupuserid-threadid-callback) ⇒ <code>Promise</code>
+* [`api.changeAdminStatus(threadID, adminIDs, adminStatus, [callback])`](#apichangeadminstatusthreadid-adminids-adminstatus-callback) ⇒ <code>Promise</code>
+* [`api.changeArchivedStatus(threadOrThreads, archive, [callback])`](#apichangearchivedstatusthreadorthreads-archive-callback) ⇒ <code>Promise</code>
+* [`api.changeBlockedStatus(userID, block, [callback])`](#apichangeblockedstatususerid-block-callback) ⇒ <code>Promise</code>
+* [`api.changeGroupImage(image, threadID, [callback])`](#apichangegroupimageimage-threadid-callback) ⇒ <code>Promise</code>
+* [`api.changeNickname(nickname, threadID, participantID, [callback])`](#apichangenicknamenickname-threadid-participantid-callback) ⇒ <code>Promise</code>
+* [`api.changeThreadColor(color, threadID, [callback])`](#apichangethreadcolorcolor-threadid-callback) ⇒ <code>Promise</code>
+* [`api.changeThreadEmoji(emoji, threadID, [callback])`](#apichangethreademojiemoji-threadid-callback) ⇒ <code>Promise</code>
+* [`api.createNewGroup(participantIDs, groupTitle, [callback])`](#apicreatenewgroupparticipantids-grouptitle-callback) ⇒ <code>Promise</code>
+* [`api.createPoll(title, threadID, options, [callback]) (*temporary deprecated because Facebook is updating this feature*)`](#apicreatepolltitle-threadid-options-callback-temporary-deprecated-because-facebook-is-updating-this-feature) ⇒ <code>Promise</code>
+* [`api.deleteMessage(messageOrMessages, [callback])`](#apideletemessagemessageormessages-callback) ⇒ <code>Promise</code>
+* [`api.deleteThread(threadOrThreads, [callback])`](#apideletethreadthreadorthreads-callback) ⇒ <code>Promise</code>
+* [`api.forwardAttachment(attachmentID, userOrUsers, [callback])`](#apiforwardattachmentattachmentid-userorusers-callback) ⇒ <code>Promise</code>
+* [`api.getAppState()`](#apigetappstate) ⇒ <code>Array</code>
+* [`api.getCurrentUserID()`](#apigetcurrentuserid) ⇒ <code>string</code>
+* [`api.getEmojiUrl(c, size, pixelRatio)`](#apigetemojiurlc-size-pixelratio) ⇒ <code>string</code>
+* [`api.getFriendsList([callback])`](#apigetfriendslistcallback) ⇒ <code>Promise</code>
+* [`api.getMessage(threadID, messageID, [callback])`](#apigetmessagethreadid-messageid-callback) ⇒ <code>Promise</code>
+* [`api.getThreadHistory(threadID, amount, timestamp, [callback])`](#apigetthreadhistorythreadid-amount-timestamp-callback) ⇒ <code>Promise</code>
+* [`api.getThreadInfo(threadIDs, [callback])`](#apigetthreadinfothreadids-callback) ⇒ <code>Promise</code>
+* [`api.getThreadList(limit, timestamp, tags, [callback])`](#apigetthreadlistlimit-timestamp-tags-callback) ⇒ <code>Promise</code>
+* [`api.getThreadPictures(threadID, offset, limit, [callback])`](#apigetthreadpicturesthreadid-offset-limit-callback) ⇒ <code>Promise</code>
+* [`api.getUserID(name, [callback])`](#apigetuseridname-callback) ⇒ <code>Promise</code>
+* [`api.getUserInfo(ids, [callback])`](#apigetuserinfoids-callback) ⇒ <code>Promise</code>
+* [`api.handleMessageRequest(threadID, accept, [callback])`](#apihandlemessagerequestthreadid-accept-callback) ⇒ <code>Promise</code>
+* [`api.httpGet(url, form, [customHeader], [callback], [notAPI])`](#apihttpgeturl-form-customheader-callback-notapi) ⇒ <code>Promise</code>
+* [`api.httpPost(url, form, [customHeader], [callback], [notAPI])`](#apihttpposturl-form-customheader-callback-notapi) ⇒ <code>Promise</code>
+* [`api.httpPostFormData(url, form, [customHeader], [callback], [notAPI])`](#apihttppostformdataurl-form-customheader-callback-notapi) ⇒ <code>Promise</code>
+* [~~`api.listen([callback])`~~](#apilistencallback) ⇒ <code>Promise</code>
+* [`api.listenMqtt([callback])`](#apilistenmqttcallback) ⇒ <code>Promise</code>
+* [`api.logout([callback])`](#apilogoutcallback) ⇒ <code>Promise</code>
+* [`api.markAsDelivered(threadID, messageID, [callback]`](#apimarkasdeliveredthreadid-messageid-callback) ⇒ <code>Promise</code>
+* [`api.markAsRead(threadID, [read, [callback]])`](#apimarkasreadthreadid-read-callback) ⇒ <code>Promise</code>
+* [`api.markAsReadAll([callback])`](#apimarkasreadallcallback) ⇒ <code>Promise</code>
+* [`api.markAsSeen([seenTimestamp], [callback])`](#apimarkasseenseentimestamp-callback) ⇒ <code>Promise</code>
+* [`api.muteThread(threadID, muteSeconds, [callback])`](#apimutethreadthreadid-muteseconds-callback) ⇒ <code>Promise</code>
+* [`api.removeUserFromGroup(userID, threadID, [callback])`](#apiremoveuserfromgroupuserid-threadid-callback) ⇒ <code>Promise</code>
+* [`api.resolvePhotoUrl(photoID, [callback])`](#apiresolvephotourlphotoid-callback) ⇒ <code>Promise</code>
+* [`api.searchForThread(name, [callback])`](#apisearchforthreadname-callback)
+* [`api.sendMessage(message, threadID, [callback], messageID)`](#apisendmessagemessage-threadid-callback-messageid) ⇒ <code>Promise</code>
+* [`api.sendTypingIndicator(threadID, [callback])`](#apisendtypingindicatorthreadid-callback) ⇒ <code>Promise</code>
+* [`api.setMessageReaction(reaction, messageID, [callback], [forceCustomReaction])`](#apisetmessagereactionreaction-messageid-callback-forcecustomreaction) ⇒ <code>Promise</code>
+* [`api.setOptions(options)`](#apisetoptionsoptions) ⇒ <code>Promise</code>
+* [`api.setPostReaction(postID, type, [callback])`](#apisetpostreactionpostid-type-callback) ⇒ <code>Promise</code>
+* [`api.setTitle(newTitle, threadID, [callback])`](#apisettitlenewtitle-threadid-callback) ⇒ <code>Promise</code>
+* [`api.threadColors`](#apithreadcolors) ⇒ <code>Object</code>
+* [`api.unsendMessage(messageID, [callback])`](#apiunsendmessagemessageid-callback) ⇒ <code>Promise</code>
+* [`api.uploadAttachment(attachments, [callback])`](#apiuploadattachmentattachments-callback) ⇒ <code>Promise</code>
+
+---------------------------------------
+
+### Password safety
+
+**Read this** before you _copy+paste_ examples from below.
+
+You should not store Facebook password in your scripts.
+There are few good reasons:
+* People who are standing behind you may look at your "code" and get your password if it is on the screen
+* Backups of source files may be readable by someone else. "_There is nothing secret in my code, why should I ever password protect my backups_"
+* You can't push your code to Github (or any onther service) without removing your password from the file.  Remember: Even if you undo your accidential commit with password, Git doesn't delete it, that commit is just not used but is still readable by everybody.
+* If you change your password in the future (maybe it leaked because _someone_ stored password in source file… oh… well…) you will have to change every occurrence in your scripts
+
+Preferred method is to have `login.js` that saves `AppState` to a file and then use that file from all your scripts.
+This way you can put password in your code for a minute, login to facebook and then remove it.
+
+If you want to be even more safe:  _login.js_ can get password with `require("readline")` or with environment variables like this:
+```js
+var credentials = {
+    email: process.env.FB_EMAIL,
+    password: process.env.FB_PASSWORD
+}
+```
+```bash
+FB_EMAIL="john.doe@example.com"
+FB_PASSWORD="MySuperHardP@ssw0rd"
+nodejs login.js
+```
+
+---------------------------------------
+
+<a name="login"></a>
+### login(credentials, options, [callback])
+
+This function is returned by `require(...)` and is the main entry point to the API.
+
+It allows the user to log into facebook given the right credentials.
+
+Return a Promise that will resolve if logged in successfully, or reject if failed to login. (will not resolve or reject if callback is supplied!)
+
+If `callback` is supplied:
+
+* `callback` will be called with a `null` object (for potential errors) and with an object containing all the available functions if logged in successfully.
+
+* `callback` will be called with an error object if failed to login.
+
+If `login-approval` error was thrown: Inside error object is `continue` function, you can call that function with 2FA code. The behaviour of this function depends on how you call `login` with:
+
+* If `callback` is not supplied (using `Promise`), this function will return a `Promise` that behaves like `Promise` received from `login`.
+
+* If `callback` is supplied, this function will still return a `Promise`, but it will not resolve. Instead, the result is called to `callback`.
+
+__Arguments__
+
+* `credentials`: An object containing the fields `email` and `password` used to login, __*or*__ an object containing the field `appState`.
+* `options`: An object representing options to use when logging in (as described in [api.setOptions](#setOptions)).
+* `callback(err, api)`: A callback called when login is done (successful or not). `err` is an object containing a field `error`.
+---
+
+<h1><b>Now login with account and password is no longer available, <a href="#loginWithAppstate">use appState</a> login instead.</b></h1>
+
+
+~~__Example (Email & Password)__: (it is no longer usable, please use [this](#loginWithAppstate) alternative method)~~
+
+```js
+const login = require("fb-chat-api-temp");
+
+login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
+    if(err) return console.error(err);
+    // Here you can use the api
+});
+```
+
+~~__Example (Email & Password then save appState to file)__: (it is no longer usable, please use [this](#loginWithAppstate) alternative method)~~
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
+    if(err) return console.error(err);
+
+    fs.writeFileSync('appstate.json', JSON.stringify(api.getAppState()));
+});
+```
+
+
+~~__Login Approvals (2-Factor Auth)__: When you try to login with Login Approvals enabled, your callback will be called with an error `'login-approval'` that has a `continue` function that accepts the approval code as a `string` or a `number`. (it is no longer usable, please use [this](#loginWithAppstate) alternative method)~~
+
+__Example__:
+
+```js
+const login = require("fb-chat-api-temp");
+const readline = require("readline");
+
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const obj = {email: "FB_EMAIL", password: "FB_PASSWORD"};
+login(obj, (err, api) => {
+    if(err) {
+        switch (err.error) {
+            case 'login-approval':
+                console.log('Enter code > ');
+                rl.on('line', (line) => {
+                    err.continue(line);
+                    rl.close();
+                });
+                break;
+            default:
+                console.error(err);
+        }
+        return;
+    }
+
+    // Logged in!
+});
+```
+
+__Review Recent Login__: Sometimes Facebook will ask you to review your recent logins. This means you've recently logged in from a unrecognized location. This will will result in the callback being called with an error `'review-recent-login'` by default. If you wish to automatically approve all recent logins, you can set the option `forceLogin` to `true` in the `loginOptions`.
+
+
+
+<a name="loginWithAppstate"></a>
+#### __Example (AppState loaded from file)__: You can get fbstate using [this](https://github.com/ntkhang03/c3c-fbstate) extension
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+    // Here you can use the api
+});
+```
+
+
+---------------------------------------
+
+<a name="apiaddexternalmodulemoduleobj"></a>
+### api.addExternalModule(moduleObj)
+
+This function is used to add external modules to the api object, each module is a function that takes 3 arguments: `defaultFuncs`, `api`, `ctx` and returns a function that will be added to the api object.
+
+Example:
+```js
+api.addExternalModule({
+	"example": function(defaultFuncs, api, ctx) {
+		return function () {
+			console.log("globalOptions", ctx.globalOptions);
+		};
+	}
+});
+```
+
+---------------------------------------
+
+<a name="addUserToGroup"></a>
+### api.addUserToGroup(userID, threadID, [callback])
+
+Adds a user (or array of users) to a group chat.
+
+__Arguments__
+
+* `userID`: User ID or array of user IDs.
+* `threadID`: Group chat ID.
+* `callback(err)`: A callback called when the query is done (either with an error or with no arguments).
+
+__Example__
+
+```js
+api.addUserToGroup("1234567890", "0987654321", (err) => {
+	if(err)
+		return console.error(err);
+	console.log("Added user to group.");
+});
+```
+
+---------------------------------------
+
+<a name="changeAdminStatus"></a>
+### api.changeAdminStatus(threadID, adminIDs, adminStatus, [callback])
+
+Given a adminID, or an array of adminIDs, will set the admin status of the user(s) to `adminStatus`.
+
+__Arguments__
+* `threadID`: ID of a group chat (can't use in one-to-one conversations)
+* `adminIDs`: The id(s) of users you wish to admin/unadmin (string or an array).
+* `adminStatus`: Boolean indicating whether the user(s) should be promoted to admin (`true`) or demoted to a regular user (`false`).
+* `callback(err)`: A callback called when the query is done (either with an error or null).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if (err) return console.error(err);
+
+    let threadID = "0000000000000000";
+    let newAdmins = ["111111111111111", "222222222222222"];
+    api.changeAdminStatus(threadID, newAdmins, true, editAdminsCallback);
+
+    let adminToRemove = "333333333333333";
+    api.changeAdminStatus(threadID, adminToRemove, false, editAdminsCallback);
+
+});
+
+function editAdminsCallback(err) {
+    if (err) return console.error(err);
+}
+
+```
+
+---------------------------------------
+
+<a name="changeArchivedStatus"></a>
+### api.changeArchivedStatus(threadOrThreads, archive, [callback])
+
+Given a threadID, or an array of threadIDs, will set the archive status of the threads to `archive`. Archiving a thread will hide it from the logged-in user's inbox until the next time a message is sent or received.
+
+__Arguments__
+* `threadOrThreads`: The id(s) of the threads you wish to archive/unarchive.
+* `archive`: Boolean indicating the new archive status to assign to the thread(s).
+* `callback(err)`: A callback called when the query is done (either with an error or null).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.changeArchivedStatus("000000000000000", true, (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="changeBlockedStatus"></a>
+### api.changeBlockedStatus(userID, block, [callback])
+
+Prevents a user from privately contacting you. (Messages in a group chat will still be seen by both parties).
+
+__Arguments__
+
+* `userID`: User ID.
+* `block`: Boolean indicating whether to block or unblock the user (true for block).
+* `callback(err)`: A callback called when the query is done (either with an error or with no arguments).
+
+---------------------------------------
+
+<a name="changeGroupImage"></a>
+### api.changeGroupImage(image, threadID, [callback])
+
+Will change the group chat's image to the given image.
+
+__Arguments__
+* `image`: File stream of image.
+* `threadID`: String representing the ID of the thread.
+* `callback(err)`: A callback called when the change is done (either with an error or null).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.changeGroupImage(fs.createReadStream("./avatar.png"), "000000000000000", (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="changeNickname"></a>
+### api.changeNickname(nickname, threadID, participantID, [callback])
+
+Will change the thread user nickname to the one provided.
+
+__Arguments__
+* `nickname`: String containing a nickname. Leave empty to reset nickname.
+* `threadID`: String representing the ID of the thread.
+* `participantID`: String representing the ID of the user.
+* `callback(err)`: An optional callback called when the change is done (either with an error or null).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.changeNickname("Example", "000000000000000", "000000000000000", (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="changeThreadColor"></a>
+### api.changeThreadColor(color, threadID, [callback])
+
+Will change the thread color to the given hex string color ("#0000ff"). Set it
+to empty string if you want the default.
+
+Note: the color needs to start with a "#".
+
+__Arguments__
+* `color`: String representing a theme ID (a list of theme ID can be found at `api.threadColors`).
+* `threadID`: String representing the ID of the thread.
+* `callback(err)`: A callback called when the change is done (either with an error or null).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.changeThreadColor("#0000ff", "000000000000000", (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="changeThreadEmoji"></a>
+### api.changeThreadEmoji(emoji, threadID, [callback])
+
+Will change the thread emoji to the one provided.
+
+Note: The UI doesn't play nice with all emoji.
+
+__Arguments__
+* `emoji`: String containing a single emoji character.
+* `threadID`: String representing the ID of the thread.
+* `callback(err)`: A callback called when the change is done (either with an error or null).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.changeThreadEmoji("💯", "000000000000000", (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="createNewGroup"></a>
+### api.createNewGroup(participantIDs, groupTitle, [callback])
+
+Create a new group chat.
+
+__Arguments__
+* `participantIDs`: An array containing participant IDs. (*Length must be >= 2*)
+* `groupTitle`: The title of the new group chat.
+* `callback(err, threadID)`: A callback called when created.
+
+---------------------------------------
+
+<a name="createPoll"></a>
+### api.createPoll(title, threadID, options, [callback]) (*temporary deprecated because Facebook is updating this feature*)
+
+Creates a poll with the specified title and optional poll options, which can also be initially selected by the logged-in user.
+
+__Arguments__
+* `title`: String containing a title for the poll.
+* `threadID`: String representing the ID of the thread.
+* `options`: An optional `string : bool` dictionary to specify initial poll options and their initial states (selected/not selected), respectively.
+* `callback(err)`: An optional callback called when the poll is posted (either with an error or null) - can omit the `options` parameter and use this as the third parameter if desired.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.createPoll("Example Poll", "000000000000000", {
+        "Option 1": false,
+        "Option 2": true
+    }, (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="deleteMessage"></a>
+### api.deleteMessage(messageOrMessages, [callback])
+
+Takes a messageID or an array of messageIDs and deletes the corresponding message.
+
+__Arguments__
+* `messageOrMessages`: A messageID string or messageID string array
+* `callback(err)`: A callback called when the query is done (either with an error or null).
+
+__Example__
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.listen((err, message) => {
+        if(message.body) {
+            api.sendMessage(message.body, message.threadID, (err, messageInfo) => {
+                if(err) return console.error(err);
+
+                api.deleteMessage(messageInfo.messageID);
+            });
+        }
+    });
+});
+```
+
+---------------------------------------
+
+<a name="deleteThread"></a>
+### api.deleteThread(threadOrThreads, [callback])
+
+Given a threadID, or an array of threadIDs, will delete the threads from your account. Note that this does *not* remove the messages from Facebook's servers - anyone who hasn't deleted the thread can still view all of the messages.
+
+__Arguments__
+
+* `threadOrThreads` - The id(s) of the threads you wish to remove from your account.
+* `callback(err)` - A callback called when the operation is done, maybe with an object representing an error.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.deleteThread("000000000000000", (err) => {
+        if(err) return console.error(err);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="forwardAttachment"></a>
+### api.forwardAttachment(attachmentID, userOrUsers, [callback])
+
+Forwards corresponding attachment to given userID or to every user from an array of userIDs
+
+__Arguments__
+* `attachmentID`: The ID field in the attachment object. Recorded audio cannot be forwarded.
+* `userOrUsers`: A userID string or usersID string array
+* `callback(err)`: A callback called when the query is done (either with an error or null).
+
+---------------------------------------
+
+<a name="getAppState"></a>
+### api.getAppState()
+
+Returns current appState which can be saved to a file or stored in a variable.
+
+---------------------------------------
+
+<a name="getCurrentUserID"></a>
+### api.getCurrentUserID()
+
+Returns the currently logged-in user's Facebook user ID.
+
+---------------------------------------
+
+<a name="getEmojiUrl"></a>
+### api.getEmojiUrl(c, size, pixelRatio)
+
+Returns the URL to a Facebook Messenger-style emoji image asset.
+
+__note__: This function will return a URL regardless of whether the image at the URL actually exists.
+This can happen if, for example, Messenger does not have an image asset for the requested emoji.
+
+__Arguments__
+
+* `c` - The emoji character
+* `size` - The width and height of the emoji image; supported sizes are 32, 64, and 128
+* `pixelRatio` - The pixel ratio of the emoji image; supported ratios are '1.0' and '1.5' (default is '1.0')
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    // Prints https://static.xx.fbcdn.net/images/emoji.php/v8/z9c/1.0/128/1f40d.png
+    console.log('Snake emoji, 128px (128x128 with pixel ratio of 1.0');
+    console.log(api.getEmojiUrl('\ud83d\udc0d', 128));
+
+    // Prints https://static.xx.fbcdn.net/images/emoji.php/v8/ze1/1.5/128/1f40d.png
+    console.log('Snake emoji, 192px (128x128 with pixel ratio of 1.5');
+    console.log(api.getEmojiUrl('\ud83d\udc0d', 128, '1.5'));
+});
+```
+
+---------------------------------------
+
+<a name="getFriendsList"></a>
+### api.getFriendsList([callback])
+
+Returns an array of objects with some information about your friends.
+
+__Arguments__
+
+* `callback(err, arr)` - A callback called when the query is done (either with an error or with an confirmation object). `arr` is an array of objects with the following fields: `alternateName`, `firstName`, `gender`, `userID`, `isFriend`, `fullName`, `profilePicture`, `type`, `profileUrl`, `vanity`, `isBirthday`.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.getFriendsList((err, data) => {
+        if(err) return console.error(err);
+
+        console.log(data.length);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="getMessage"></a>
+### api.getMessage(threadID, messageID, [callback])
+
+Returns message data from messageID
+
+__Arguments__
+
+* `threadID`: The ID of the thread you want to get the message from.
+* `messageID`: The ID of the message you want to get.
+* `callback(err, data)` - A callback called when the query is done.
+
+---------------------------------------
+<a name="getThreadHistory"></a>
+### api.getThreadHistory(threadID, amount, timestamp, [callback])
+
+Takes a threadID, number of messages, a timestamp, and a callback.
+
+__note__: if you're getting a 500 error, it's possible that you're requesting too many messages. Try reducing that number and see if that works.
+
+__Arguments__
+* `threadID`: A threadID corresponding to the target chat
+* `amount`: The amount of messages to *request*
+* `timestamp`: Used to described the time of the most recent message to load. If timestamp is `undefined`, facebook will load the most recent messages.
+* `callback(error, history)`: If error is null, history will contain an array of message objects.
+
+__Example__
+
+To load 50 messages at a time, we can use `undefined` as the timestamp to retrieve the most recent messages and use the timestamp of the earliest message to load the next 50.
+
+```js
+var timestamp = undefined;
+
+function loadNextThreadHistory(api){
+    api.getThreadHistory(threadID, 50, timestamp, (err, history) => {
+        if(err) return console.error(err);
+
+        /*
+            Since the timestamp is from a previous loaded message,
+            that message will be included in this history so we can discard it unless it is the first load.
+        */
+        if(timestamp != undefined) history.pop();
+
+        /*
+            Handle message history
+        */
+
+        timestamp = history[0].timestamp;
+    });
+}
+```
+
+---------------------------------------
+
+<a name="getThreadInfo"></a>
+### api.getThreadInfo(threadIDs, [callback])
+
+Takes a threadID and a callback.  Works for both single-user and group threads.
+
+__Arguments__
+* `threadIDs`: Either a string/number for one ID or an array of strings/numbers for a batched query.
+* `callback(err, info)`: If `err` is `null`, `info` will return
+<!-- * in nghiêng chữ -->
+*if `threadIDs` is an array of IDs, `info` will be an array of objects with the following fields:*
+```js
+{
+	"4000000000000000": {
+		threadID: "4000000000000000",
+		threadName: "Thread Name",
+		// ...
+		// thread info
+	},
+	"5000000000000000": {
+		threadID: "5000000000000000",
+		threadName: "Thread Name",
+		// ...
+		// thread info
+	},
+	// ...
+}
+```
+
+*if `threadIDs` is a single ID, `info` will be an object with the following fields:*
+```js
+{
+	threadID: "4000000000000000",
+	threadName: "Thread Name",
+	// ...
+	// thread info
+}
+```
+
+`info` will contain the following fields:
+
+|        Key        |                                                                                                           Description                                                                                                            |
+| :---------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|     threadID      |                                                                                                         ID of the thread                                                                                                         |
+|  participantIDs   |                                                                                                 Array of user IDs in the thread                                                                                                  |
+|    threadName     |                                                   Name of the thread. Usually the name of the user. In group chats, this will be empty if the name of the group chat is unset.                                                   |
+|     userInfo      |                                     An array contains info of members, which has the same structure as [`getUserInfo`](#getUserInfo), but add a key `id`, contain ID of member currently at.                                     |
+|     nicknames     |                                Map of nicknames for members of the thread. If there are no nicknames set, this will be `null`. Can be of the form: <ul><li>`{'123456789': "nickname"}`</ul></li>                                 |
+|    unreadCount    |                                                                                                    Number of unread messages                                                                                                     |
+|   messageCount    |                                                                                                        Number of messages                                                                                                        |
+|     imageSrc      |                                                                                  URL to the group chat photo. `null` if unset or a 1-1 thread.                                                                                   |
+|     timestamp     |                                                                                                    Timestamp of last activity                                                                                                    |
+|     muteUntil     |                                     Timestamp at which the thread will no longer be muted. The timestamp will be -1 if the thread is muted indefinitely or null if the thread is not muted.                                      |
+|      isGroup      |                                                                            boolean, true if this thread is a group thread (more than 2 participants).                                                                            |
+|   isSubscribed    |                                                                                                                                                                                                                                  |
+|      folder       |                                                                    The folder that the thread is in. Can be one of: `INBOX`, `ARCHIVED`, `PENDING` or `OTHER`                                                                    |
+|    isArchived     |                                                                                           True if the thread is archived, false if not                                                                                           |
+| cannotReplyReason |                                                                If you cannot reply to this thread, this will be a string stating why. Otherwise it will be null.                                                                 |
+| lastReadTimestamp |                                                                           Timestamp of the last message that is marked as 'read' by the current user.                                                                            |
+|       emoji       |                                                                        Object with key 'emoji' whose value is the emoji unicode character. Null if unset.                                                                        |
+|       color       |                                                                                       String form of the custom color in hexadecimal form.                                                                                       |
+|     adminIDs      |                                                Array of user IDs of the admins of the thread. Empty array if unset. Can be of the form:<ul><li>`[{ id: '123456789' }]`</li></ul>                                                 |
+|   approvalMode    |                                                                       `true` or `false`, used to check if this group requires admin approval to add users                                                                        |
+|   approvalQueue   | Array of object that has the following keys: <ul><li>`inviterID`: ID of the user invited the person to the group</li><li>`requesterID`: ID of the person waiting to be approved</li><li>`timestamp`: Request timestamp</li></ul> |
+|    inviteLink     |                                       Invite link for the thread. <ul><li>`enable`: `true` if the invite link is enabled, `false` if it is disabled</li> <li>`link`: Invite link</li></ul>                                       |
+
+`accountType` is one of the following:
+- `"User"`
+- `"Page"`
+- `"UnavailableMessagingActor"`
+- `"ReducedMessagingActor"`
+
+---------------------------------------
+
+<a name="getThreadList"></a>
+### api.getThreadList(limit, timestamp, tags, [callback])
+
+Returns information about the user's threads.
+
+__Arguments__
+
+* `limit`: Limit the number of threads to fetch.
+* `timestamp`: Request threads *before* this date. `null` means *now*
+* `tags`: An array describing which folder to fetch. It should be one of these:
+  - `["INBOX"]` *(same as `[]`)*
+  - `["ARCHIVED"]`
+  - `["PENDING"]`
+  - `["OTHER"]`
+  - `["INBOX", "unread"]`
+  - `["ARCHIVED", "unread"]`
+  - `["PENDING", "unread"]`
+  - `["OTHER", "unread"]`
+
+*if you find something new, let us know*
+
+* `callback(err, list)`: Callback called when the query is done (either with an error or with a proper result). `list` is an *array* with objects with the following properties same structure as [`getThreadInfo`](#getThreadInfo)
+
+`accountType` is one of the following:
+- `"User"`
+- `"Page"`
+- `"UnavailableMessagingActor"`
+- `"ReducedMessagingActor"`
+
+(*there might be more*)
+
+<table>
+<tr>
+<th>Account type</th>
+<th>Key</th>
+<th>Description</th>
+</tr>
+<tr>
+<td rowspan="12"><code>"User"</code></td>
+<td>userID</td>
+<td>ID of user</td>
+</tr>
+<tr>
+<td>name</td>
+<td>Full name of user</td>
+</tr>
+<tr>
+<td>shortName</td>
+<td>Short name of user (most likely first name)</td>
+</tr>
+<tr>
+<td>gender</td>
+<td>Either
+<code>"MALE"</code>,
+<code>"FEMALE"</code>,
+<code>"NEUTER"</code> or
+<code>"UNKNOWN"</code>
+</td>
+</tr>
+<tr>
+<td>url</td>
+<td>URL of the user's Facebook profile</td>
+</tr>
+<tr>
+<td>profilePicture</td>
+<td>URL of the profile picture</td>
+</tr>
+<tr>
+<td>username</td>
+<td>Username of user or
+<code>null</code>
+</td>
+</tr>
+<tr>
+<td>isViewerFriend</td>
+<td>Is the user a friend of you?</td>
+</tr>
+<tr>
+<td>isMessengerUser</td>
+<td>Does the user use Messenger?</td>
+</tr>
+<tr>
+<td>isVerified</td>
+<td>Is the user verified? (Little blue tick mark)</td>
+</tr>
+<tr>
+<td>isMessageBlockedByViewer</td>
+<td>Is the user blocking messages from you?</td>
+</tr>
+<tr>
+<td>isViewerCoworker</td>
+<td>Is the user your coworker?
+</td>
+</tr>
+
+<tr>
+<td rowspan="10"><code>"Page"</code></td>
+<td>userID</td>
+<td>ID of the page</td>
+</tr>
+<tr>
+<td>name</td>
+<td>Name of the fanpage</td>
+</tr>
+<tr>
+<td>url</td>
+<td>URL of the fanpage</td>
+</tr>
+<tr>
+<td>profilePicture</td>
+<td>URL of the profile picture</td>
+</tr>
+<tr>
+<td>username</td>
+<td>Username of user or
+<code>null</code>
+</td>
+</tr>
+<tr>
+<td>acceptsMessengerUserFeedback</td>
+<td></td>
+</tr>
+<tr>
+<td>isMessengerUser</td>
+<td>Does the fanpage use Messenger?</td>
+</tr>
+<tr>
+<td>isVerified</td>
+<td>Is the fanpage verified? (Little blue tick mark)</td>
+</tr>
+<tr>
+<td>isMessengerPlatformBot</td>
+<td>Is the fanpage a bot</td>
+</tr>
+<tr>
+<td>isMessageBlockedByViewer</td>
+<td>Is the fanpage blocking messages from you?</td>
+</tr>
+
+<tr>
+<td rowspan="7"><code>"ReducedMessagingActor"</code><br />(account requres verification,<br />messages are hidden)</td>
+<td>userID</td>
+<td>ID of the user</td>
+</tr>
+<tr>
+<td>name</td>
+<td>Name of the user</td>
+</tr>
+<tr>
+<td>url</td>
+<td>
+<code>null</code>
+</td>
+</tr>
+<tr>
+<td>profilePicture</td>
+<td>URL of the default Facebook profile picture</td>
+</tr>
+<tr>
+<td>username</td>
+<td>Username of user</td>
+</td>
+</tr>
+<tr>
+<td>acceptsMessengerUserFeedback</td>
+<td></td>
+</tr>
+<tr>
+<td>isMessageBlockedByViewer</td>
+<td>Is the user blocking messages from you?</td>
+</tr>
+<tr>
+<td rowspan="7"><code>"UnavailableMessagingActor"</code><br />(account disabled/removed)</td>
+<td>userID</td>
+<td>ID of the user</td>
+</tr>
+<tr>
+<td>name</td>
+<td><em>Facebook User</em> in user's language</td>
+</tr>
+<tr>
+<td>url</td>
+<td><code>null</code></td>
+</tr>
+<tr>
+<td>profilePicture</td>
+<td>URL of the default **male** Facebook profile picture</td>
+</tr>
+<tr>
+<td>username</td>
+<td><code>null</code></td>
+</tr>
+<tr>
+<td>acceptsMessengerUserFeedback</td>
+<td></td>
+</tr>
+<tr>
+<td>isMessageBlockedByViewer</td>
+<td>Is the user blocking messages from you?</td>
+</tr>
+</table>
+
+
+In a case that some account type is not supported, we return just this *(but you can't rely on it)* and log a warning to the console:
+
+| Key         | Description           |
+| ----------- | --------------------- |
+| accountType | type, can be anything |
+| userID      | ID of the account     |
+| name        | Name of the account   |
+
+
+---------------------------------------
+
+<a name="getThreadPictures"></a>
+### api.getThreadPictures(threadID, offset, limit, [callback])
+
+Returns pictures sent in the thread.
+
+__Arguments__
+
+* `threadID`: A threadID corresponding to the target chat
+* `offset`: Start index of picture to retrieve, where 0 is the most recent picture
+* `limit`: Number of pictures to get, incrementing from the offset index
+* `callback(err, arr)`: A callback called when the query is done (either with an error or with an confirmation object). `arr` is an array of objects with `uri`, `width`, and `height`.
+
+---------------------------------------
+
+<a name="getUserID"></a>
+### api.getUserID(name, [callback])
+
+Given the full name or vanity name of a Facebook user, event, page, group or app, the call will perform a Facebook Graph search and return all corresponding IDs (order determined by Facebook).
+
+__Arguments__
+
+* `name` - A string being the name of the item you're looking for.
+* `callback(err, obj)` - A callback called when the search is done (either with an error or with the resulting object). `obj` is an array which contains all of the items that facebook graph search found, ordered by "importance".  Each item in the array has the following properties: `userID`,`photoUrl`,`indexRank`, `name`, `isVerified`, `profileUrl`, `category`, `score`, `type` (type is generally user, group, page, event or app).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.getUserID("Marc Zuckerbot", (err, data) => {
+        if(err) return console.error(err);
+
+        // Send the message to the best match (best by Facebook's criteria)
+        var msg = "Hello!"
+        var threadID = data[0].userID;
+        api.sendMessage(msg, threadID);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="getUserInfo"></a>
+### api.getUserInfo(ids, [callback])
+
+Will get some information about the given users.
+
+__Arguments__
+
+* `ids` - Either a string/number for one ID or an array of strings/numbers for a batched query.
+* `callback(err, obj)` - A callback called when the query is done (either with an error or with an confirmation object). `obj` is a mapping from userId to another object containing the following properties: 
+
+| Key           | Description                                                        |
+| ------------- | ------------------------------------------------------------------ |
+| name          | Name of the user                                                   |
+| firstName     | First name of the user                                             |
+| vanity        | the username of the user if any                                    |
+| thumbSrc      | URL of the profile picture                                         |
+| profileUrl    | URL of the profile                                                 |
+| gender        | the gender of the user, with 1 is Female, 2 is Male, 0 is unknown  |
+| type          | type is generally user, group, page, event or app                  |
+| isFriend      | is the user a friend of the current user, either `true` or `false` |
+| isBirthday    | is the user having a birthday today, either `true` or `false`      |
+| searchTokens  | an array of strings that can be used to search for the user        |
+| alternateName |                                                                    |
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.getUserInfo([1, 2, 3, 4], (err, ret) => {
+        if(err) return console.error(err);
+
+        for(var prop in ret) {
+            if(ret.hasOwnProperty(prop) && ret[prop].isBirthday) {
+                api.sendMessage("Happy birthday :)", prop);
+            }
+        }
+    });
+});
+```
+
+---------------------------------------
+
+<a name="threadColors"></a>
+### api.threadColors
+
+A dictionary mapping names of all currently valid thread themes to their theme ID that are accepted by [`api.changeThreadColor`](#changeThreadColor). These themes, listed below, are the ones present in the palette UI used for selecting thread themes on the Messenger client.
+<details>
+<summary><b>List of colors:</b></summary>
+<br>
+
+- MessengerBlue:   `196241301102133`
+- Viking:          `1928399724138152`
+- GoldenPoppy:     `174636906462322`
+- RadicalRed:      `2129984390566328`
+- Shocking:        `2058653964378557`
+- FreeSpeechGreen: `2136751179887052`
+- Pumpkin:         `175615189761153`
+- LightCoral:      `980963458735625`
+- MediumSlateBlue: `234137870477637`
+- DeepSkyBlue:     `2442142322678320`
+- BrilliantRose:   `169463077092846`
+- DefaultBlue:     `196241301102133`
+- HotPink:         `169463077092846`
+- AquaBlue:        `2442142322678320`
+- BrightPurple:    `234137870477637`
+- CoralPink:       `980963458735625`
+- Orange:          `175615189761153`
+- Green:           `2136751179887052`
+- LavenderPurple:  `2058653964378557`
+- Red:             `2129984390566328`
+- Yellow:          `174636906462322`
+- TealBlue:        `1928399724138152`
+- Aqua:            `417639218648241`
+- Mango:           `930060997172551`
+- Berry:           `164535220883264`
+- Citrus:          `370940413392601`
+- Candy:           `205488546921017`
+- Earth:           `1833559466821043`
+- Support:         `365557122117011`
+- Music:           `339021464972092`
+- Pride:           `1652456634878319`
+- DoctorStrange:   `538280997628317`
+- LoFi:            `1060619084701625`
+- Sky:             `3190514984517598`
+- LunarNewYear:    `357833546030778`
+- Celebration:     `627144732056021`
+- Chill:           `390127158985345`
+- StrangerThings:  `1059859811490132`
+- Dune:            `1455149831518874`
+- Care:            `275041734441112`
+- Astrology:       `3082966625307060`
+- JBalvin:         `184305226956268`
+- Birthday:        `621630955405500`
+- Cottagecore:     `539927563794799`
+- Ocean:           `736591620215564`
+- Love:            `741311439775765`
+- TieDye:          `230032715012014`
+- Monochrome:      `788274591712841`
+- Default:         `3259963564026002`
+- Rocket:          `582065306070020`
+- Berry2:          `724096885023603`
+- Candy2:          `624266884847972`
+- Unicorn:         `273728810607574`
+- Tropical:        `262191918210707`
+- Maple:           `2533652183614000`
+- Sushi:           `909695489504566`
+- Citrus2:         `557344741607350`
+- Lollipop:        `280333826736184`
+- Shadow:          `271607034185782`
+- Rose:            `1257453361255152`
+- Lavender:        `571193503540759`
+- Tulip:           `2873642949430623`
+- Classic:         `3273938616164733`
+- Peach:           `3022526817824329`
+- Honey:           `672058580051520`
+- Kiwi:            `3151463484918004`
+- Grape:           `193497045377796`
+- NonBinary:       `737761000603635`
+- ~~StarWars:      `809305022860427`~~ (Facebook removed it.)
+</details>
+
+---------------------------------------
+
+<a name="handleMessageRequest"></a>
+### api.handleMessageRequest(threadID, accept, [callback])
+
+Accept or ignore message request(s) with thread id `threadID`.
+
+__Arguments__
+
+* `threadID`: A threadID or array of threadIDs corresponding to the target thread(s). Can be numbers or strings.
+* `accept`: Boolean indicating the new status to assign to the message request(s); true for inbox, false to others.
+* `callback(err)`: A callback called when the query is done (with an error or with null).
+
+---------------------------------------
+
+<a name="httpGet"></a>
+### api.httpGet(url, form, [customHeader], [callback], [notAPI])
+
+Get data from a URL with method GET.
+
+__Arguments__
+
+* `url`: A string being the URL to get data from.
+* `form`: An object containing the form data to send.
+* `customHeader`: An object containing custom headers to send.
+* `callback(err, data)`: A callback called when the query is done (either with an error or with the resulting data).
+* `notAPI`: A boolean indicating whether the request is made from the API or not (default: false, meaning it's from the API).
+
+---------------------------------------
+
+<a name="httpPost"></a>
+### api.httpPost(url, form, [customHeader], [callback], [notAPI])
+
+Get data from a URL with method POST.
+
+__Arguments__
+
+* Similar to [`api.httpGet`](#httpGet).
+
+---------------------------------------
+
+<a name="httpPostFormData"></a>
+### api.httpPostFormData(url, form, [customHeader], [callback], [notAPI])
+
+Post form data to a URL.
+
+__Arguments__
+
+* Similar to [`api.httpGet`](#httpGet).
+
+---------------------------------------
+
+<a name="listen"></a>
+### ~~api.listen([callback])~~
+<a name="listenMqtt"></a>
+### api.listenMqtt([callback])
+
+Will call `callback` when a new message is received on this account.
+By default this won't receive events (joining/leaving a chat, title change etc...) but it can be activated with `api.setOptions({listenEvents: true})`.  This will by default ignore messages sent by the current account, you can enable listening to your own messages with `api.setOptions({selfListen: true})`. This returns an `EventEmitter` that contains function `stopListening` that will stop the `listen` loop and is guaranteed to prevent any future calls to the callback given to `listen`. An immediate call to `stopListening` when an error occurs will prevent the listen function to continue.
+
+If `callback` is not defined, or isn't a `Function`, you can listen to messages with event `message` and `error` from `EventEmitter` returned by this function.
+
+__Arguments__
+
+- `callback(error, message)`: A callback called every time the logged-in account receives a new message.
+
+<a name="message"></a>
+__Message__
+
+The message object will contain different fields based on its type (as determined by its `type` field). By default, the only type that will be listened for is `message`. If enabled through [setOptions](#setOptions), the message object may alternatively represent an event e.g. a read receipt. The available event types are as follows:
+
+<table>
+	<tr>
+		<th>Event Type</th>
+		<th>Field</th>
+		<th>Description</th>
+	</tr>
+	<tr>
+		<td rowspan="9">
+			<code>"message"</code><br />
+			A message was sent to a thread.
+		</td>
+		<td><code>attachments</code></td>
+		<td>An array of attachments to the message. Attachments vary in type, see the attachments table below.</td>
+	</tr>
+	<tr>
+		<td><code>body</code></td>
+		<td>The string corresponding to the message that was just received.</td>
+	</tr>
+	<tr>
+		<td><code>isGroup</code></td>
+		<td>boolean, true if this thread is a group thread (more than 2 participants).</td>
+	</tr>
+    <tr>
+        <td><code>mentions</code></td>
+        <td>An object containing people mentioned/tagged in the message in the format { id: name }</td>
+    </tr>
+	<tr>
+		<td><code>messageID</code></td>
+		<td>A string representing the message ID.</td>
+	</tr>
+	<tr>
+		<td><code>senderID</code></td>
+		<td>The id of the person who sent the message in the chat with threadID.</td>
+	</tr>
+	<tr>
+		<td><code>threadID</code></td>
+		<td>The threadID representing the thread in which the message was sent.</td>
+	</tr>
+  	<tr>
+		<td><code>isUnread</code></td>
+		<td>Boolean representing whether or not the message was read.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"message"</code>.</td>
+	</tr>
+	<tr>
+		<td rowspan="6">
+			<code>"event"</code><br />
+			An event occurred within a thread. Note that receiving this event type needs to be enabled with `api.setOptions({ listenEvents: true })`
+		</td>
+		<td><code>author</code></td>
+		<td>The person who performed the event.</td>
+	</tr>
+	<tr>
+		<td><code>logMessageBody</code></td>
+		<td>String printed in the chat.</td>
+	</tr>
+	<tr>
+		<td><code>logMessageData</code></td>
+		<td>Data relevant to the event.</td>
+	</tr>
+	<tr>
+		<td><code>logMessageType</code></td>
+		<td>String representing the type of event (<code>log:subscribe</code>, <code>log:unsubscribe</code>, <code>log:thread-name</code>, <code>log:thread-color</code>, <code>log:thread-icon</code>, <code>log:user-nickname</code>)</td>
+	</tr>
+	<tr>
+		<td><code>threadID</code></td>
+		<td>The threadID representing the thread in which the message was sent.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"event"</code>.</td>
+	</tr>
+	<tr>
+		<td rowspan="5">
+			<code>"typ"</code><br />
+			A user in a thread is typing. Note that receiving this event type needs to be enabled with `api.setOptions({ listenTyping: true })`
+		</td>
+		<td><code>from</code></td>
+		<td>ID of the user who started/stopped typing.</td>
+	</tr>
+	<tr>
+		<td><code>fromMobile</code></td>
+		<td>Boolean representing whether or not the person's using a mobile device to type.</td>
+	</tr>
+	<tr>
+		<td><code>isTyping</code></td>
+		<td>Boolean representing whether or not a person started typing.</td>
+	</tr>
+	<tr>
+		<td><code>threadID</code></td>
+		<td>The threadID representing the thread in which a user is typing.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"typ"</code>.</td>
+	</tr>
+	<tr>
+		<td rowspan="3">
+			<code>"read"</code><br />
+			The current API user has read a message.
+		</td>
+		<td><code>threadID</code></td>
+		<td>The threadID representing the thread in which the message was sent.</td>
+	</tr>
+	<tr>
+		<td><code>time</code></td>
+		<td>The time at which the user read the message.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"read"</code>.</td>
+	</tr>
+	<tr>
+		<td rowspan="4">
+			<code>"read_receipt"</code><br />
+			A user within a thread has seen a message sent by the API user.
+		</td>
+		<td><code>reader</code></td>
+		<td>ID of the user who just read the message.</td>
+	</tr>
+	<tr>
+		<td><code>threadID</code></td>
+		<td>The thread in which the message was read.</td>
+	</tr>
+	<tr>
+		<td><code>time</code></td>
+		<td>The time at which the reader read the message.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"read_receipt"</code>.</td>
+	</tr>
+	<tr>
+		<td rowspan="8">
+			<code>"message_reaction"</code><br />
+			A user has sent a reaction to a message.
+		</td>
+		<td><code>messageID</code></td>
+		<td>The ID of the message</td>
+	</tr>
+	<tr>
+		<td><code>offlineThreadingID</code></td>
+		<td>The offline message ID</td>
+	</tr>
+	<tr>
+		<td><code>reaction</code></td>
+		<td>Contains reaction emoji</td>
+	</tr>
+	<tr>
+		<td><code>senderID</code></td>
+		<td>ID of the author the message, where has been reaction added</td>
+	</tr>
+	<tr>
+		<td><code>threadID</code></td>
+		<td>ID of the thread where the message has been sent</td>
+	</tr>
+	<tr>
+		<td><code>timestamp</code></td>
+		<td>Unix Timestamp (in miliseconds) when the reaction was sent</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"message_reaction"</code>.</td>
+	</tr>
+	<tr>
+		<td><code>userID</code></td>
+		<td>ID of the reaction sender</td>
+	</tr>
+	<tr>
+		<td rowspan="4"><a name="presence"></a>
+			<code>"presence"</code><br />
+			The online status of the user's friends. Note that receiving this event type needs to be enabled with <code>api.setOptions({ updatePresence: true })</code>
+		</td>
+		<td><code>statuses</code></td>
+		<td>The online status of the user. <code>0</code> means the user is idle (away for 2 minutes) and <code>2</code> means the user is online (we don't know what 1 or above 2 means...).</td>
+	</tr>
+	<tr>
+		<td><code>timestamp</code></td>
+		<td>The time when the user was last online.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"presence"</code>.</td>
+	</tr>
+	<tr>
+		<td><code>userID</code></td>
+		<td>The ID of the user whose status this packet is describing.</td>
+	</tr>
+	<tr>
+		<td rowspan="5">
+			<code>"message_unsend"</code><br />
+			A revoke message request for a message from a thread was received.
+		</td>
+		<td><code>threadID</code></td>
+		<td>The threadID representing the thread in which the revoke message request was received.</td>
+	</tr>
+	<tr>
+		<td><code>senderID</code></td>
+		<td>The id of the person who request to revoke message on threadID.</td>
+	</tr>
+	<tr>
+		<td><code>messageID</code></td>
+		<td>A string representing the message ID that the person request to revoke message want to.</td>
+	</tr>
+	<tr>
+		<td><code>deletionTimestamp</code></td>
+		<td>The time when the request was sent.</td>
+    </tr>
+    <tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"message_unsend"</code>.</td>
+	</tr>
+	<tr>
+		<td rowspan="10">
+			<code>"message_reply"</code><br />
+			A reply message was sent to a thread.
+		</td>
+		<td><code>attachments</code></td>
+		<td>An array of attachments to the message. Attachments vary in type, see the attachments table below.</td>
+	</tr>
+	<tr>
+		<td><code>body</code></td>
+		<td>The string corresponding to the message that was just received.</td>
+	</tr>
+	<tr>
+		<td><code>isGroup</code></td>
+		<td>boolean, true if this thread is a group thread (more than 2 participants).</td>
+	</tr>
+    <tr>
+        <td><code>mentions</code></td>
+        <td>An object containing people mentioned/tagged in the message in the format { id: name }</td>
+    </tr>
+	<tr>
+		<td><code>messageID</code></td>
+		<td>A string representing the message ID.</td>
+	</tr>
+	<tr>
+		<td><code>senderID</code></td>
+		<td>The id of the person who sent the message in the chat with threadID.</td>
+	</tr>
+	<tr>
+		<td><code>threadID</code></td>
+		<td>The threadID representing the thread in which the message was sent.</td>
+	</tr>
+  	<tr>
+		<td><code>isUnread</code></td>
+		<td>Boolean representing whether or not the message was read.</td>
+	</tr>
+	<tr>
+		<td><code>type</code></td>
+		<td>For this event type, this will always be the string <code>"message_reply"</code>.</td>
+	</tr>
+	<tr>
+		<td><code>messageReply</code></td>
+		<td>An object represent a message being replied. Content inside is the same like a normal <code>"message"</code> event.</td>
+	</tr>
+</table>
+
+__Attachments__
+
+Similar to how messages can vary based on their `type`, so too can the `attachments` within `"message"` events. Each attachment will consist of an object of one of the following types:
+
+| Attachment Type    | Fields                                                                                                                                                    |
+| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `"sticker"`        | `ID`, `url`, `packID`, `spriteUrl`, `spriteUrl2x`, `width`, `height`, `caption`, `description`, `frameCount`, `frameRate`, `framesPerRow`, `framesPerCol` |
+| `"file"`           | `ID`, `filename`, `url`, `isMalicious`, `contentType`                                                                                                     |
+| `"photo"`          | `ID`, `filename`, `thumbnailUrl`, `previewUrl`, `previewWidth`, `previewHeight`, `largePreviewUrl`, `largePreviewWidth`, `largePreviewHeight`             |
+| `"animated_image"` | `ID`, `filename`, `previewUrl`, `previewWidth`, `previewHeight`, `url`, `width`, `height`                                                                 |
+| `"video"`          | `ID`, `filename`, `previewUrl`, `previewWidth`, `previewHeight`, `url`, `width`, `height`, `duration`, `videoType`                                        |
+| `"audio"`          | `ID`, `filename`, `audioType`, `duration`, `url`, `isVoiceMail`                                                                                           |
+| `"location"`       | `ID`, `latitude`, `longitude`, `image`, `width`, `height`, `url`, `address`                                                                               |
+| `"share"`          | `ID`, `url`, `title`, `description`, `source`, `image`, `width`, `height`, `playable`, `duration`, `playableUrl`, `subattachments`, `properties`          |
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+// Simple echo bot. He'll repeat anything that you say.
+// Will stop when you say '/stop'
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.setOptions({listenEvents: true});
+
+    var listenEmitter = api.listen((err, event) => {
+        if(err) return console.error(err);
+
+        switch (event.type) {
+            case "message":
+                if(event.body === '/stop') {
+                    api.sendMessage("Goodbye...", event.threadID);
+                    return listenEmitter.stopListening();
+                }
+                api.markAsRead(event.threadID, (err) => {
+                    if(err) console.log(err);
+                });
+                api.sendMessage("TEST BOT: " + event.body, event.threadID);
+                break;
+            case "event":
+                console.log(event);
+                break;
+        }
+    });
+});
+```
+
+---------------------------------------
+
+<a name="logout"></a>
+### api.logout([callback])
+
+Logs out the current user.
+
+__Arguments__
+
+* `callback(err)`: A callback called when the query is done (either with an error or with null).
+
+---------------------------------------
+
+<a name="markAsDelivered"></a>
+### api.markAsDelivered(threadID, messageID, [callback]])
+
+Given a threadID and a messageID will mark that message as delivered. If a message is marked as delivered that tells facebook servers that it was recieved.
+
+You can also mark new messages as delivered automatically. This is enabled by default. See [api.setOptions](#setOptions).
+
+__Arguments__
+
+* `threadID` - The id of the thread in which you want to mark the message as delivered.
+* `messageID` - The id of the message want to mark as delivered.
+* `callback(err)` - A callback called when the operation is done maybe with an object representing an error.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("facebook-chat-api");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.listen((err, message) => {
+        if(err) return console.error(err);
+
+        // Marks messages as delivered immediately after they're received
+        api.markAsDelivered(message.threadID, message.messageID);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="markAsRead"></a>
+### api.markAsRead(threadID, [read, [callback]])
+
+Given a threadID will mark all the unread messages in a thread as read. Facebook will take a couple of seconds to show that you've read the messages.
+
+You can also mark new messages as read automatically. See [api.setOptions](#setOptions). But be careful, this will make your account getting banned, especially when receiving *HUGE* amount of messages.
+
+__Arguments__
+
+* `threadID` - The id of the thread in which you want to mark the messages as read.
+* `read` - An optional boolean where `true` means to mark the message as being "read" and `false` means to mark the message as being "unread".
+* `callback(err)` - A callback called when the operation is done maybe with an object representing an error.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.listen((err, message) => {
+        if(err) return console.error(err);
+
+        // Marks messages as read immediately after they're received
+        api.markAsRead(message.threadID);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="markAsReadAll"></a>
+### api.markAsReadAll([callback])
+
+This function will mark all of messages in your inbox readed.
+
+---------------------------------------
+
+<a name="markAsSeen"></a>
+### api.markAsSeen([seenTimestamp], [callback])
+
+This function will mark your entire inbox as seen (don't be confused with read!).
+
+---------------------------------------
+
+<a name="muteThread"></a>
+### api.muteThread(threadID, muteSeconds, [callback])
+
+Mute a chat for a period of time, or unmute a chat.
+
+__Arguments__
+
+* `threadID` - The ID of the chat you want to mute.
+* `muteSeconds` - Mute the chat for this amount of seconds. Use `0` to unmute a chat. Use '-1' to mute a chat indefinitely.
+* `callback(err)` - A callback called when the operation is done maybe with an object representing an error.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.listen((err, message) => {
+        if(err) return console.error(err);
+
+        // Mute all incoming chats for one minute
+        api.muteThread(message.threadID, 60);
+    });
+});
+```
+
+---------------------------------------
+
+<a name="removeUserFromGroup"></a>
+### api.removeUserFromGroup(userID, threadID, [callback])
+
+Removes a user from a group chat.
+
+__Arguments__
+
+* `userID`: User ID.
+* `threadID`: Group chat ID.
+* `callback(err)`: A callback called when the query is done (either with an error or with no arguments).
+
+---------------------------------------
+
+<a name="resolvePhotoUrl"></a>
+### api.resolvePhotoUrl(photoID, [callback])
+
+Resolves the URL to the full-size photo, given its ID. This function is useful for retrieving the full-size photo URL
+of image attachments in messages, returned by [`api.getThreadHistory`](#getThreadHistory).
+
+__Arguments__
+
+* `photoID`: Photo ID.
+* `callback(err, url)`: A callback called when the query is done (either with an error or with the photo's URL). `url` is a string with the photo's URL.
+
+---------------------------------------
+
+<a name="searchForThread"></a>
+### api.searchForThread(name, [callback])
+
+> This part is outdated.
+> see #396
+
+Takes a chat title (thread name) and returns matching results as a formatted threads array (ordered according to Facebook).
+
+__Arguments__
+* `name`: A messageID string or messageID string array
+* `callback(err, obj)`: A callback called when the query is done (either with an error or a thread object). The object passed in the callback has the following shape: `threadID`, <del>`participants`</del>, `participantIDs`, `formerParticipants`, `name`, `nicknames`, `snippet`, `snippetHasAttachment`, `snippetAttachments`, `snippetSender`, `unreadCount`, `messageCount`, `imageSrc`, `timestamp`, `serverTimestamp`, `muteSettings`, `isCanonicalUser`, `isCanonical`, `canonicalFbid`, `isSubscribed`, `rootMessageThreadingID`, `folder`, `isArchived`, `recipientsLoadable`, `hasEmailParticipant`, `readOnly`, `canReply`, `composerEnabled`, `blockedParticipants`, `lastMessageID`
+
+---------------------------------------
+
+<a name="sendMessage"></a>
+### api.sendMessage(message, threadID, [callback], messageID)
+
+Sends the given message to the threadID.
+
+__Arguments__
+
+* `message`: A string (for backward compatibility) or a message object as described below.
+* `threadID`: A string, number, or array representing a thread. It happens to be someone's userID in the case of a one to one conversation or an array of userIDs when starting a new group chat.
+* `callback(err, messageInfo)`: (Optional) A callback called when sending the message is done (either with an error or with an confirmation object). `messageInfo` contains the `threadID` where the message was sent and a `messageID`, as well as the `timestamp` of the message.
+* `messageID`: (Optional) A string representing a message you want to reply.
+
+__Message Object__:
+
+Various types of message can be sent:
+* *Regular:* set field `body` to the desired message as a string.
+* *Sticker:* set a field `sticker` to the desired sticker ID.
+* *File or image:* Set field `attachment` to a readable stream or an array of readable streams.
+* *URL:* set a field `url` to the desired URL.
+* *Emoji:* set field `emoji` to the desired emoji as a string and set field `emojiSize` with size of the emoji (`small`, `medium`, `large`)
+* *Mentions:* set field `mentions` to an array of objects. Objects should have the `tag` field set to the text that should be highlighted in the mention. The object should have an `id` field, where the `id` is the user id of the person being mentioned. The instance of `tag` that is highlighted is determined through indexOf, an optional `fromIndex`
+can be passed in to specify the start index to start searching for the `tag` text
+in `body` (default=0). (See below for an example.)
+* *Location:* set field `location` to an object with `latitude` and `longitude` fields. Optionally set field `current` of the `location` object to true to indicate the location is the user’s current location. Otherwise the location will be sent as a pinned location.
+
+Note that a message can only be a regular message (which can be empty) and optionally one of the following: a sticker, an attachment or a url.
+
+__Tip__: to find your own ID, you can look inside the cookies. The `userID` is under the name `c_user`.
+
+__Example (Basic Message)__
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    var yourID = "000000000000000";
+    var msg = {body: "Hey!"};
+    api.sendMessage(msg, yourID);
+});
+```
+
+__Example (File upload)__
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    // This example uploads an image called image.jpg
+    var yourID = "000000000000000";
+    var msg = {
+        body: "Hey!",
+        attachment: fs.createReadStream(__dirname + '/image.jpg')
+    }
+    api.sendMessage(msg, yourID);
+});
+```
+
+__Example (Mention)__
+```js
+const login = require("fb-chat-api-temp");
+
+login({email: "EMAIL", password: "PASSWORD"}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.listen((err, message) => {
+        if (message && message.body) {
+            // Getting the actual sender name from ID involves calling
+            // `api.getThreadInfo` and `api.getUserInfo`
+            api.sendMessage({
+                body: 'Hello @Sender! @Sender!',
+                mentions: [{
+                     tag: '@Sender',
+                     id: message.senderID,
+                     fromIndex: 9, // Highlight the second occurrence of @Sender
+                }],
+            }, message.threadID);
+        }
+    });
+});
+```
+
+__Example (Location)__
+```js
+const login = require("fb-chat-api-temp");
+login({email: "EMAIL", password: "PASSWORD"}, (err, api) => {
+    if(err) return console.error(err);
+    var yourID = "000000000000000";
+    const msg = {
+    	location: { latitude: 48.858093, longitude: 2.294694, current: true },
+  	};
+    api.sendMessage(msg, yourID);
+});
+```
+
+---------------------------------------
+
+<a name="sendTypingIndicator"></a>
+### api.sendTypingIndicator(threadID, [callback])
+
+Sends a "USERNAME is typing" indicator to other members of the thread indicated by `threadID`. This indication will disappear after 30 second or when the `end` function is called. The `end` function is returned by `api.sendTypingIndicator`.
+
+__Arguments__
+
+* `threadID`: Group chat ID.
+* `callback(err)`: A callback called when the query is done (with an error or with null).
+
+---------------------------------------
+
+<a name="setMessageReaction"></a>
+### api.setMessageReaction(reaction, messageID, [callback], forceCustomReaction)
+
+Sets reaction on message
+
+__Arguments__
+
+* `reaction`: A string containing either an emoji, an emoji in unicode, or an emoji shortcut (see list of supported emojis below). The string can be left empty ("") in order to remove a reaction.
+* `messageID`: A string representing the message ID.
+* `callback(err)`: A callback called when sending the reaction is done.
+* `forceCustomReaction`: Forcing the use of an emoji for setting reaction **(WARNING: NOT TESTED, YOU SHOULD NOT USE THIS AT ALL, UNLESS YOU'RE TESTING A NEW EMOJI)**
+
+__Supported Emojis__
+
+| Emoji | Text | Unicode        | Shortcuts                   |
+| ----- | ---- | -------------- | --------------------------- |
+| 😍     | `😍`  | `\uD83D\uDE0D` | `:love:`, `:heart_eyes:`    |
+| 😆     | `😆`  | `\uD83D\uDE06` | `:haha:`, `:laughing:`      |
+| 😮     | `😮`  | `\uD83D\uDE2E` | `:wow:`, `:open_mouth:`     |
+| 😢     | `😢`  | `\uD83D\uDE22` | `:sad:`, `:cry:`            |
+| 😠     | `😠`  | `\uD83D\uDE20` | `:angry:`                   |
+| 👍     | `👍`  | `\uD83D\uDC4D` | `:like:`, `:thumbsup:`      |
+| 👎     | `👎`  | `\uD83D\uDC4E` | `:dislike:`, `:thumbsdown:` |
+| ❤     | `❤`  | `\u2764`       | `:heart:`                   |
+| 💗     | `💗`  | `\uD83D\uDC97` | `:glowingheart:`            |
+
+---------------------------------------
+
+<a name="setOptions"></a>
+### api.setOptions(options)
+
+Sets various configurable options for the api.
+
+__Arguments__
+
+* `options` - An object containing the new values for the options that you want
+  to set.  If the value for an option is unspecified, it is unchanged. The following options are possible.
+    - `logLevel`: The desired logging level as determined by npmlog.  Choose
+      from either `"silly"`, `"verbose"`, `"info"`, `"http"`, `"warn"`, `"error"`, or `"silent"`.
+    - `selfListen`: (Default `false`) Set this to `true` if you want your api
+      to receive messages from its own account.  This is to be used with
+      caution, as it can result in loops (a simple echo bot will send messages
+      forever).
+    - `listenEvents`: (Default `false`) Will make [api.listen](#listen) also handle events (look at api.listen for more details).
+    - `pageID`: (Default empty) Makes [api.listen](#listen) only receive messages through the page specified by that ID. Also makes [api.sendMessage](#sendMessage) send from the page.
+    - `updatePresence`: (Default `false`) Will make [api.listen](#listen) also return `presence` ([api.listen](#presence) for more details).
+    - `forceLogin`: (Default `false`) Will automatically approve of any recent logins and continue with the login process.
+    - `userAgent`: (Default `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/600.3.18 (KHTML, like Gecko) Version/8.0.3 Safari/600.3.18`) The desired simulated User Agent.
+	- `autoMarkDelivery`: (Default `true`) Will automatically mark new messages as delivered. See [api.markAsDelivered](#markAsDelivered).
+	- `autoMarkRead`: (Default `false`) Will automatically mark new messages as read/seen. See [api.markAsRead](#markAsRead).
+	- `proxy`: (Default empty) Set this to proxy server address to use proxy. Note: Only HTTP Proxies which support CONNECT method is supported.
+	- `online`: (Default `true`) Set account's online state.
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+
+// Simple echo bot. This will send messages forever.
+
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+    if(err) return console.error(err);
+
+    api.setOptions({
+        selfListen: true,
+        logLevel: "silent"
+    });
+
+    api.listen((err, message) => {
+        if(err) return console.error(err);
+
+        // Ignore empty messages (photos etc.)
+        if (typeof message.body === "string") {
+            api.sendMessage(message.body, message.threadID);
+        }
+    });
+});
+```
+
+---------------------------------------
+
+<a name="setPostReaction"></a>
+### api.setPostReaction(postID, type, [callback])
+__Arguments__
+
+* `postID`: id of the post to react.
+* `type`: A string reaction type or key reaction.
+* `callback(err, obj)`: A callback called when the query is done.
+
+| Key | Reaction Type |
+| --- | ------------- |
+| 0   | unlike        |
+| 1   | like          |
+| 2   | heart         |
+| 16  | love          |
+| 4   | haha          |
+| 3   | wow           |
+| 7   | sad           |
+| 8   | angry         |
+
+---------------------------------------
+
+<a name="setTitle"></a>
+### api.setTitle(newTitle, threadID, [callback])
+
+Sets the title of the group chat with thread id `threadID` to `newTitle`.
+
+Note: This will not work if the thread id corresponds to a single-user chat or if the bot is not in the group chat.
+
+__Arguments__
+
+* `newTitle`: A string representing the new title.
+* `threadID`: A string or number representing a thread. It happens to be someone's userID in the case of a one to one conversation.
+* `callback(err, obj)` - A callback called when sending the message is done (either with an error or with an confirmation object). `obj` contains only the threadID where the message was sent.
+
+---------------------------------------
+
+<a name="unsendMessage"></a>
+### api.unsendMessage(messageID, [callback])
+
+Revokes a message from anyone that could see that message with `messageID`
+
+Note: This will only work if the message is sent by you and was sent less than 10 minutes ago.
+
+__Arguments__
+
+* `messageID`: Message ID you want to unsend.
+* `callback(err)`: A callback called when the query is done (with an error or with null).
+
+---------------------------------------
+
+<a name="uploadAttachments"></a>
+### api.uploadAttachment(attachments, [callback])
+This function is used to upload attachments to Facebook. It is used internally by [api.sendMessage](#apisendmessagemessage-threadid-callback-messageid).
+
+__Arguments__
+<!--  readable stream or an array of readable streams. -->
+* `attachments`: A readable stream or an array of readable streams to upload.
+* `callback(err, info)`: A callback called when the upload is done (either with an error or with the uploaded file info).
+
+__Example__
+
+```js
+const fs = require("fs-extra");
+const login = require("fb-chat-api-temp");
+login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
+	if (err)
+		return console.error(err);
+
+	// Send a local file as a stream
+	const iamgeOne = fs.createReadStream(__dirname + '/image.jpg');
+	const iamgeTwo = fs.createReadStream(__dirname + '/image2.jpg');
+
+	api.uploadAttachment([iamgeOne, iamgeTwo], (err, attachments) => {
+		if(err)
+			return console.error(err);
+			
+		console.log(attachments);
+	});
+});

includes/login/index.js

@@ -0,0 +1,392 @@
+"use strict";
+
+const utils = require("./utils");
+const log = require("npmlog");
+
+const checkVerified = null;
+
+const defaultLogRecordSize = 100;
+log.maxRecordSize = defaultLogRecordSize;
+
+function setOptions(globalOptions, options) {
+  Object.keys(options).map(function (key) {
+    switch (key) {
+      case 'online':
+        globalOptions.online = Boolean(options.online);
+        break;
+      case 'logLevel':
+        log.level = options.logLevel;
+        globalOptions.logLevel = options.logLevel;
+        break;
+      case 'logRecordSize':
+        log.maxRecordSize = options.logRecordSize;
+        globalOptions.logRecordSize = options.logRecordSize;
+        break;
+      case 'selfListen':
+        globalOptions.selfListen = Boolean(options.selfListen);
+        break;
+      case 'selfListenEvent':
+        globalOptions.selfListenEvent = options.selfListenEvent;
+        break;
+      case 'listenEvents':
+        globalOptions.listenEvents = Boolean(options.listenEvents);
+        break;
+      case 'pageID':
+        globalOptions.pageID = options.pageID.toString();
+        break;
+      case 'updatePresence':
+        globalOptions.updatePresence = Boolean(options.updatePresence);
+        break;
+      case 'forceLogin':
+        globalOptions.forceLogin = Boolean(options.forceLogin);
+        break;
+      case 'userAgent':
+        globalOptions.userAgent = options.userAgent;
+        break;
+      case 'autoMarkDelivery':
+        globalOptions.autoMarkDelivery = Boolean(options.autoMarkDelivery);
+        break;
+      case 'autoMarkRead':
+        globalOptions.autoMarkRead = Boolean(options.autoMarkRead);
+        break;
+      case 'listenTyping':
+        globalOptions.listenTyping = Boolean(options.listenTyping);
+        break;
+      case 'proxy':
+        if (typeof options.proxy != "string") {
+          delete globalOptions.proxy;
+          utils.setProxy();
+        } else {
+          globalOptions.proxy = options.proxy;
+          utils.setProxy(globalOptions.proxy);
+        }
+        break;
+      case 'autoReconnect':
+        globalOptions.autoReconnect = Boolean(options.autoReconnect);
+        break;
+      case 'emitReady':
+        globalOptions.emitReady = Boolean(options.emitReady);
+        break;
+      default:
+        log.warn("setOptions", "Unrecognized option given to setOptions: " + key);
+        break;
+    }
+  });
+}
+
+function buildAPI(globalOptions, html, jar) {
+  const maybeCookie = jar.getCookies("https://www.facebook.com").filter(function (val) {
+    return val.cookieString().split("=")[0] === "c_user";
+  });
+
+  const objCookie = jar.getCookies("https://www.facebook.com").reduce(function (obj, val) {
+    obj[val.cookieString().split("=")[0]] = val.cookieString().split("=")[1];
+    return obj;
+  }, {});
+
+  if (maybeCookie.length === 0) {
+    throw { error: "Error retrieving userID. This can be caused by a lot of things, including getting blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify." };
+  }
+
+  if (html.indexOf("/checkpoint/block/?next") > -1) {
+    log.warn("login", "Checkpoint detected. Please log in with a browser to verify.");
+  }
+
+  const userID = maybeCookie[0].cookieString().split("=")[1].toString();
+  const i_userID = objCookie.i_user || null;
+  log.info("login", `Logged in as ${userID}`);
+
+  try {
+    clearInterval(checkVerified);
+  } catch (_) { }
+
+  const clientID = (Math.random() * 2147483648 | 0).toString(16);
+
+
+  const oldFBMQTTMatch = html.match(/irisSeqID:"(.+?)",appID:219994525426954,endpoint:"(.+?)"/);
+  let mqttEndpoint = null;
+  let region = null;
+  let irisSeqID = null;
+  let noMqttData = null;
+
+  if (oldFBMQTTMatch) {
+    irisSeqID = oldFBMQTTMatch[1];
+    mqttEndpoint = oldFBMQTTMatch[2];
+    region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
+    log.info("login", `Got this account's message region: ${region}`);
+  } else {
+    const newFBMQTTMatch = html.match(/{"app_id":"219994525426954","endpoint":"(.+?)","iris_seq_id":"(.+?)"}/);
+    if (newFBMQTTMatch) {
+      irisSeqID = newFBMQTTMatch[2];
+      mqttEndpoint = newFBMQTTMatch[1].replace(/\\\//g, "/");
+      region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
+      log.info("login", `Got this account's message region: ${region}`);
+    } else {
+      const legacyFBMQTTMatch = html.match(/(\["MqttWebConfig",\[\],{fbid:")(.+?)(",appID:219994525426954,endpoint:")(.+?)(",pollingEndpoint:")(.+?)(3790])/);
+      if (legacyFBMQTTMatch) {
+        mqttEndpoint = legacyFBMQTTMatch[4];
+        region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
+        log.warn("login", `Cannot get sequence ID with new RegExp. Fallback to old RegExp (without seqID)...`);
+        log.info("login", `Got this account's message region: ${region}`);
+        log.info("login", `[Unused] Polling endpoint: ${legacyFBMQTTMatch[6]}`);
+      } else {
+        log.warn("login", "Cannot get MQTT region & sequence ID.");
+        noMqttData = html;
+      }
+    }
+  }
+
+  // All data available to api functions
+  const ctx = {
+    userID: userID,
+    i_userID: i_userID,
+    jar: jar,
+    clientID: clientID,
+    globalOptions: globalOptions,
+    loggedIn: true,
+    access_token: 'NONE',
+    clientMutationId: 0,
+    mqttClient: undefined,
+    lastSeqId: irisSeqID,
+    syncToken: undefined,
+    wsReqNumber: 0,
+    wsTaskNumber: 0,
+    mqttEndpoint,
+    region,
+    firstListen: true
+  };
+
+  const api = {
+    setOptions: setOptions.bind(null, globalOptions),
+    getAppState: function getAppState() {
+      const appState = utils.getAppState(jar);
+      // filter duplicate
+      return appState.filter((item, index, self) => self.findIndex((t) => { return t.key === item.key; }) === index);
+    }
+  };
+
+  if (noMqttData) {
+    api["htmlData"] = noMqttData;
+  }
+
+  const apiFuncNames = [
+    'addExternalModule',
+    'addUserToGroup',
+    'changeAdminStatus',
+    'changeArchivedStatus',
+    'changeAvatar',
+    'changeBio',
+    'changeBlockedStatus',
+    'changeGroupImage',
+    'changeNickname',
+    'changeThreadColor',
+    'changeThreadEmoji',
+    'createNewGroup',
+    'createPoll',
+    'deleteMessage',
+    'deleteThread',
+    'forwardAttachment',
+    'getCurrentUserID',
+    'getEmojiUrl',
+    'getFriendsList',
+    'getMessage',
+    'getThreadHistory',
+    'getThreadInfo',
+    'getThreadList',
+    'getThreadPictures',
+    'getUserID',
+    'getUserInfo',
+    'handleMessageRequest',
+    'listenMqtt',
+    'logout',
+    'markAsDelivered',
+    'markAsRead',
+    'markAsReadAll',
+    'markAsSeen',
+    'muteThread',
+    'refreshFb_dtsg',
+    'removeUserFromGroup',
+    'resolvePhotoUrl',
+    'searchForThread',
+    'sendMessage',
+    'sendTypingIndicator',
+    'setMessageReaction',
+    'setPostReaction',
+    'setTitle',
+    'threadColors',
+    'unsendMessage',
+    'unfriend',
+    'editMessage',
+    'shareContact',
+    'sendComment',
+
+    // HTTP
+    'httpGet',
+    'httpPost',
+    'httpPostFormData',
+
+    'uploadAttachment'
+  ];
+
+  const defaultFuncs = utils.makeDefaults(html, i_userID || userID, ctx);
+
+  // Load all api functions in a loop
+  apiFuncNames.map(function (v) {
+    api[v] = require('./src/' + v)(defaultFuncs, api, ctx);
+  });
+
+  //Removing original `listen` that uses pull.
+  //Map it to listenMqtt instead for backward compatibly.
+  api.listen = api.listenMqtt;
+
+  return [ctx, defaultFuncs, api];
+}
+
+// Helps the login
+function loginHelper(appState, email, password, globalOptions, callback, prCallback) {
+  let mainPromise = null;
+  const jar = utils.getJar();
+
+  // If we're given an appState we loop through it and save each cookie
+  // back into the jar.
+  if (appState) {
+    // check and convert cookie to appState
+    if (utils.getType(appState) === 'Array' && appState.some(c => c.name)) {
+      appState = appState.map(c => {
+        c.key = c.name;
+        delete c.name;
+        return c;
+      });
+    }
+    else if (utils.getType(appState) === 'String') {
+      const arrayAppState = [];
+      appState.split(';').forEach(c => {
+        const [key, value] = c.split('=');
+
+        arrayAppState.push({
+          key: (key || "").trim(),
+          value: (value || "").trim(),
+          domain: "facebook.com",
+          path: "/",
+          expires: new Date().getTime() + 1000 * 60 * 60 * 24 * 365
+        });
+      });
+      appState = arrayAppState;
+    }
+
+    appState.map(function (c) {
+      const str = c.key + "=" + c.value + "; expires=" + c.expires + "; domain=" + c.domain + "; path=" + c.path + ";";
+      jar.setCookie(str, "http://" + c.domain);
+    });
+
+    // Load the main page.
+    mainPromise = utils
+      .get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true })
+      .then(utils.saveCookies(jar));
+  } else {
+    if (email) {
+      throw { error: "Currently, the login method by email and password is no longer supported, please use the login method by appState" };
+    }
+    else {
+      throw { error: "No appState given." };
+    }
+  }
+
+  let ctx = null;
+  let _defaultFuncs = null;
+  let api = null;
+
+  mainPromise = mainPromise
+    .then(function (res) {
+      // Hacky check for the redirection that happens on some ISPs, which doesn't return statusCode 3xx
+      const reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+      const redirect = reg.exec(res.body);
+      if (redirect && redirect[1]) {
+        return utils
+          .get(redirect[1], jar, null, globalOptions)
+          .then(utils.saveCookies(jar));
+      }
+      return res;
+    })
+    .then(function (res) {
+      const html = res.body;
+      const stuff = buildAPI(globalOptions, html, jar);
+      ctx = stuff[0];
+      _defaultFuncs = stuff[1];
+      api = stuff[2];
+      return res;
+    });
+
+  // given a pageID we log in as a page
+  if (globalOptions.pageID) {
+    mainPromise = mainPromise
+      .then(function () {
+        return utils
+          .get('https://www.facebook.com/' + ctx.globalOptions.pageID + '/messages/?section=messages&subsection=inbox', ctx.jar, null, globalOptions);
+      })
+      .then(function (resData) {
+        let url = utils.getFrom(resData.body, 'window.location.replace("https:\\/\\/www.facebook.com\\', '");').split('\\').join('');
+        url = url.substring(0, url.length - 1);
+
+        return utils
+          .get('https://www.facebook.com' + url, ctx.jar, null, globalOptions);
+      });
+  }
+
+  // At the end we call the callback or catch an exception
+  mainPromise
+    .then(function () {
+      log.info("login", 'Done logging in.');
+      return callback(null, api);
+    })
+    .catch(function (e) {
+      log.error("login", e.error || e);
+      callback(e);
+    });
+}
+
+function login(loginData, options, callback) {
+  if (utils.getType(options) === 'Function' || utils.getType(options) === 'AsyncFunction') {
+    callback = options;
+    options = {};
+  }
+
+  const globalOptions = {
+    selfListen: false,
+    selfListenEvent: false,
+    listenEvents: false,
+    listenTyping: false,
+    updatePresence: false,
+    forceLogin: false,
+    autoMarkDelivery: true,
+    autoMarkRead: false,
+    autoReconnect: true,
+    logRecordSize: defaultLogRecordSize,
+    online: true,
+    emitReady: false,
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/600.3.18 (KHTML, like Gecko) Version/8.0.3 Safari/600.3.18"
+  };
+
+  setOptions(globalOptions, options);
+
+  let prCallback = null;
+  if (utils.getType(callback) !== "Function" && utils.getType(callback) !== "AsyncFunction") {
+    let rejectFunc = null;
+    let resolveFunc = null;
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    prCallback = function (error, api) {
+      if (error) {
+        return rejectFunc(error);
+      }
+      return resolveFunc(api);
+    };
+    callback = prCallback;
+  }
+  loginHelper(loginData.appState, loginData.email, loginData.password, globalOptions, callback, prCallback);
+  return returnPromise;
+}
+
+module.exports = login;

includes/login/utils.js

@@ -0,0 +1,1544 @@
+/* eslint-disable no-prototype-builtins */
+"use strict";
+
+let request = promisifyPromise(require("request").defaults({ jar: true, proxy: process.env.FB_PROXY }));
+const stream = require("stream");
+const log = require("npmlog");
+const querystring = require("querystring");
+const url = require("url");
+
+class CustomError extends Error {
+  constructor(obj) {
+    if (typeof obj === 'string')
+      obj = { message: obj };
+    if (typeof obj !== 'object' || obj === null)
+      throw new TypeError('Object required');
+    obj.message ? super(obj.message) : super();
+    Object.assign(this, obj);
+  }
+}
+
+function callbackToPromise(func) {
+  return function (...args) {
+    return new Promise((resolve, reject) => {
+      func(...args, (err, data) => {
+        if (err)
+          reject(err);
+        else
+          resolve(data);
+      });
+    });
+  };
+}
+
+function isHasCallback(func) {
+  if (typeof func !== "function")
+    return false;
+  return func.toString().split("\n")[0].match(/(callback|cb)\s*\)/) !== null;
+}
+
+// replace for bluebird.promisify (but this only applies best to the `request` package)
+function promisifyPromise(promise) {
+  const keys = Object.keys(promise);
+  let promise_;
+  if (
+    typeof promise === "function"
+    && isHasCallback(promise)
+  )
+    promise_ = callbackToPromise(promise);
+  else
+    promise_ = promise;
+
+  for (const key of keys) {
+    if (!promise[key]?.toString)
+      continue;
+
+    if (
+      typeof promise[key] === "function"
+      && isHasCallback(promise[key])
+    ) {
+      promise_[key] = callbackToPromise(promise[key]);
+    }
+    else {
+      promise_[key] = promise[key];
+    }
+  }
+
+  return promise_;
+}
+
+// replace for bluebird.delay
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// replace for bluebird.try
+function tryPromise(tryFunc) {
+  return new Promise((resolve, reject) => {
+    try {
+      resolve(tryFunc());
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function setProxy(url) {
+  if (typeof url == "undefined")
+    return request = promisifyPromise(require("request").defaults({
+      jar: true
+    }));
+  return request = promisifyPromise(require("request").defaults({
+    jar: true,
+    proxy: url
+  }));
+}
+
+function getHeaders(url, options, ctx, customHeader) {
+  const 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",
+    "sec-fetch-site": "same-origin"
+  };
+  if (customHeader) {
+    Object.assign(headers, customHeader);
+  }
+  if (ctx && ctx.region) {
+    headers["X-MSGR-Region"] = ctx.region;
+  }
+
+  return headers;
+}
+
+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) {
+  // I'm still confused about this
+  if (getType(qs) === "Object") {
+    for (const prop in qs) {
+      if (qs.hasOwnProperty(prop) && getType(qs[prop]) === "Object") {
+        qs[prop] = JSON.stringify(qs[prop]);
+      }
+    }
+  }
+  const op = {
+    headers: getHeaders(url, options, ctx),
+    timeout: 60000,
+    qs: qs,
+    url: url,
+    method: "GET",
+    jar: jar,
+    gzip: true
+  };
+
+  return request(op).then(function (res) {
+    return Array.isArray(res) ? res[0] : res;
+  });
+}
+
+function post(url, jar, form, options, ctx, customHeader) {
+  const op = {
+    headers: getHeaders(url, options, ctx, customHeader),
+    timeout: 60000,
+    url: url,
+    method: "POST",
+    form: form,
+    jar: jar,
+    gzip: true
+  };
+
+  return request(op).then(function (res) {
+    return Array.isArray(res) ? res[0] : res;
+  });
+}
+
+function postFormData(url, jar, form, qs, options, ctx) {
+  const headers = getHeaders(url, options, ctx);
+  headers["Content-Type"] = "multipart/form-data";
+  const op = {
+    headers: headers,
+    timeout: 60000,
+    url: url,
+    method: "POST",
+    formData: form,
+    qs: qs,
+    jar: jar,
+    gzip: true
+  };
+
+  return request(op).then(function (res) {
+    return Array.isArray(res) ? res[0] : res;
+  });
+}
+
+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);
+  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);
+}
+
+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, function (m, n) {
+      return n ? "%" + n.charCodeAt(0).toString(16) : m;
+    })
+    .toLowerCase()
+    .replace(h, function (m) {
+      return i[m];
+    });
+}
+
+// eslint-disable-next-line no-unused-vars
+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(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() {
+  /** @type {number} */
+  let sectionLength = Date.now();
+  /** @type {string} */
+  const id = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    /** @type {number} */
+    const r = Math.floor((sectionLength + Math.random() * 16) % 16);
+    /** @type {number} */
+    sectionLength = Math.floor(sectionLength / 16);
+    /** @type {string} */
+    const _guid = (c == "x" ? r : (r & 7) | 8).toString(16);
+    return _guid;
+  });
+  return id;
+}
+
+function getExtension(original_extension, fullFileName = "") {
+  if (original_extension) {
+    return original_extension;
+  }
+  else {
+    const extension = fullFileName.split(".").pop();
+    if (extension === fullFileName) {
+      return "";
+    }
+    else {
+      return extension;
+    }
+  }
+}
+
+function _formatAttachment(attachment1, attachment2) {
+  // 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.
+  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 &&
+      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(), // @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 // @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, // @Legacy
+        width: attachment1.metadata.dimensions.split(",")[0], // @Legacy
+        height: attachment1.metadata.dimensions.split(",")[1], // @Legacy
+        name: fullFileName // @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, // @Legacy
+        facebookUrl: attachment1.url, // @Legacy
+        thumbnailUrl: attachment1.thumbnail_url, // @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, // @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 // @Legacy
+      };
+    case "error":
+      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, // @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, // @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 // @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
+      };
+    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, // @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 {
+        latitude = Number.parseFloat(address[0]);
+        longitude = Number.parseFloat(address[1]);
+      } catch (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 &&
+          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, // @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
+      };
+    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) {
+  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 === undefined
+      ? []
+      : m.delta.data.prng === undefined
+        ? []
+        : JSON.parse(m.delta.data.prng);
+  const m_id = mdata.map(u => u.i);
+  const m_offset = mdata.map(u => u.o);
+  const m_length = mdata.map(u => u.l);
+  const mentions = {};
+  for (let 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()
+    ),
+    messageID: md.messageId,
+    attachments: (m.delta.attachments || []).map(v => _formatAttachment(v)),
+    mentions: mentions,
+    timestamp: md.timestamp,
+    isGroup: !!md.threadKey.threadFbId,
+    participantIDs: m.delta.participants || (md.cid ? md.cid.canonicalParticipantFbids : []) || []
+  };
+}
+
+function formatID(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 = {
+    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(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,
+    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) {
+  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 "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;
+
+  // 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);
+      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
+        }
+      };
+  }
+
+  return {
+    type: "event",
+    threadID: formatID(
+      (
+        m.messageMetadata.threadKey.threadFbId ||
+        m.messageMetadata.threadKey.otherUserFbId
+      ).toString()
+    ),
+    messageID: m.messageMetadata.messageId.toString(),
+    logMessageType: logMessageType,
+    logMessageData: logMessageData,
+    logMessageBody: m.messageMetadata.adminText,
+    timestamp: m.messageMetadata.timestamp,
+    author: m.messageMetadata.actorFbId,
+    participantIDs: (m.participants || []).map(p => p.toString())
+  };
+}
+
+function formatTyp(event) {
+  return {
+    isTyping: !!event.st,
+    from: 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"
+  };
+}
+
+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"
+  };
+}
+
+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 new 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*/, "");
+
+  // (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
+  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 makeDefaults(html, userID, ctx) {
+  let reqCounter = 1;
+  const 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 = {};
+  // }
+
+  let ttstamp = "2";
+  for (let i = 0; i < fb_dtsg.length; i++) {
+    ttstamp += fb_dtsg.charCodeAt(i);
+  }
+  const revision = getFrom(html, 'revision":', ",");
+
+  function mergeWithDefaults(obj) {
+    // @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
+    const newObj = {
+      __user: userID,
+      __req: (reqCounter++).toString(36),
+      __rev: revision,
+      __a: 1,
+      // __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;
+
+    for (const prop in obj) {
+      if (obj.hasOwnProperty(prop)) {
+        if (!newObj[prop]) {
+          newObj[prop] = obj[prop];
+        }
+      }
+    }
+
+    return newObj;
+  }
+
+  function postWithDefaults(url, jar, form, ctxx, customHeader = {}) {
+    return post(url, jar, mergeWithDefaults(form), ctx.globalOptions, ctxx || ctx, customHeader);
+  }
+
+  function getWithDefaults(url, jar, qs, ctxx, customHeader = {}) {
+    return get(url, jar, mergeWithDefaults(qs), ctx.globalOptions, ctxx || ctx, customHeader);
+  }
+
+  function postFormDataWithDefault(url, jar, form, qs, ctxx) {
+    return postFormData(
+      url,
+      jar,
+      mergeWithDefaults(form),
+      mergeWithDefaults(qs),
+      ctx.globalOptions,
+      ctxx || ctx
+    );
+  }
+
+  return {
+    get: getWithDefaults,
+    post: postWithDefaults,
+    postFormData: postFormDataWithDefault
+  };
+}
+
+function parseAndCheckLogin(ctx, defaultFuncs, retryCount, sourceCall) {
+  if (retryCount == undefined) {
+    retryCount = 0;
+  }
+  if (sourceCall == undefined) {
+    try {
+      throw new Error();
+    }
+    catch (e) {
+      sourceCall = e;
+    }
+  }
+  return function (data) {
+    return tryPromise(function () {
+      log.verbose("parseAndCheckLogin", data.body);
+      if (data.statusCode >= 500 && data.statusCode < 600) {
+        if (retryCount >= 5) {
+          throw new CustomError({
+            message: "Request retry failed. Check the `res` and `statusCode` property on this error.",
+            statusCode: data.statusCode,
+            res: data.body,
+            error: "Request retry failed. Check the `res` and `statusCode` property on this error.",
+            sourceCall: sourceCall
+          });
+        }
+        retryCount++;
+        const retryTime = Math.floor(Math.random() * 5000);
+        log.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;
+        if (
+          data.request.headers["Content-Type"].split(";")[0] ===
+          "multipart/form-data"
+        ) {
+          return delay(retryTime)
+            .then(function () {
+              return defaultFuncs.postFormData(
+                url,
+                ctx.jar,
+                data.request.formData,
+                {}
+              );
+            })
+            .then(parseAndCheckLogin(ctx, defaultFuncs, retryCount, sourceCall));
+        }
+        else {
+          return delay(retryTime)
+            .then(function () {
+              return defaultFuncs.post(url, ctx.jar, data.request.formData);
+            })
+            .then(parseAndCheckLogin(ctx, defaultFuncs, retryCount, sourceCall));
+        }
+      }
+      if (data.statusCode !== 200)
+        throw new CustomError({
+          message: "parseAndCheckLogin got status code: " + data.statusCode + ". Bailing out of trying to parse response.",
+          statusCode: data.statusCode,
+          res: data.body,
+          error: "parseAndCheckLogin got status code: " + data.statusCode + ". Bailing out of trying to parse response.",
+          sourceCall: sourceCall
+        });
+
+      let res = null;
+      try {
+        res = JSON.parse(makeParsable(data.body));
+      } catch (e) {
+        throw new CustomError({
+          message: "JSON.parse error. Check the `detail` property on this error.",
+          detail: e,
+          res: data.body,
+          error: "JSON.parse error. Check the `detail` property on this error.",
+          sourceCall: sourceCall
+        });
+      }
+
+      // In some cases the response contains only a redirect URL which should be followed
+      if (res.redirect && data.request.method === "GET") {
+        return defaultFuncs
+          .get(res.redirect, ctx.jar)
+          .then(parseAndCheckLogin(ctx, defaultFuncs, undefined, sourceCall));
+      }
+
+      // 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_",
+          ""
+        );
+        const cookie = formatCookie(res.jsmods.require[0][3], "facebook");
+        const 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) {
+          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++) {
+              ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
+            }
+          }
+        }
+      }
+
+      if (res.error === 1357001) {
+        throw new CustomError({
+          message: "Facebook blocked login. Please visit https://facebook.com and check your account.",
+          error: "Not logged in.",
+          res: res,
+          statusCode: data.statusCode,
+          sourceCall: sourceCall
+        });
+      }
+      return res;
+    });
+  };
+}
+
+function checkLiveCookie(ctx, defaultFuncs) {
+  return defaultFuncs
+    .get("https://m.facebook.com/me", ctx.jar)
+    .then(function (res) {
+      if (res.body.indexOf(ctx.i_userID || ctx.userID) === -1) {
+        throw new CustomError({
+          message: "Not logged in.",
+          error: "Not logged in."
+        });
+      }
+      return true;
+    });
+}
+
+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) {
+  let d = date.getUTCDate();
+  d = d >= 10 ? d : "0" + d;
+  let h = date.getUTCHours();
+  h = h >= 10 ? h : "0" + h;
+  let m = date.getUTCMinutes();
+  m = m >= 10 ? m : "0" + m;
+  let 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, url) {
+  return (
+    arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + url + ".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, // what is this?
+    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 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
+  };
+}
+
+function formatPresence(presence, userID) {
+  return {
+    type: "presence",
+    timestamp: presence.la * 1000,
+    userID: userID,
+    statuses: presence.a
+  };
+}
+
+function decodeClientPayload(payload) {
+  /*
+  Special function which Client using to "encode" clients JSON payload
+  */
+  return JSON.parse(String.fromCharCode.apply(null, payload));
+}
+
+function getAppState(jar) {
+  return jar
+    .getCookies("https://www.facebook.com")
+    .concat(jar.getCookies("https://facebook.com"))
+    .concat(jar.getCookies("https://www.messenger.com"));
+}
+module.exports = {
+  CustomError,
+  isReadableStream,
+  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,
+  checkLiveCookie
+};