fca-neokex-fix 1.0.1

package/src/apis/mqttDeltaValue.js

@@ -0,0 +1,330 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
+  if (v.delta.class == "NewMessage") {
+
+    if (ctx.globalOptions.pageID && ctx.globalOptions.pageID != v.queue) return;
+    (function resolveAttachmentUrl(i) {
+      if (!v.delta.attachments || i == v.delta.attachments.length || utils.getType(v.delta.attachments) !== "Array") {
+        var fmtMsg;
+        try {
+          fmtMsg = utils.formatDeltaMessage(v);
+        } catch (err) {
+          return;
+        }
+        if (fmtMsg) {
+            if (ctx.globalOptions.autoMarkDelivery) {
+                api.markAsDelivered(fmtMsg.threadID, fmtMsg.messageID);
+            }
+            if (!ctx.globalOptions.selfListen && fmtMsg.senderID === ctx.userID) {
+                return;
+            }
+            return globalCallback(null, fmtMsg);
+        }
+      } else {
+         var attachment = v.delta.attachments[i];
+         if (attachment && attachment.mercury && attachment.mercury.attach_type == "photo") {
+          api.resolvePhotoUrl(attachment.fbid, (err, url) => {
+            if (!err) attachment.mercury.metadata.url = url;
+            return resolveAttachmentUrl(i + 1);
+          });
+         } else {
+            return resolveAttachmentUrl(i + 1);
+         }
+      }
+    })(0);
+  }
+
+  if (v.delta.class == "ClientPayload") {
+    var clientPayload = utils.decodeClientPayload(v.delta.payload);
+    if (clientPayload && clientPayload.deltas) {
+      for (var i in clientPayload.deltas) {
+        var delta = clientPayload.deltas[i];
+
+        if (delta.deltaMessageReaction && !!ctx.globalOptions.listenEvents) {
+            const reactionEvent = {
+              type: "message_reaction",
+              threadID: (delta.deltaMessageReaction.threadKey.threadFbId || delta.deltaMessageReaction.threadKey.otherUserFbId).toString(),
+              messageID: delta.deltaMessageReaction.messageId,
+              reaction: delta.deltaMessageReaction.reaction,
+              senderID: delta.deltaMessageReaction.userId.toString(),
+              userID: delta.deltaMessageReaction.userId.toString()
+            };
+
+            if (!ctx.globalOptions.selfListen && reactionEvent.senderID === ctx.userID) {
+              return;
+            }
+
+            globalCallback(null, reactionEvent);
+        } else if (delta.deltaRecallMessageData && !!ctx.globalOptions.listenEvents) {
+            globalCallback(null, {
+              type: "message_unsend",
+              threadID: (delta.deltaRecallMessageData.threadKey.threadFbId || delta.deltaRecallMessageData.threadKey.otherUserFbId).toString(),
+              messageID: delta.deltaRecallMessageData.messageID,
+              senderID: delta.deltaRecallMessageData.senderID.toString(),
+              deletionTimestamp: delta.deltaRecallMessageData.deletionTimestamp,
+              timestamp: delta.deltaRecallMessageData.timestamp
+            });
+        } else if (delta.deltaMessageReply) {
+          // Parse mentions from multiple possible sources
+          var mdata = [];
+          var msg = delta.deltaMessageReply.message;
+          var msgBody = msg.body || "";
+          
+          // Method 1: data.prng (old format)
+          if (msg?.data?.prng) {
+            try { mdata = JSON.parse(msg.data.prng); } catch (e) {}
+          }
+          // Method 2: data.mentions (newer format)
+          if (mdata.length === 0 && msg?.data?.mentions) {
+            try { mdata = JSON.parse(msg.data.mentions); } catch (e) {}
+          }
+          // Method 3: messageMetadata.ranges (latest format)
+          if (mdata.length === 0 && msg?.messageMetadata?.ranges) {
+            try {
+              mdata = msg.messageMetadata.ranges.map(r => ({
+                i: r.entity?.id || r.mentionID || r.id,
+                o: r.offset,
+                l: r.length
+              }));
+            } catch (e) {}
+          }
+          // Method 4: message.mentions directly
+          if (mdata.length === 0 && msg?.mentions) {
+            try {
+              if (Array.isArray(msg.mentions)) {
+                mdata = msg.mentions.map(mention => ({
+                  i: mention.id || mention.i,
+                  o: mention.offset || mention.o,
+                  l: mention.length || mention.l
+                }));
+              }
+            } catch (e) {}
+          }
+          
+          var mentions = {};
+          if (mdata) {
+            mdata.forEach(m => {
+              if (m.i && msgBody) {
+                mentions[m.i] = msgBody.substring(m.o, m.o + m.l);
+              }
+            });
+          }
+
+          var callbackToReturn = {
+            type: "message_reply",
+            threadID: (delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId || delta.deltaMessageReply.message.messageMetadata.threadKey.otherUserFbId).toString(),
+            messageID: delta.deltaMessageReply.message.messageMetadata.messageId,
+            senderID: delta.deltaMessageReply.message.messageMetadata.actorFbId.toString(),
+            attachments: delta.deltaMessageReply.message.attachments.map(att => {
+              try {
+                var mercury = JSON.parse(att.mercuryJSON);
+                Object.assign(att, mercury);
+                return utils._formatAttachment(att);
+              } catch (ex) {
+                return { ...att, error: ex, type: "unknown" };
+              }
+            }),
+            body: (delta.deltaMessageReply.message.body || ""),
+            isGroup: !!delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId,
+            mentions: mentions,
+            timestamp: delta.deltaMessageReply.message.messageMetadata.timestamp,
+            participantIDs: (delta.deltaMessageReply.message.participants || []).map(e => e.toString())
+          };
+
+          if (delta.deltaMessageReply.repliedToMessage) {
+            var rmdata = [];
+            var replyMsg = delta.deltaMessageReply.repliedToMessage;
+            var replyBody = replyMsg.body || "";
+            
+            // Method 1: data.prng (old format)
+            if (replyMsg?.data?.prng) {
+              try { rmdata = JSON.parse(replyMsg.data.prng); } catch (e) {}
+            }
+            // Method 2: data.mentions (newer format)
+            if (rmdata.length === 0 && replyMsg?.data?.mentions) {
+              try { rmdata = JSON.parse(replyMsg.data.mentions); } catch (e) {}
+            }
+            // Method 3: messageMetadata.ranges (latest format)
+            if (rmdata.length === 0 && replyMsg?.messageMetadata?.ranges) {
+              try {
+                rmdata = replyMsg.messageMetadata.ranges.map(r => ({
+                  i: r.entity?.id || r.mentionID || r.id,
+                  o: r.offset,
+                  l: r.length
+                }));
+              } catch (e) {}
+            }
+            // Method 4: mentions directly
+            if (rmdata.length === 0 && replyMsg?.mentions) {
+              try {
+                if (Array.isArray(replyMsg.mentions)) {
+                  rmdata = replyMsg.mentions.map(mention => ({
+                    i: mention.id || mention.i,
+                    o: mention.offset || mention.o,
+                    l: mention.length || mention.l
+                  }));
+                }
+              } catch (e) {}
+            }
+            
+            var rmentions = {};
+            if (rmdata) {
+              rmdata.forEach(m => {
+                if (m.i && replyBody) {
+                  rmentions[m.i] = replyBody.substring(m.o, m.o + m.l);
+                }
+              });
+            }
+
+            callbackToReturn.messageReply = {
+              threadID: (delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId || delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.otherUserFbId).toString(),
+              messageID: delta.deltaMessageReply.repliedToMessage.messageMetadata.messageId,
+              senderID: delta.deltaMessageReply.repliedToMessage.messageMetadata.actorFbId.toString(),
+              attachments: delta.deltaMessageReply.repliedToMessage.attachments.map(att => {
+                 try {
+                    var mercury = JSON.parse(att.mercuryJSON);
+                    Object.assign(att, mercury);
+                    return utils._formatAttachment(att);
+                  } catch (ex) {
+                    return { ...att, error: ex, type: "unknown" };
+                  }
+              }),
+              body: delta.deltaMessageReply.repliedToMessage.body || "",
+              isGroup: !!delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId,
+              mentions: rmentions,
+              timestamp: delta.deltaMessageReply.repliedToMessage.messageMetadata.timestamp,
+              participantIDs: (delta.deltaMessageReply.repliedToMessage.participants || []).map(e => e.toString())
+            };
+          }
+          if (ctx.globalOptions.autoMarkDelivery) api.markAsDelivered(callbackToReturn.threadID, callbackToReturn.messageID);
+          if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+          return globalCallback(null, callbackToReturn);
+        }
+      }
+      return;
+    }
+  }
+
+  if (v.delta.class !== "NewMessage" && !ctx.globalOptions.listenEvents) return;
+  switch (v.delta.class) {
+    case "ReadReceipt":
+      var fmtMsg;
+      try {
+        fmtMsg = utils.formatDeltaReadReceipt(v.delta);
+      } catch (err) {
+        return;
+      }
+      if (fmtMsg) globalCallback(null, fmtMsg);
+      break;
+    case "AdminTextMessage":
+      switch (v.delta.type) {
+        case "instant_game_dynamic_custom_update":
+        case "accept_pending_thread":
+        case "confirm_friend_request":
+        case "shared_album_delete":
+        case "shared_album_addition":
+        case "pin_messages_v2":
+        case "unpin_messages_v2":
+        case "change_thread_theme":
+        case "change_thread_nickname":
+        case "change_thread_icon":
+        case "change_thread_quick_reaction":
+        case "change_thread_admins":
+        case "group_poll":
+        case "joinable_group_link_mode_change":
+        case "magic_words":
+        case "change_thread_approval_mode":
+        case "messenger_call_log":
+        case "participant_joined_group_call":
+        case "rtc_call_log":
+        case "update_vote":
+          var fmtEvent;
+          try {
+            fmtEvent = utils.formatDeltaEvent(v.delta);
+          } catch (err) {
+            return;
+          }
+          if (fmtEvent) globalCallback(null, fmtEvent);
+          break;
+      }
+      break;
+    case "ThreadName":
+    case "ParticipantsAddedToGroupThread":
+    case "ParticipantLeftGroupThread":
+      var fmtEvent2;
+      try {
+        fmtEvent2 = utils.formatDeltaEvent(v.delta);
+      } catch (err) {
+        return;
+      }
+      if (!ctx.globalOptions.selfListen && fmtEvent2 && fmtEvent2.author && fmtEvent2.author.toString() === ctx.userID) return;
+      if (!ctx.loggedIn) return;
+      if (fmtEvent2) globalCallback(null, fmtEvent2);
+      break;
+    case "ForcedFetch":
+      if (!v.delta.threadKey) return;
+      var mid = v.delta.messageId;
+      var tid = v.delta.threadKey.threadFbId;
+      if (mid && tid) {
+        var form = {
+          av: ctx.globalOptions.pageID,
+          queries: JSON.stringify({
+            o0: {
+              doc_id: "2848441488556444",
+              query_params: {
+                thread_and_message_id: {
+                  thread_id: tid.toString(),
+                  message_id: mid
+                }
+              }
+            }
+          })
+        };
+        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then(resData => {
+            if (resData[resData.length - 1].error_results > 0) throw resData[0].o0.errors;
+            if (resData[resData.length - 1].successful_results === 0) throw { error: "forcedFetch: no successful_results" };
+            var fetchData = resData[0].o0.data.message;
+            if (utils.getType(fetchData) === "Object") {
+              if (fetchData.__typename === "UserMessage" && fetchData.extensible_attachment) {
+                var event = {
+                  type: "message",
+                  senderID: utils.formatID(fetchData.message_sender.id),
+                  body: fetchData.message.text || "",
+                  threadID: utils.formatID(tid.toString()),
+                  messageID: fetchData.message_id,
+                  attachments: [{
+                    type: "share",
+                    ID: fetchData.extensible_attachment.legacy_attachment_id,
+                    url: fetchData.extensible_attachment.story_attachment.url,
+                    title: fetchData.extensible_attachment.story_attachment.title_with_entities.text,
+                    description: fetchData.extensible_attachment.story_attachment.description ? fetchData.extensible_attachment.story_attachment.description.text : "",
+                    source: fetchData.extensible_attachment.story_attachment.source,
+                    image: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).uri,
+                    width: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).width,
+                    height: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).height,
+                    playable: ((fetchData.extensible_attachment.story_attachment.media || {}).is_playable || false),
+                    duration: ((fetchData.extensible_attachment.story_attachment.media || {}).playable_duration_in_ms || 0)
+                  }],
+                  mentions: {},
+                  timestamp: parseInt(fetchData.timestamp_precise),
+                  isGroup: fetchData.message_sender.id !== tid.toString()
+                };
+                globalCallback(null, event);
+              }
+            }
+          })
+          .catch(err => {});
+      }
+      break;
+  }
+}
+
+module.exports = {
+    parseDelta
+};

