disney.js 0.0.1-security → 0.2.2

package/dist/disney.js.cjs.development.js

@@ -0,0 +1,1872 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var commonTags = require('common-tags');
+var socket_ioClient = require('socket.io-client');
+var axios = _interopDefault(require('axios'));
+
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) keys.push(key);
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var Service = /*#__PURE__*/function () {
+  function Service() {}
+
+  var _proto = Service.prototype;
+
+  _proto.setWorker = function setWorker(worker) {
+    this._worker = worker;
+    return this;
+  };
+
+  _createClass(Service, [{
+    key: "worker",
+    get: function get() {
+      if (!this._worker) throw new Error('Worker is not initialized');
+      return this._worker;
+    }
+  }, {
+    key: "guild",
+    get: function get() {
+      if (!this._worker) throw new Error('Worker is not initialized');
+      return this.worker.guild;
+    }
+  }]);
+
+  return Service;
+}();
+
+var Worker = /*#__PURE__*/function () {
+  function Worker(_connection, _botMember, _guild) {
+    this._connection = _connection;
+    this._botMember = _botMember;
+    this._guild = _guild;
+  }
+
+  _createClass(Worker, [{
+    key: "connection",
+    get: function get() {
+      return this._connection;
+    }
+  }, {
+    key: "botMember",
+    get: function get() {
+      return this._botMember;
+    }
+  }, {
+    key: "guild",
+    get: function get() {
+      return this._guild;
+    }
+  }]);
+
+  return Worker;
+}();
+
+var UserSocketEvent;
+
+(function (UserSocketEvent) {
+  UserSocketEvent["ONLINE"] = "online";
+  UserSocketEvent["UPDATE_PROFILE"] = "updateProfile";
+  UserSocketEvent["ADD_FRIEND"] = "addFriend";
+  UserSocketEvent["ACCEPT_FRIEND"] = "acceptFriend";
+  UserSocketEvent["BLOCK_FRIEND"] = "blockFriend";
+})(UserSocketEvent || (UserSocketEvent = {}));
+
+var GuildSocketEvent;
+
+(function (GuildSocketEvent) {
+  GuildSocketEvent["CREATE"] = "create";
+  GuildSocketEvent["UPDATE"] = "update";
+  GuildSocketEvent["GET_ONE"] = "getOne";
+  GuildSocketEvent["GET_JOINED"] = "getJoined";
+  GuildSocketEvent["DELETE"] = "delete";
+})(GuildSocketEvent || (GuildSocketEvent = {}));
+
+var MemberSocketEvent;
+
+(function (MemberSocketEvent) {
+  MemberSocketEvent["GET_JOINED"] = "getJoined";
+  MemberSocketEvent["ONLINE"] = "online";
+  MemberSocketEvent["UPDATE"] = "update";
+  MemberSocketEvent["USER_JOIN"] = "userJoin";
+  MemberSocketEvent["BOT_JOIN"] = "botJoin";
+  MemberSocketEvent["LEAVE"] = "leave";
+})(MemberSocketEvent || (MemberSocketEvent = {}));
+
+var ChannelCtgSocketEvent;
+
+(function (ChannelCtgSocketEvent) {
+  ChannelCtgSocketEvent["CREATE"] = "create";
+  ChannelCtgSocketEvent["UPDATE"] = "update";
+  ChannelCtgSocketEvent["DELETE"] = "delete";
+})(ChannelCtgSocketEvent || (ChannelCtgSocketEvent = {}));
+
+var ChannelSocketEvent;
+
+(function (ChannelSocketEvent) {
+  ChannelSocketEvent["CREATE"] = "create";
+  ChannelSocketEvent["UPDATE"] = "update";
+  ChannelSocketEvent["DELETE"] = "delete";
+  ChannelSocketEvent["ADD_MEMBER"] = "addMember";
+  ChannelSocketEvent["REMOVE_MEMBER"] = "removeMember";
+})(ChannelSocketEvent || (ChannelSocketEvent = {}));
+
+var RoleSocketEvent;
+
+(function (RoleSocketEvent) {
+  RoleSocketEvent["CREATE"] = "create";
+  RoleSocketEvent["UPDATE"] = "update";
+  RoleSocketEvent["DELETE"] = "delete";
+  RoleSocketEvent["ADD_TO_MEMBER"] = "addToMember";
+  RoleSocketEvent["REMOVE_FROM_MEMBER"] = "removeFromMember";
+  RoleSocketEvent["ADD_TO_CHANNEL"] = "addToChannel";
+  RoleSocketEvent["REMOVE_FROM_CHANNEL"] = "removeFromChannel";
+})(RoleSocketEvent || (RoleSocketEvent = {}));
+
+var MessageSocketEvent;
+
+(function (MessageSocketEvent) {
+  MessageSocketEvent["FIND"] = "find";
+  MessageSocketEvent["CREATE"] = "create";
+  MessageSocketEvent["UPDATE"] = "update";
+  MessageSocketEvent["DELETE"] = "delete";
+})(MessageSocketEvent || (MessageSocketEvent = {}));
+
+var EmojiSocketEvent;
+
+(function (EmojiSocketEvent) {
+  EmojiSocketEvent["CREATE"] = "create";
+  EmojiSocketEvent["UPDATE"] = "update";
+  EmojiSocketEvent["DELETE"] = "delete";
+})(EmojiSocketEvent || (EmojiSocketEvent = {}));
+
+var ReactSocketEvent;
+
+(function (ReactSocketEvent) {
+  ReactSocketEvent["CREATE"] = "create";
+  ReactSocketEvent["UPDATE"] = "update";
+  ReactSocketEvent["DELETE"] = "delete";
+})(ReactSocketEvent || (ReactSocketEvent = {}));
+
+var SocketNamespace;
+
+(function (SocketNamespace) {
+  SocketNamespace["USER"] = "user";
+  SocketNamespace["GUILD"] = "guild";
+  SocketNamespace["CHANNEL"] = "channel";
+  SocketNamespace["CHANNEL_CATEGORY"] = "channel-category";
+  SocketNamespace["MEMBER"] = "member";
+  SocketNamespace["ROLE"] = "role";
+  SocketNamespace["EMOJI"] = "emoji";
+  SocketNamespace["REACT"] = "react";
+  SocketNamespace["MESSAGE"] = "message";
+  SocketNamespace["BUTTON"] = "button";
+  SocketNamespace["ACTION"] = "action";
+  SocketNamespace["SELECT"] = "select";
+})(SocketNamespace || (SocketNamespace = {}));
+
+var UserSocketEmit;
+
+(function (UserSocketEmit) {
+  UserSocketEmit["ONLINE"] = "online";
+  UserSocketEmit["UPDATE_PROFILE"] = "updateProfile";
+  UserSocketEmit["ADD_FRIEND"] = "addFriend";
+  UserSocketEmit["ACCEPT_FRIEND"] = "acceptFriend";
+  UserSocketEmit["BLOCK_FRIEND"] = "blockFriend";
+})(UserSocketEmit || (UserSocketEmit = {}));
+
+var GuildSocketEmit;
+
+(function (GuildSocketEmit) {
+  GuildSocketEmit["UPDATE"] = "update";
+  GuildSocketEmit["DELETE"] = "delete";
+})(GuildSocketEmit || (GuildSocketEmit = {}));
+
+var MemberSocketEmit;
+
+(function (MemberSocketEmit) {
+  MemberSocketEmit["JOIN"] = "join";
+  MemberSocketEmit["LEAVE"] = "leave";
+  MemberSocketEmit["UPDATE"] = "ipdate";
+  MemberSocketEmit["ONLINE"] = "online";
+})(MemberSocketEmit || (MemberSocketEmit = {}));
+
+var ChannelCtgSocketEmit;
+
+(function (ChannelCtgSocketEmit) {
+  ChannelCtgSocketEmit["CREATE"] = "create";
+  ChannelCtgSocketEmit["UPDATE"] = "update";
+  ChannelCtgSocketEmit["DELETE"] = "delete";
+})(ChannelCtgSocketEmit || (ChannelCtgSocketEmit = {}));
+
+var ChannelSocketEmit;
+
+(function (ChannelSocketEmit) {
+  ChannelSocketEmit["CREATE"] = "create";
+  ChannelSocketEmit["UPDATE"] = "update";
+  ChannelSocketEmit["DELETE"] = "delete";
+  ChannelSocketEmit["ADD_MEMBER"] = "addMember";
+  ChannelSocketEmit["REMOVE_MEMBER"] = "removeMember";
+})(ChannelSocketEmit || (ChannelSocketEmit = {}));
+
+var RoleSocketEmit;
+
+(function (RoleSocketEmit) {
+  RoleSocketEmit["CREATE"] = "create";
+  RoleSocketEmit["UPDATE"] = "update";
+  RoleSocketEmit["DELETE"] = "delete";
+  RoleSocketEmit["ADD_TO_MEMBER"] = "addToMember";
+  RoleSocketEmit["REMOVE_FROM_MEMBER"] = "removeFromMember";
+  RoleSocketEmit["ADD_TO_CHANNEL"] = "addToChannel";
+  RoleSocketEmit["REMOVE_FROM_CHANNEL"] = "removeFromChannel";
+})(RoleSocketEmit || (RoleSocketEmit = {}));
+
+var MessageSocketEmit;
+
+(function (MessageSocketEmit) {
+  MessageSocketEmit["CREATE"] = "create";
+  MessageSocketEmit["UPDATE"] = "update";
+  MessageSocketEmit["DELETE"] = "delete";
+})(MessageSocketEmit || (MessageSocketEmit = {}));
+
+var EmojiSocketEmit;
+
+(function (EmojiSocketEmit) {
+  EmojiSocketEmit["CREATE"] = "create";
+  EmojiSocketEmit["UPDATE"] = "update";
+  EmojiSocketEmit["DELETE"] = "delete";
+})(EmojiSocketEmit || (EmojiSocketEmit = {}));
+
+var ReactSocketEmit;
+
+(function (ReactSocketEmit) {
+  ReactSocketEmit["CREATE"] = "create";
+  ReactSocketEmit["UPDATE"] = "update";
+  ReactSocketEmit["DELETE"] = "delete";
+})(ReactSocketEmit || (ReactSocketEmit = {}));
+
+var ButtonSocketEmit;
+
+(function (ButtonSocketEmit) {
+  ButtonSocketEmit["CLICK"] = "click";
+})(ButtonSocketEmit || (ButtonSocketEmit = {}));
+
+var SelectSocketEmit;
+
+(function (SelectSocketEmit) {
+  SelectSocketEmit["SELECT"] = "select";
+})(SelectSocketEmit || (SelectSocketEmit = {}));
+
+var MessageAction = /*#__PURE__*/function () {
+  function MessageAction() {
+    this.buttons = [];
+    this.reacts = [];
+    this.selects = [];
+  }
+
+  var _proto = MessageAction.prototype;
+
+  _proto.clearButton = function clearButton() {
+    this.buttons = [];
+    return this;
+  };
+
+  _proto.clearReact = function clearReact() {
+    this.reacts = [];
+    return this;
+  };
+
+  _proto.clearSelect = function clearSelect() {
+    this.selects = [];
+    return this;
+  };
+
+  _proto.clearAction = function clearAction() {
+    this.clearButton();
+    this.clearReact();
+    this.clearSelect();
+    return this;
+  };
+
+  _proto.addButton = function addButton(button) {
+    this.buttons.push(button.getData());
+    return this;
+  };
+
+  _proto.addButtons = function addButtons(buttons) {
+    this.buttons = this.buttons.concat(buttons.map(function (button) {
+      return button.getData();
+    }));
+    return this;
+  };
+
+  _proto.addReact = function addReact(emoji) {
+    this.reacts.push({
+      emoji: emoji
+    });
+    return this;
+  };
+
+  _proto.addReacts = function addReacts(emojis) {
+    this.reacts = this.reacts.concat(emojis.map(function (emoji) {
+      return {
+        emoji: emoji
+      };
+    }));
+    return this;
+  };
+
+  _proto.addSelect = function addSelect(select) {
+    this.selects.push(select.getData());
+    return this;
+  };
+
+  _proto.getData = function getData() {
+    return {
+      buttons: this.buttons,
+      reacts: this.reacts,
+      selects: this.selects
+    };
+  };
+
+  _proto.setId = function setId(id) {
+    this._actionId = id;
+    return this;
+  };
+
+  _proto.setConnection = function setConnection(connection) {
+    this._connection = connection;
+    return this;
+  };
+
+  _proto.onButtonClick = function onButtonClick(callback) {
+    this.checkId();
+
+    this._connection.button.on(this._actionId + "/" + SocketNamespace.BUTTON + "/" + ButtonSocketEmit.CLICK, function (interaction) {
+      callback(interaction);
+    });
+  };
+
+  _proto.onReactCreate = function onReactCreate(callback) {
+    this.checkId();
+
+    this._connection.react.on(this._actionId + "/" + SocketNamespace.REACT + "/" + ReactSocketEmit.CREATE, function (react) {
+      callback(react);
+    });
+  };
+
+  _proto.onReactDelete = function onReactDelete(callback) {
+    this.checkId();
+
+    this._connection.react.on(this._actionId + "/" + SocketNamespace.REACT + "/" + ReactSocketEmit.DELETE, function (react) {
+      callback(react);
+    });
+  };
+
+  _proto.onSelect = function onSelect(callback) {
+    this.checkId();
+
+    this._connection.select.on(this._actionId + "/" + SocketNamespace.SELECT + "/" + SelectSocketEmit.SELECT, function (interaction) {
+      callback(interaction);
+    });
+  };
+
+  _proto.checkId = function checkId() {
+    if (!this._actionId) throw new Error('Listener must be start in advance the message sent');
+  };
+
+  return MessageAction;
+}();
+
+var MessageService = /*#__PURE__*/function (_Service) {
+  _inheritsLoose(MessageService, _Service);
+
+  function MessageService(_client, _connection, initMessage) {
+    var _this;
+
+    _this = _Service.call(this) || this;
+    _this._client = _client;
+    _this._connection = _connection;
+    _this._route = _client.bot.info.botId + "/" + SocketNamespace.MESSAGE;
+
+    if (initMessage) {
+      _this._message = initMessage;
+    }
+
+    _this._action = new MessageAction();
+    return _this;
+  }
+
+  var _proto = MessageService.prototype;
+
+  _proto.onCreate = function onCreate(callback) {
+    var _this2 = this;
+
+    this._connection.message.on(this._route + "/create", function (message, inspectedCommand, guild) {
+      var member = _this2._client.bot.info.joinedGuilds.find(function (g) {
+        return g.guild.guildId === guild.guildId;
+      });
+
+      if (!member) {
+        throw new Error('Bot is not in this guild');
+      }
+
+      _this2._inspectedCommand = inspectedCommand;
+      _this2._message = message;
+      var worker = new Worker(_this2._connection.message, member, guild);
+
+      _this2.setWorker(worker);
+
+      callback({
+        worker: worker
+      });
+    });
+  };
+
+  _proto.onUpdate = function onUpdate(callback) {
+    this._connection.message.on(this._route + "/update", callback);
+  };
+
+  _proto.onDelete = function onDelete(callback) {
+    this._connection.message.on(this._route + "/delete", callback);
+  };
+
+  _proto.send = /*#__PURE__*/function () {
+    var _send = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(message) {
+      var _this3 = this;
+
+      var m;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return new Promise(function (resolve) {
+                _this3._connection.message.emit(MessageSocketEvent.CREATE, {
+                  message: _extends({}, message, {
+                    action: _this3._action.getData()
+                  }),
+                  channel: _this3._message.channel,
+                  member: _this3.worker.botMember,
+                  memberId: _this3.worker.botMember.memberId
+                }, function (m) {
+                  return resolve(m);
+                });
+              });
+
+            case 2:
+              m = _context.sent;
+              this.updateAction(m.action);
+              return _context.abrupt("return", this.clone().setMessage(m));
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function send(_x) {
+      return _send.apply(this, arguments);
+    }
+
+    return send;
+  }();
+
+  _proto.edit = /*#__PURE__*/function () {
+    var _edit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(message) {
+      var _this4 = this;
+
+      var m;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return new Promise(function (resolve) {
+                var _message$action;
+
+                _this4._connection.message.emit(MessageSocketEvent.UPDATE, {
+                  message: _extends({}, message, {
+                    action: (_message$action = message.action) == null ? void 0 : _message$action.getData(),
+                    messageId: _this4._message.messageId
+                  }),
+                  memberId: _this4.worker.botMember.memberId
+                }, function (m) {
+                  return resolve(m);
+                });
+              });
+
+            case 2:
+              m = _context2.sent;
+              this.updateAction(m.action);
+              return _context2.abrupt("return", this.clone().setMessage(m));
+
+            case 5:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function edit(_x2) {
+      return _edit.apply(this, arguments);
+    }
+
+    return edit;
+  }();
+
+  _proto.reply = /*#__PURE__*/function () {
+    var _reply = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(message) {
+      var _this5 = this;
+
+      var m;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return new Promise(function (resolve) {
+                var _message$action2;
+
+                _this5._connection.message.emit(MessageSocketEvent.CREATE, {
+                  message: _extends({}, message, {
+                    action: (_message$action2 = message.action) == null ? void 0 : _message$action2.getData(),
+                    messageId: _this5._message.messageId
+                  }),
+                  member: _this5.worker.botMember,
+                  replyTo: _this5._message.messageId,
+                  memberId: _this5.worker.botMember.memberId
+                }, function (m) {
+                  return resolve(m);
+                });
+              });
+
+            case 2:
+              m = _context3.sent;
+              this.updateAction(m.action);
+              return _context3.abrupt("return", this.clone().setMessage(m));
+
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function reply(_x3) {
+      return _reply.apply(this, arguments);
+    }
+
+    return reply;
+  }();
+
+  _proto.setMessage = function setMessage(message) {
+    this._message = message;
+    return this;
+  };
+
+  _proto.setAction = function setAction(action) {
+    this._action = action;
+  };
+
+  _proto.updateAction = function updateAction(action) {
+    this._action.setId(action.actionId).setConnection(this._connection);
+  };
+
+  _proto.clone = function clone() {
+    var newService = new MessageService(this._client, this._connection);
+    newService.setWorker(this.worker);
+    newService.setMessage(this._message);
+    newService._action = this._action;
+    return newService;
+  };
+
+  _createClass(MessageService, [{
+    key: "data",
+    get: function get() {
+      if (!this._message) throw new Error('Message is not initialized');
+      return this._message;
+    }
+  }, {
+    key: "command",
+    get: function get() {
+      return this._inspectedCommand;
+    }
+  }, {
+    key: "action",
+    get: function get() {
+      return this._action;
+    }
+  }]);
+
+  return MessageService;
+}(Service);
+
+var MarkdownBuilder = /*#__PURE__*/function () {
+  function MarkdownBuilder() {}
+
+  MarkdownBuilder.bold = function bold(text) {
+    return "**" + text + "**";
+  };
+
+  MarkdownBuilder.italic = function italic(text) {
+    return "*" + text + "*";
+  };
+
+  MarkdownBuilder.underline = function underline(text) {
+    return "__" + text + "__";
+  };
+
+  MarkdownBuilder.strikethrough = function strikethrough(text) {
+    return "~~" + text + "~~";
+  };
+
+  MarkdownBuilder.inlineCode = function inlineCode(text) {
+    return "`" + text + "`";
+  };
+
+  MarkdownBuilder.codeBlock = function codeBlock(text, language) {
+    if (language) {
+      return "```" + language + "\n" + text + "\n```";
+    }
+
+    return "```" + text + "```";
+  };
+
+  MarkdownBuilder.link = function link(text, url) {
+    return "[" + text + "](" + url + ")";
+  };
+
+  MarkdownBuilder.image = function image(text, url) {
+    return "![" + text + "](" + url + ")";
+  };
+
+  _createClass(MarkdownBuilder, null, [{
+    key: "tag",
+    get: function get() {
+      return commonTags.stripIndent;
+    }
+  }]);
+
+  return MarkdownBuilder;
+}();
+
+(function (ButtonStyle) {
+  ButtonStyle["PRIMARY"] = "primary";
+  ButtonStyle["SECONDARY"] = "secondary";
+  ButtonStyle["SUCCESS"] = "success";
+  ButtonStyle["WARNING"] = "warning";
+  ButtonStyle["ERROR"] = "error";
+})(exports.ButtonStyle || (exports.ButtonStyle = {}));
+
+var MessageButton = /*#__PURE__*/function () {
+  function MessageButton() {}
+
+  var _proto = MessageButton.prototype;
+
+  _proto.setName = function setName(name) {
+    this._name = name;
+    return this;
+  };
+
+  _proto.setCustomId = function setCustomId(customId) {
+    this._customId = customId;
+    return this;
+  };
+
+  _proto.setDisabled = function setDisabled(disabled) {
+    this._isDisabled = disabled;
+    return this;
+  };
+
+  _proto.setStyle = function setStyle(style) {
+    this._style = style;
+    return this;
+  };
+
+  _proto.getData = function getData() {
+    return {
+      name: this._name,
+      customId: this._customId,
+      isDisabled: this._isDisabled,
+      style: this._style
+    };
+  };
+
+  _createClass(MessageButton, [{
+    key: "name",
+    get: function get() {
+      return this._name;
+    }
+  }, {
+    key: "customId",
+    get: function get() {
+      return this._customId;
+    }
+  }, {
+    key: "isDisabled",
+    get: function get() {
+      return this._isDisabled;
+    }
+  }, {
+    key: "style",
+    get: function get() {
+      return this._style;
+    }
+  }]);
+
+  return MessageButton;
+}();
+
+(function (SelectStyle) {
+  SelectStyle["PRIMARY"] = "primary";
+  SelectStyle["SECONDARY"] = "secondary";
+})(exports.SelectStyle || (exports.SelectStyle = {}));
+
+var MessageSelect = /*#__PURE__*/function () {
+  function MessageSelect() {
+    this._options = [];
+  }
+
+  var _proto = MessageSelect.prototype;
+
+  _proto.clearOption = function clearOption() {
+    this._options = [];
+    return this;
+  };
+
+  _proto.addOption = function addOption(option) {
+    this._options.push(option.getData());
+
+    return this;
+  };
+
+  _proto.addOptions = function addOptions(options) {
+    this._options = this._options.concat(options.map(function (option) {
+      return option.getData();
+    }));
+    return this;
+  };
+
+  _proto.setDisabled = function setDisabled(disabled) {
+    this._isDisabled = disabled;
+    return this;
+  };
+
+  _proto.setStyle = function setStyle(style) {
+    this._style = style;
+    return this;
+  };
+
+  _proto.setCustomId = function setCustomId(customId) {
+    this._customId = customId;
+    return this;
+  };
+
+  _proto.getData = function getData() {
+    return {
+      customId: this._customId,
+      isDisabled: this._isDisabled,
+      style: this._style,
+      options: this._options
+    };
+  };
+
+  _createClass(MessageSelect, [{
+    key: "customId",
+    get: function get() {
+      return this._customId;
+    }
+  }, {
+    key: "isDisabled",
+    get: function get() {
+      return this._isDisabled;
+    }
+  }, {
+    key: "style",
+    get: function get() {
+      return this._style;
+    }
+  }, {
+    key: "options",
+    get: function get() {
+      return this._options;
+    }
+  }]);
+
+  return MessageSelect;
+}();
+var MessageSelectOption = /*#__PURE__*/function () {
+  function MessageSelectOption() {}
+
+  var _proto2 = MessageSelectOption.prototype;
+
+  _proto2.setDescription = function setDescription(description) {
+    this._description = description;
+    return this;
+  };
+
+  _proto2.setValue = function setValue(value) {
+    this._value = value;
+    return this;
+  };
+
+  _proto2.getData = function getData() {
+    return {
+      description: this._description,
+      value: this._value
+    };
+  };
+
+  _createClass(MessageSelectOption, [{
+    key: "description",
+    get: function get() {
+      return this._description;
+    }
+  }, {
+    key: "value",
+    get: function get() {
+      return this._value;
+    }
+  }]);
+
+  return MessageSelectOption;
+}();
+
+var ChannelService = /*#__PURE__*/function (_Service) {
+  _inheritsLoose(ChannelService, _Service);
+
+  function ChannelService(_client, _connection) {
+    var _this;
+
+    _this = _Service.call(this) || this;
+    _this._client = _client;
+    _this._connection = _connection;
+    _this._route = _client.bot.info.botId + "/message";
+    return _this;
+  }
+
+  var _proto = ChannelService.prototype;
+
+  _proto.withIdOrName = function withIdOrName(channelNameOrId) {
+    var existChannel = this.worker.guild.categories.map(function (c) {
+      return c.channels;
+    }).flat().find(function (c) {
+      return c.name.toLowerCase() === channelNameOrId.toLowerCase() || c.channelId === channelNameOrId;
+    });
+
+    if (!existChannel) {
+      throw new Error('Channel not found');
+    }
+
+    var newService = this.clone();
+    newService.setChannel(existChannel);
+    return newService;
+  };
+
+  _proto.update = /*#__PURE__*/function () {
+    var _update = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(channel) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              this._connection.channel.emit(ChannelSocketEvent.UPDATE, {
+                channel: _extends({
+                  channelId: this._channel.channelId
+                }, channel),
+                memberId: this.worker.botMember.memberId
+              });
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function update(_x) {
+      return _update.apply(this, arguments);
+    }
+
+    return update;
+  }();
+
+  _proto.addMember = /*#__PURE__*/function () {
+    var _addMember = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(memberNicknameOrId) {
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.updateMemberOfChannel(ChannelSocketEvent.ADD_MEMBER, this._channel.channelId, memberNicknameOrId);
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function addMember(_x2) {
+      return _addMember.apply(this, arguments);
+    }
+
+    return addMember;
+  }();
+
+  _proto.removeMember = /*#__PURE__*/function () {
+    var _removeMember = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(memberNicknameOrId) {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.updateMemberOfChannel(ChannelSocketEvent.REMOVE_MEMBER, this._channel.channelId, memberNicknameOrId);
+
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function removeMember(_x3) {
+      return _removeMember.apply(this, arguments);
+    }
+
+    return removeMember;
+  }();
+
+  _proto.addRole = /*#__PURE__*/function () {
+    var _addRole = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(roleNameOrId) {
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.updateRoleOfChannel(RoleSocketEvent.ADD_TO_CHANNEL, this._channel.channelId, roleNameOrId);
+
+            case 2:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function addRole(_x4) {
+      return _addRole.apply(this, arguments);
+    }
+
+    return addRole;
+  }();
+
+  _proto.removeRole = /*#__PURE__*/function () {
+    var _removeRole = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(roleNameOrId) {
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.updateRoleOfChannel(RoleSocketEvent.REMOVE_FROM_CHANNEL, this._channel.channelId, roleNameOrId);
+
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function removeRole(_x5) {
+      return _removeRole.apply(this, arguments);
+    }
+
+    return removeRole;
+  }();
+
+  _proto.setChannel = function setChannel(channel) {
+    this._channel = channel;
+  };
+
+  _proto.inCategory = function inCategory(categoryNameOrId) {
+    var _this2 = this;
+
+    var category = this.worker.guild.categories.find(function (c) {
+      return c.name.toLowerCase() === categoryNameOrId.toLowerCase() || c.categoryId === categoryNameOrId;
+    });
+
+    if (!category) {
+      throw new Error('Category not found');
+    }
+
+    return {
+      create: function create(channel) {
+        _this2._connection.channel.emit('create', {
+          channel: channel,
+          category: category,
+          firstMember: _this2.worker.botMember,
+          memberId: _this2.worker.botMember.memberId
+        });
+      }
+    };
+  };
+
+  _proto.clone = function clone() {
+    var newService = new ChannelService(this._client, this._connection);
+    newService.setChannel(this._channel);
+    newService.setWorker(this.worker);
+    return newService;
+  };
+
+  _proto.updateMemberOfChannel = /*#__PURE__*/function () {
+    var _updateMemberOfChannel = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(event, channelId, memberNicknameOrId) {
+      var existMember;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              existMember = this.worker.guild.members.find(function (m) {
+                return m.nickname.toLowerCase() === memberNicknameOrId.toLowerCase() || m.memberId === memberNicknameOrId;
+              });
+
+              if (existMember) {
+                _context6.next = 3;
+                break;
+              }
+
+              throw new Error('Member not found');
+
+            case 3:
+              this._connection.channel.emit(event, {
+                channel: {
+                  channelId: channelId,
+                  memberId: existMember.memberId
+                },
+                memberId: this.worker.botMember.memberId
+              });
+
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
+
+    function updateMemberOfChannel(_x6, _x7, _x8) {
+      return _updateMemberOfChannel.apply(this, arguments);
+    }
+
+    return updateMemberOfChannel;
+  }();
+
+  _proto.updateRoleOfChannel = /*#__PURE__*/function () {
+    var _updateRoleOfChannel = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(event, channelId, roleNameOrId) {
+      var existRole;
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              existRole = this.worker.guild.roles.find(function (r) {
+                return r.name.toLowerCase() === roleNameOrId.toLowerCase() || r.roleId === roleNameOrId;
+              });
+
+              if (existRole) {
+                _context7.next = 3;
+                break;
+              }
+
+              throw new Error('Role not found');
+
+            case 3:
+              this._connection.role.emit(event, {
+                channel: {
+                  channelId: channelId,
+                  roleId: existRole.roleId
+                },
+                memberId: this.worker.botMember.memberId
+              });
+
+            case 4:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7, this);
+    }));
+
+    function updateRoleOfChannel(_x9, _x10, _x11) {
+      return _updateRoleOfChannel.apply(this, arguments);
+    }
+
+    return updateRoleOfChannel;
+  }();
+
+  _createClass(ChannelService, [{
+    key: "data",
+    get: function get() {
+      if (!this._channel) throw new Error('Channel is not initialized');
+      return this._channel;
+    }
+  }]);
+
+  return ChannelService;
+}(Service);
+
+var Config = function Config() {};
+Config.SERVER_HOST = 'https://c522-116-102-222-20.ap.ngrok.io';
+
+(function (FriendStatus) {
+  FriendStatus["ACCEPTED"] = "accepted";
+  FriendStatus["PENDING"] = "pending";
+  FriendStatus["BLOCKED"] = "blocked";
+})(exports.FriendStatus || (exports.FriendStatus = {}));
+
+var BotInfo = /*#__PURE__*/function () {
+  function BotInfo(_connection) {
+    this._connection = _connection;
+  }
+
+  var _proto = BotInfo.prototype;
+
+  _proto.getInfo = /*#__PURE__*/function () {
+    var _getInfo = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(token) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return axios.get(Config.SERVER_HOST + "/bot", {
+                headers: {
+                  Authorization: "Bearer " + token
+                }
+              });
+
+            case 3:
+              this._info = _context.sent.data;
+              _context.next = 9;
+              break;
+
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](0);
+              throw new Error('Token is invalid or expired');
+
+            case 9:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this, [[0, 6]]);
+    }));
+
+    function getInfo(_x) {
+      return _getInfo.apply(this, arguments);
+    }
+
+    return getInfo;
+  }();
+
+  _proto.listenUpdate = function listenUpdate() {
+    var _this = this;
+
+    this._connection.member.on(this._info.botId + "/" + SocketNamespace.MEMBER + "/" + MemberSocketEmit.JOIN, function (member) {
+      _this._info.joinedGuilds.push(member);
+    });
+
+    this._connection.member.on(this._info.botId + "/" + SocketNamespace.MEMBER + "/" + MemberSocketEmit.LEAVE, function (member) {
+      _this._info.joinedGuilds = _this._info.joinedGuilds.filter(function (m) {
+        return m.memberId !== member.memberId;
+      });
+    });
+  };
+
+  _createClass(BotInfo, [{
+    key: "info",
+    get: function get() {
+      return this._info;
+    }
+  }]);
+
+  return BotInfo;
+}();
+
+var Connection = function Connection(gateway) {
+  this.message = gateway.socket("/" + SocketNamespace.MESSAGE);
+  this.channel = gateway.socket("/" + SocketNamespace.CHANNEL);
+  this.role = gateway.socket("/" + SocketNamespace.ROLE);
+  this.member = gateway.socket("/" + SocketNamespace.MEMBER);
+  this.action = gateway.socket("/" + SocketNamespace.ACTION);
+  this.button = gateway.socket("/" + SocketNamespace.BUTTON);
+  this.react = gateway.socket("/" + SocketNamespace.REACT);
+  this.select = gateway.socket("/" + SocketNamespace.SELECT);
+};
+
+var Client = /*#__PURE__*/function () {
+  function Client() {}
+
+  var _proto = Client.prototype;
+
+  _proto.login = /*#__PURE__*/function () {
+    var _login = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(token) {
+      var _iterator, _step, command;
+
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              this._accessToken = token;
+              this._gateway = new socket_ioClient.Manager(Config.SERVER_HOST, {
+                transportOptions: {
+                  polling: {
+                    extraHeaders: {
+                      authorization: "Bearer " + this._accessToken
+                    }
+                  }
+                }
+              });
+              this._connection = new Connection(this._gateway);
+              this._bot = new BotInfo(this._connection);
+              _context.next = 7;
+              return this._bot.getInfo(this._accessToken);
+
+            case 7:
+              this._bot.listenUpdate();
+
+              this._messageService = new MessageService(this, this._connection);
+              this._channalService = new ChannelService(this, this._connection);
+              console.log('💖 Login successfully'); //validate commands which user created to bot manager
+
+              _iterator = _createForOfIteratorHelperLoose(this._bot.info.commands);
+
+            case 12:
+              if ((_step = _iterator()).done) {
+                _context.next = 18;
+                break;
+              }
+
+              command = _step.value;
+
+              if (this[command.name]) {
+                _context.next = 16;
+                break;
+              }
+
+              throw new Error(this._bot.info.name + ".[" + command.name + "] command is not implemented");
+
+            case 16:
+              _context.next = 12;
+              break;
+
+            case 18:
+              _context.next = 23;
+              break;
+
+            case 20:
+              _context.prev = 20;
+              _context.t0 = _context["catch"](0);
+              console.error(_context.t0);
+
+            case 23:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this, [[0, 20]]);
+    }));
+
+    function login(_x) {
+      return _login.apply(this, arguments);
+    }
+
+    return login;
+  }()
+  /**@return message received: MessageEntity */
+  ;
+
+  _createClass(Client, [{
+    key: "message",
+    get: function get() {
+      if (!this._messageService) throw new Error('Message Service is not initialized');
+      return this._messageService;
+    },
+    set: function set(messageService) {
+      this._messageService = messageService;
+    }
+    /**@return channel which received message: ChannelEntity */
+
+  }, {
+    key: "channel",
+    get: function get() {
+      if (!this._channalService) throw new Error('Channel Service is not initialized');
+      return this._channalService;
+    }
+    /**@return currentBot: BotEntity */
+
+  }, {
+    key: "bot",
+    get: function get() {
+      if (!this._bot) throw new Error('Bot is not identified');
+      return this._bot;
+    }
+  }]);
+
+  return Client;
+}();
+
+var MessageClient = /*#__PURE__*/function (_Client) {
+  _inheritsLoose(MessageClient, _Client);
+
+  function MessageClient() {
+    return _Client.apply(this, arguments) || this;
+  }
+
+  var _proto = MessageClient.prototype;
+
+  _proto.login = /*#__PURE__*/function () {
+    var _login = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(token) {
+      var _this = this;
+
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return _Client.prototype.login.call(this, token);
+
+            case 2:
+              this.message.onCreate(function (_ref) {
+                var worker = _ref.worker;
+
+                _this.message.setWorker(worker);
+
+                _this.message.setAction(new MessageAction());
+
+                _this.channel.setWorker(worker);
+
+                _this.channel.setChannel(_this.message.data.channel);
+
+                _this.bot.info.commands.forEach(function (command) {
+                  var _this$message$command = _this.message.command,
+                      name = _this$message$command.name,
+                      args = _this$message$command.args;
+
+                  if (name && args && command.name === name && command.args.length === args.length) {
+                    _this[command.name].apply(_this, args);
+                  }
+                });
+              });
+
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function login(_x) {
+      return _login.apply(this, arguments);
+    }
+
+    return login;
+  }();
+
+  return MessageClient;
+}(Client);
+
+exports.BotInfo = BotInfo;
+exports.ChannelService = ChannelService;
+exports.Client = Client;
+exports.Config = Config;
+exports.Connection = Connection;
+exports.MarkdownBuilder = MarkdownBuilder;
+exports.MessageAction = MessageAction;
+exports.MessageButton = MessageButton;
+exports.MessageClient = MessageClient;
+exports.MessageSelect = MessageSelect;
+exports.MessageSelectOption = MessageSelectOption;
+exports.MessageService = MessageService;
+exports.Service = Service;
+exports.Worker = Worker;
+//# sourceMappingURL=disney.js.cjs.development.js.map