package/src/apis/muteThread.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function muteThread(threadID, muteSeconds, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        thread_fbid: threadID,
+        mute_settings: muteSeconds
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/change_mute_thread.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("muteThread", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/nickname.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) { 
+  /**
+   * Made by Choru Official 
+   * Mqtt
+   * Sets a nickname for a participant in a Facebook thread via MQTT.
+   *
+   * @param {string} nickname The new nickname to set.
+   * @param {string} threadID The ID of the thread.
+   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
+   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   */
+  return function setNickname(nickname, threadID, participantID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        _resolvePromise = resolve;
+        _rejectPromise = reject;
+    });
+
+    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
+        _callback = callback;
+        _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+        _callback = threadID;
+        threadID = null;
+        _initiatorID = callback;
+    } else if (utils.getType(participantID) === "Function" || utils.getType(participantID) === "AsyncFunction") {
+        _callback = participantID;
+        participantID = ctx.userID;
+        _initiatorID = callback;
+    }
+    else if (utils.getType(callback) === "string") {
+        _initiatorID = callback;
+        _callback = undefined;
+    } else {
+        _callback = undefined;
+        _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function (__err, __data) {
+        if (__err) _rejectPromise(__err);
+        else _resolvePromise(__data);
+      };
+    } else {
+      const originalCallback = _callback;
+      _callback = function(__err, __data) {
+        if (__err) {
+          originalCallback(__err);
+          _rejectPromise(__err);
+        } else {
+          originalCallback(null, __data);
+          _resolvePromise(__data);
+        }
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+    participantID = participantID || ctx.userID;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to set a nickname."));
+    }
+    if (typeof nickname !== 'string') {
+      return _callback(new Error("nickname must be a string."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      contact_id: participantID.toString(),
+      nickname: nickname,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '44',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_participant_nickname',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context = {
+      app_id: ctx.appID,
+      payload: {
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '24631415369801570',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    context.payload = JSON.stringify(context.payload);
+    
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err) {
+        return _callback(new Error(`MQTT publish failed for setNickname: ${err.message || err}`));
+      }
+      
+      const nicknameChangeEvent = {
+        type: "thread_nickname_update", 
+        threadID: threadID,
+        participantID: participantID,
+        newNickname: nickname,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, nicknameChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/src/apis/notes.js

@@ -0,0 +1,163 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @ChoruOfficial
+ * @description A module for interacting with Facebook Messenger Notes. This is not for creating notes on a user's profile page, but rather the temporary status-like notes in Messenger.
+ * @param {Object} defaultFuncs The default functions provided by the API wrapper.
+ * @param {Object} api The full API object.
+ * @param {Object} ctx The context object containing the user's session state (e.g., userID, jar).
+ * @returns {Object} An object containing methods to create, delete, recreate, and check notes.
+ */
+module.exports = function(defaultFuncs, api, ctx) {
+
+  /**
+   * @callback notesCallback
+   * @param {Error|null} error An error object if the request fails, otherwise null.
+   * @param {Object} [data] The data returned from the API.
+   */
+
+  /**
+   * Checks for the currently active note for the logged-in user.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object representing the current note.
+   */
+  function checkNote(callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogQuery",
+      variables: JSON.stringify({ scale: 2 }),
+      doc_id: "30899655739648624",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const currentNote = resData?.data?.viewer?.actor?.msgr_user_rich_status;
+        callback(null, currentNote);
+      })
+      .catch(err => {
+        utils.error("notes.checkNote", err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Creates a new note with the provided text. The note lasts for 24 hours (86400 seconds).
+   * @param {string} text The content of the note.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the note's creation status.
+   */
+  function createNote(text, privacy = "EVERYONE", callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const variables = {
+      input: {
+        client_mutation_id: Math.round(Math.random() * 10).toString(),
+        actor_id: ctx.userID,
+        description: text,
+        duration: 86400,
+        note_type: "TEXT_NOTE",
+        privacy,
+        session_id: utils.getGUID(),
+      },
+    };
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogCreationStepContentMutation",
+      variables: JSON.stringify(variables),
+      doc_id: "24060573783603122",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const status = resData?.data?.xfb_rich_status_create?.status;
+        if (!status) throw new Error("Could not find note status in the server response.");
+        callback(null, status);
+      })
+      .catch(err => {
+        utils.error("notes.createNote", err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Deletes a specific note by its ID.
+   * @param {string} noteID The ID of the note to be deleted.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the deletion.
+   */
+  function deleteNote(noteID, callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const variables = {
+      input: {
+        client_mutation_id: Math.round(Math.random() * 10).toString(),
+        actor_id: ctx.userID,
+        rich_status_id: noteID,
+      },
+    };
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useMWInboxTrayDeleteNoteMutation",
+      variables: JSON.stringify(variables),
+      doc_id: "9532619970198958",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const deletedStatus = resData?.data?.xfb_rich_status_delete;
+        if (!deletedStatus) throw new Error("Could not find deletion status in the server response.");
+        callback(null, deletedStatus);
+      })
+      .catch(err => {
+        utils.error("notes.deleteNote", err);
+        callback(err);
+      });
+  }
+
+  /**
+   * A convenience function that first deletes an old note and then creates a new one.
+   * @param {string} oldNoteID The ID of the note to delete.
+   * @param {string} newText The text for the new note.
+   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object containing the deletion and creation statuses.
+   */
+  function recreateNote(oldNoteID, newText, callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    deleteNote(oldNoteID, (err, deleted) => {
+      if (err) {
+        return callback(err);
+      }
+      createNote(newText, (err, created) => {
+        if (err) {
+          return callback(err);
+        }
+        callback(null, { deleted, created });
+      });
+    });
+  }
+
+  return {
+    create: createNote,
+    delete: deleteNote,
+    recreate: recreateNote,
+    check: checkNote,
+  };
+};