Chaturbate

Apps Home | Create an App
nw-1
Author: ether5456dev
Description Source Code Launch App Current Users
(() => {
  var __commonJS = (cb2, mod) => function __require() {
    return mod || (0, cb2[Object.keys(cb2)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __async = (__this, __arguments, generator) => {
    return new Promise((resolve, reject) => {
      var fulfilled = (value) => {
        try {
          step(generator.next(value));
        } catch (e) {
          reject(e);
        }
      };
      var rejected = (value) => {
        try {
          step(generator.throw(value));
        } catch (e) {
          reject(e);
        }
      };
      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
      step((generator = generator.apply(__this, __arguments)).next());
    });
  };

  // src/require.js
  var require_require = __commonJS({
    "src/require.js"(exports, module) {
      var requirejs;
      var require;
      var define;
      !function(global, setTimeout) {
        var req, s, head, baseElement, dataMain, src, interactiveScript, currentlyAddingScript, mainScript, subPath, version = "2.3.6", commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/gm, cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g, jsSuffixRegExp = /\.js$/, currDirRegExp = /^\.\//, op = Object.prototype, ostring = op.toString, hasOwn = op.hasOwnProperty, isBrowser = !(typeof window == "undefined" || typeof navigator == "undefined" || !window.document), isWebWorker = !isBrowser && typeof importScripts != "undefined", readyRegExp = isBrowser && navigator.platform === "PLAYSTATION 3" ? /^complete$/ : /^(complete|loaded)$/, defContextName = "_", isOpera = typeof opera != "undefined" && opera.toString() === "[object Opera]", contexts = {}, cfg = {}, globalDefQueue = [], useInteractive = false;
        function commentReplace(e, t) {
          return t || "";
        }
        function isFunction(e) {
          return ostring.call(e) === "[object Function]";
        }
        function isArray(e) {
          return ostring.call(e) === "[object Array]";
        }
        function each(e, t) {
          var i;
          if (e)
            for (i = 0; i < e.length && (!e[i] || !t(e[i], i, e)); i += 1)
              ;
        }
        function eachReverse(e, t) {
          var i;
          if (e)
            for (i = e.length - 1; -1 < i && (!e[i] || !t(e[i], i, e)); i -= 1)
              ;
        }
        function hasProp(e, t) {
          return hasOwn.call(e, t);
        }
        function getOwn(e, t) {
          return hasProp(e, t) && e[t];
        }
        function eachProp(e, t) {
          var i;
          for (i in e)
            if (hasProp(e, i) && t(e[i], i))
              break;
        }
        function mixin(i, e, r, n) {
          return e && eachProp(e, function(e2, t) {
            !r && hasProp(i, t) || (!n || typeof e2 != "object" || !e2 || isArray(e2) || isFunction(e2) || e2 instanceof RegExp ? i[t] = e2 : (i[t] || (i[t] = {}), mixin(i[t], e2, r, n)));
          }), i;
        }
        function bind(e, t) {
          return function() {
            return t.apply(e, arguments);
          };
        }
        function scripts() {
          return document.getElementsByTagName("script");
        }
        function defaultOnError(e) {
          throw e;
        }
        function getGlobal(e) {
          if (!e)
            return e;
          var t = global;
          return each(e.split("."), function(e2) {
            t = t[e2];
          }), t;
        }
        function makeError(e, t, i, r) {
          var n = new Error(t + "\nhttps://requirejs.org/docs/errors.html#" + e);
          return n.requireType = e, n.requireModules = r, i && (n.originalError = i), n;
        }
        if (define === void 0) {
          if (requirejs !== void 0) {
            if (isFunction(requirejs))
              return;
            cfg = requirejs, requirejs = void 0;
          }
          require === void 0 || isFunction(require) || (cfg = require, require = void 0), req = requirejs = function(e, t, i, r) {
            var n, o, a = defContextName;
            return isArray(e) || typeof e == "string" || (o = e, isArray(t) ? (e = t, t = i, i = r) : e = []), o && o.context && (a = o.context), (n = getOwn(contexts, a)) || (n = contexts[a] = req.s.newContext(a)), o && n.configure(o), n.require(e, t, i);
          }, req.config = function(e) {
            return req(e);
          }, req.nextTick = setTimeout !== void 0 ? function(e) {
            setTimeout(e, 4);
          } : function(e) {
            e();
          }, require || (require = req), req.version = version, req.jsExtRegExp = /^\/|:|\?|\.js$/, req.isBrowser = isBrowser, s = req.s = { contexts, newContext }, req({}), each(["toUrl", "undef", "defined", "specified"], function(t) {
            req[t] = function() {
              var e = contexts[defContextName];
              return e.require[t].apply(e, arguments);
            };
          }), isBrowser && (head = s.head = document.getElementsByTagName("head")[0], baseElement = document.getElementsByTagName("base")[0], baseElement && (head = s.head = baseElement.parentNode)), req.onError = defaultOnError, req.createNode = function(e, t, i) {
            var r = e.xhtml ? document.createElementNS("http://www.w3.org/1999/xhtml", "html:script") : document.createElement("script");
            return r.type = e.scriptType || "text/javascript", r.charset = "utf-8", r.async = true, r;
          }, req.load = function(t, i, r) {
            var e, n = t && t.config || {};
            if (isBrowser)
              return (e = req.createNode(n, i, r)).setAttribute("data-requirecontext", t.contextName), e.setAttribute("data-requiremodule", i), !e.attachEvent || e.attachEvent.toString && e.attachEvent.toString().indexOf("[native code") < 0 || isOpera ? (e.addEventListener("load", t.onScriptLoad, false), e.addEventListener("error", t.onScriptError, false)) : (useInteractive = true, e.attachEvent("onreadystatechange", t.onScriptLoad)), e.src = r, n.onNodeCreated && n.onNodeCreated(e, n, i, r), currentlyAddingScript = e, baseElement ? head.insertBefore(e, baseElement) : head.appendChild(e), currentlyAddingScript = null, e;
            if (isWebWorker)
              try {
                setTimeout(function() {
                }, 0), importScripts(r), t.completeLoad(i);
              } catch (e2) {
                t.onError(makeError("importscripts", "importScripts failed for " + i + " at " + r, e2, [i]));
              }
          }, isBrowser && !cfg.skipDataMain && eachReverse(scripts(), function(e) {
            if (head || (head = e.parentNode), dataMain = e.getAttribute("data-main"))
              return mainScript = dataMain, cfg.baseUrl || mainScript.indexOf("!") !== -1 || (mainScript = (src = mainScript.split("/")).pop(), subPath = src.length ? src.join("/") + "/" : "./", cfg.baseUrl = subPath), mainScript = mainScript.replace(jsSuffixRegExp, ""), req.jsExtRegExp.test(mainScript) && (mainScript = dataMain), cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript], true;
          }), define = function(e, i, t) {
            var r, n;
            typeof e != "string" && (t = i, i = e, e = null), isArray(i) || (t = i, i = null), !i && isFunction(t) && (i = [], t.length && (t.toString().replace(commentRegExp, commentReplace).replace(cjsRequireRegExp, function(e2, t2) {
              i.push(t2);
            }), i = (t.length === 1 ? ["require"] : ["require", "exports", "module"]).concat(i))), useInteractive && (r = currentlyAddingScript || getInteractiveScript()) && (e || (e = r.getAttribute("data-requiremodule")), n = contexts[r.getAttribute("data-requirecontext")]), n ? (n.defQueue.push([e, i, t]), n.defQueueMap[e] = true) : globalDefQueue.push([e, i, t]);
          }, define.amd = { jQuery: true }, req.exec = function(text) {
            return eval(text);
          }, req(cfg);
        }
        function newContext(u) {
          var i, e, l, c, d, g = { waitSeconds: 7, baseUrl: "./", paths: {}, bundles: {}, pkgs: {}, shim: {}, config: {} }, p = {}, f = {}, r = {}, h = [], m = {}, n = {}, v = {}, x = 1, b = 1;
          function q(e2, t, i2) {
            var r2, n2, o2, a2, s3, u2, c2, d2, p2, f2, l2 = t && t.split("/"), h2 = g.map, m2 = h2 && h2["*"];
            if (e2 && (u2 = (e2 = e2.split("/")).length - 1, g.nodeIdCompat && jsSuffixRegExp.test(e2[u2]) && (e2[u2] = e2[u2].replace(jsSuffixRegExp, "")), e2[0].charAt(0) === "." && l2 && (e2 = l2.slice(0, l2.length - 1).concat(e2)), function(e3) {
              var t2, i3;
              for (t2 = 0; t2 < e3.length; t2++)
                if ((i3 = e3[t2]) === ".")
                  e3.splice(t2, 1), t2 -= 1;
                else if (i3 === "..") {
                  if (t2 === 0 || t2 === 1 && e3[2] === ".." || e3[t2 - 1] === "..")
                    continue;
                  0 < t2 && (e3.splice(t2 - 1, 2), t2 -= 2);
                }
            }(e2), e2 = e2.join("/")), i2 && h2 && (l2 || m2)) {
              e:
                for (o2 = (n2 = e2.split("/")).length; 0 < o2; o2 -= 1) {
                  if (s3 = n2.slice(0, o2).join("/"), l2) {
                    for (a2 = l2.length; 0 < a2; a2 -= 1)
                      if ((r2 = getOwn(h2, l2.slice(0, a2).join("/"))) && (r2 = getOwn(r2, s3))) {
                        c2 = r2, d2 = o2;
                        break e;
                      }
                  }
                  !p2 && m2 && getOwn(m2, s3) && (p2 = getOwn(m2, s3), f2 = o2);
                }
              !c2 && p2 && (c2 = p2, d2 = f2), c2 && (n2.splice(0, d2, c2), e2 = n2.join("/"));
            }
            return getOwn(g.pkgs, e2) || e2;
          }
          function E(t) {
            isBrowser && each(scripts(), function(e2) {
              if (e2.getAttribute("data-requiremodule") === t && e2.getAttribute("data-requirecontext") === l.contextName)
                return e2.parentNode.removeChild(e2), true;
            });
          }
          function w(e2) {
            var t = getOwn(g.paths, e2);
            if (t && isArray(t) && 1 < t.length)
              return t.shift(), l.require.undef(e2), l.makeRequire(null, { skipMap: true })([e2]), true;
          }
          function y(e2) {
            var t, i2 = e2 ? e2.indexOf("!") : -1;
            return -1 < i2 && (t = e2.substring(0, i2), e2 = e2.substring(i2 + 1, e2.length)), [t, e2];
          }
          function S(e2, t, i2, r2) {
            var n2, o2, a2, s3, u2 = null, c2 = t ? t.name : null, d2 = e2, p2 = true, f2 = "";
            return e2 || (p2 = false, e2 = "_@r" + (x += 1)), u2 = (s3 = y(e2))[0], e2 = s3[1], u2 && (u2 = q(u2, c2, r2), o2 = getOwn(m, u2)), e2 && (u2 ? f2 = i2 ? e2 : o2 && o2.normalize ? o2.normalize(e2, function(e3) {
              return q(e3, c2, r2);
            }) : e2.indexOf("!") === -1 ? q(e2, c2, r2) : e2 : (u2 = (s3 = y(f2 = q(e2, c2, r2)))[0], f2 = s3[1], i2 = true, n2 = l.nameToUrl(f2))), { prefix: u2, name: f2, parentMap: t, unnormalized: !!(a2 = !u2 || o2 || i2 ? "" : "_unnormalized" + (b += 1)), url: n2, originalName: d2, isDefine: p2, id: (u2 ? u2 + "!" + f2 : f2) + a2 };
          }
          function k(e2) {
            var t = e2.id, i2 = getOwn(p, t);
            return i2 || (i2 = p[t] = new l.Module(e2)), i2;
          }
          function M(e2, t, i2) {
            var r2 = e2.id, n2 = getOwn(p, r2);
            !hasProp(m, r2) || n2 && !n2.defineEmitComplete ? (n2 = k(e2)).error && t === "error" ? i2(n2.error) : n2.on(t, i2) : t === "defined" && i2(m[r2]);
          }
          function O(i2, e2) {
            var t = i2.requireModules, r2 = false;
            e2 ? e2(i2) : (each(t, function(e3) {
              var t2 = getOwn(p, e3);
              t2 && (t2.error = i2, t2.events.error && (r2 = true, t2.emit("error", i2)));
            }), r2 || req.onError(i2));
          }
          function j() {
            globalDefQueue.length && (each(globalDefQueue, function(e2) {
              var t = e2[0];
              typeof t == "string" && (l.defQueueMap[t] = true), h.push(e2);
            }), globalDefQueue = []);
          }
          function P(e2) {
            delete p[e2], delete f[e2];
          }
          function R() {
            var e2, r2, t = 1e3 * g.waitSeconds, n2 = t && l.startTime + t < new Date().getTime(), o2 = [], a2 = [], s3 = false, u2 = true;
            if (!i) {
              if (i = true, eachProp(f, function(e3) {
                var t2 = e3.map, i2 = t2.id;
                if (e3.enabled && (t2.isDefine || a2.push(e3), !e3.error)) {
                  if (!e3.inited && n2)
                    w(i2) ? s3 = r2 = true : (o2.push(i2), E(i2));
                  else if (!e3.inited && e3.fetched && t2.isDefine && (s3 = true, !t2.prefix))
                    return u2 = false;
                }
              }), n2 && o2.length)
                return (e2 = makeError("timeout", "Load timeout for modules: " + o2, null, o2)).contextName = l.contextName, O(e2);
              u2 && each(a2, function(e3) {
                !function n3(o3, a3, s4) {
                  var e4 = o3.map.id;
                  o3.error ? o3.emit("error", o3.error) : (a3[e4] = true, each(o3.depMaps, function(e5, t2) {
                    var i2 = e5.id, r3 = getOwn(p, i2);
                    !r3 || o3.depMatched[t2] || s4[i2] || (getOwn(a3, i2) ? (o3.defineDep(t2, m[i2]), o3.check()) : n3(r3, a3, s4));
                  }), s4[e4] = true);
                }(e3, {}, {});
              }), n2 && !r2 || !s3 || !isBrowser && !isWebWorker || d || (d = setTimeout(function() {
                d = 0, R();
              }, 50)), i = false;
            }
          }
          function a(e2) {
            hasProp(m, e2[0]) || k(S(e2[0], null, true)).init(e2[1], e2[2]);
          }
          function o(e2, t, i2, r2) {
            e2.detachEvent && !isOpera ? r2 && e2.detachEvent(r2, t) : e2.removeEventListener(i2, t, false);
          }
          function s2(e2) {
            var t = e2.currentTarget || e2.srcElement;
            return o(t, l.onScriptLoad, "load", "onreadystatechange"), o(t, l.onScriptError, "error"), { node: t, id: t && t.getAttribute("data-requiremodule") };
          }
          function T() {
            var e2;
            for (j(); h.length; ) {
              if ((e2 = h.shift())[0] === null)
                return O(makeError("mismatch", "Mismatched anonymous define() module: " + e2[e2.length - 1]));
              a(e2);
            }
            l.defQueueMap = {};
          }
          return c = { require: function(e2) {
            return e2.require ? e2.require : e2.require = l.makeRequire(e2.map);
          }, exports: function(e2) {
            if (e2.usingExports = true, e2.map.isDefine)
              return e2.exports ? m[e2.map.id] = e2.exports : e2.exports = m[e2.map.id] = {};
          }, module: function(e2) {
            return e2.module ? e2.module : e2.module = { id: e2.map.id, uri: e2.map.url, config: function() {
              return getOwn(g.config, e2.map.id) || {};
            }, exports: e2.exports || (e2.exports = {}) };
          } }, (e = function(e2) {
            this.events = getOwn(r, e2.id) || {}, this.map = e2, this.shim = getOwn(g.shim, e2.id), this.depExports = [], this.depMaps = [], this.depMatched = [], this.pluginMaps = {}, this.depCount = 0;
          }).prototype = { init: function(e2, t, i2, r2) {
            r2 = r2 || {}, this.inited || (this.factory = t, i2 ? this.on("error", i2) : this.events.error && (i2 = bind(this, function(e3) {
              this.emit("error", e3);
            })), this.depMaps = e2 && e2.slice(0), this.errback = i2, this.inited = true, this.ignore = r2.ignore, r2.enabled || this.enabled ? this.enable() : this.check());
          }, defineDep: function(e2, t) {
            this.depMatched[e2] || (this.depMatched[e2] = true, this.depCount -= 1, this.depExports[e2] = t);
          }, fetch: function() {
            if (!this.fetched) {
              this.fetched = true, l.startTime = new Date().getTime();
              var e2 = this.map;
              if (!this.shim)
                return e2.prefix ? this.callPlugin() : this.load();
              l.makeRequire(this.map, { enableBuildCallback: true })(this.shim.deps || [], bind(this, function() {
                return e2.prefix ? this.callPlugin() : this.load();
              }));
            }
          }, load: function() {
            var e2 = this.map.url;
            n[e2] || (n[e2] = true, l.load(this.map.id, e2));
          }, check: function() {
            if (this.enabled && !this.enabling) {
              var t, e2, i2 = this.map.id, r2 = this.depExports, n2 = this.exports, o2 = this.factory;
              if (this.inited) {
                if (this.error)
                  this.emit("error", this.error);
                else if (!this.defining) {
                  if (this.defining = true, this.depCount < 1 && !this.defined) {
                    if (isFunction(o2)) {
                      if (this.events.error && this.map.isDefine || req.onError !== defaultOnError)
                        try {
                          n2 = l.execCb(i2, o2, r2, n2);
                        } catch (e3) {
                          t = e3;
                        }
                      else
                        n2 = l.execCb(i2, o2, r2, n2);
                      if (this.map.isDefine && n2 === void 0 && ((e2 = this.module) ? n2 = e2.exports : this.usingExports && (n2 = this.exports)), t)
                        return t.requireMap = this.map, t.requireModules = this.map.isDefine ? [this.map.id] : null, t.requireType = this.map.isDefine ? "define" : "require", O(this.error = t);
                    } else
                      n2 = o2;
                    if (this.exports = n2, this.map.isDefine && !this.ignore && (m[i2] = n2, req.onResourceLoad)) {
                      var a2 = [];
                      each(this.depMaps, function(e3) {
                        a2.push(e3.normalizedMap || e3);
                      }), req.onResourceLoad(l, this.map, a2);
                    }
                    P(i2), this.defined = true;
                  }
                  this.defining = false, this.defined && !this.defineEmitted && (this.defineEmitted = true, this.emit("defined", this.exports), this.defineEmitComplete = true);
                }
              } else
                hasProp(l.defQueueMap, i2) || this.fetch();
            }
          }, callPlugin: function() {
            var u2 = this.map, c2 = u2.id, e2 = S(u2.prefix);
            this.depMaps.push(e2), M(e2, "defined", bind(this, function(e3) {
              var o2, t, i2, r2 = getOwn(v, this.map.id), n2 = this.map.name, a2 = this.map.parentMap ? this.map.parentMap.name : null, s3 = l.makeRequire(u2.parentMap, { enableBuildCallback: true });
              return this.map.unnormalized ? (e3.normalize && (n2 = e3.normalize(n2, function(e4) {
                return q(e4, a2, true);
              }) || ""), M(t = S(u2.prefix + "!" + n2, this.map.parentMap, true), "defined", bind(this, function(e4) {
                this.map.normalizedMap = t, this.init([], function() {
                  return e4;
                }, null, { enabled: true, ignore: true });
              })), void ((i2 = getOwn(p, t.id)) && (this.depMaps.push(t), this.events.error && i2.on("error", bind(this, function(e4) {
                this.emit("error", e4);
              })), i2.enable()))) : r2 ? (this.map.url = l.nameToUrl(r2), void this.load()) : ((o2 = bind(this, function(e4) {
                this.init([], function() {
                  return e4;
                }, null, { enabled: true });
              })).error = bind(this, function(e4) {
                this.inited = true, (this.error = e4).requireModules = [c2], eachProp(p, function(e5) {
                  e5.map.id.indexOf(c2 + "_unnormalized") === 0 && P(e5.map.id);
                }), O(e4);
              }), o2.fromText = bind(this, function(e4, t2) {
                var i3 = u2.name, r3 = S(i3), n3 = useInteractive;
                t2 && (e4 = t2), n3 && (useInteractive = false), k(r3), hasProp(g.config, c2) && (g.config[i3] = g.config[c2]);
                try {
                  req.exec(e4);
                } catch (e5) {
                  return O(makeError("fromtexteval", "fromText eval for " + c2 + " failed: " + e5, e5, [c2]));
                }
                n3 && (useInteractive = true), this.depMaps.push(r3), l.completeLoad(i3), s3([i3], o2);
              }), void e3.load(u2.name, s3, o2, g));
            })), l.enable(e2, this), this.pluginMaps[e2.id] = e2;
          }, enable: function() {
            (f[this.map.id] = this).enabled = true, this.enabling = true, each(this.depMaps, bind(this, function(e2, t) {
              var i2, r2, n2;
              if (typeof e2 == "string") {
                if (e2 = S(e2, this.map.isDefine ? this.map : this.map.parentMap, false, !this.skipMap), this.depMaps[t] = e2, n2 = getOwn(c, e2.id))
                  return void (this.depExports[t] = n2(this));
                this.depCount += 1, M(e2, "defined", bind(this, function(e3) {
                  this.undefed || (this.defineDep(t, e3), this.check());
                })), this.errback ? M(e2, "error", bind(this, this.errback)) : this.events.error && M(e2, "error", bind(this, function(e3) {
                  this.emit("error", e3);
                }));
              }
              i2 = e2.id, r2 = p[i2], hasProp(c, i2) || !r2 || r2.enabled || l.enable(e2, this);
            })), eachProp(this.pluginMaps, bind(this, function(e2) {
              var t = getOwn(p, e2.id);
              t && !t.enabled && l.enable(e2, this);
            })), this.enabling = false, this.check();
          }, on: function(e2, t) {
            var i2 = this.events[e2];
            i2 || (i2 = this.events[e2] = []), i2.push(t);
          }, emit: function(e2, t) {
            each(this.events[e2], function(e3) {
              e3(t);
            }), e2 === "error" && delete this.events[e2];
          } }, (l = { config: g, contextName: u, registry: p, defined: m, urlFetched: n, defQueue: h, defQueueMap: {}, Module: e, makeModuleMap: S, nextTick: req.nextTick, onError: O, configure: function(e2) {
            if (e2.baseUrl && e2.baseUrl.charAt(e2.baseUrl.length - 1) !== "/" && (e2.baseUrl += "/"), typeof e2.urlArgs == "string") {
              var i2 = e2.urlArgs;
              e2.urlArgs = function(e3, t) {
                return (t.indexOf("?") === -1 ? "?" : "&") + i2;
              };
            }
            var r2 = g.shim, n2 = { paths: true, bundles: true, config: true, map: true };
            eachProp(e2, function(e3, t) {
              n2[t] ? (g[t] || (g[t] = {}), mixin(g[t], e3, true, true)) : g[t] = e3;
            }), e2.bundles && eachProp(e2.bundles, function(e3, t) {
              each(e3, function(e4) {
                e4 !== t && (v[e4] = t);
              });
            }), e2.shim && (eachProp(e2.shim, function(e3, t) {
              isArray(e3) && (e3 = { deps: e3 }), !e3.exports && !e3.init || e3.exportsFn || (e3.exportsFn = l.makeShimExports(e3)), r2[t] = e3;
            }), g.shim = r2), e2.packages && each(e2.packages, function(e3) {
              var t;
              t = (e3 = typeof e3 == "string" ? { name: e3 } : e3).name, e3.location && (g.paths[t] = e3.location), g.pkgs[t] = e3.name + "/" + (e3.main || "main").replace(currDirRegExp, "").replace(jsSuffixRegExp, "");
            }), eachProp(p, function(e3, t) {
              e3.inited || e3.map.unnormalized || (e3.map = S(t, null, true));
            }), (e2.deps || e2.callback) && l.require(e2.deps || [], e2.callback);
          }, makeShimExports: function(t) {
            return function() {
              var e2;
              return t.init && (e2 = t.init.apply(global, arguments)), e2 || t.exports && getGlobal(t.exports);
            };
          }, makeRequire: function(o2, a2) {
            function s3(e2, t, i2) {
              var r2, n2;
              return a2.enableBuildCallback && t && isFunction(t) && (t.__requireJsBuild = true), typeof e2 == "string" ? isFunction(t) ? O(makeError("requireargs", "Invalid require call"), i2) : o2 && hasProp(c, e2) ? c[e2](p[o2.id]) : req.get ? req.get(l, e2, o2, s3) : (r2 = S(e2, o2, false, true).id, hasProp(m, r2) ? m[r2] : O(makeError("notloaded", 'Module name "' + r2 + '" has not been loaded yet for context: ' + u + (o2 ? "" : ". Use require([])")))) : (T(), l.nextTick(function() {
                T(), (n2 = k(S(null, o2))).skipMap = a2.skipMap, n2.init(e2, t, i2, { enabled: true }), R();
              }), s3);
            }
            return a2 = a2 || {}, mixin(s3, { isBrowser, toUrl: function(e2) {
              var t, i2 = e2.lastIndexOf("."), r2 = e2.split("/")[0];
              return i2 !== -1 && (!(r2 === "." || r2 === "..") || 1 < i2) && (t = e2.substring(i2, e2.length), e2 = e2.substring(0, i2)), l.nameToUrl(q(e2, o2 && o2.id, true), t, true);
            }, defined: function(e2) {
              return hasProp(m, S(e2, o2, false, true).id);
            }, specified: function(e2) {
              return e2 = S(e2, o2, false, true).id, hasProp(m, e2) || hasProp(p, e2);
            } }), o2 || (s3.undef = function(i2) {
              j();
              var e2 = S(i2, o2, true), t = getOwn(p, i2);
              t.undefed = true, E(i2), delete m[i2], delete n[e2.url], delete r[i2], eachReverse(h, function(e3, t2) {
                e3[0] === i2 && h.splice(t2, 1);
              }), delete l.defQueueMap[i2], t && (t.events.defined && (r[i2] = t.events), P(i2));
            }), s3;
          }, enable: function(e2) {
            getOwn(p, e2.id) && k(e2).enable();
          }, completeLoad: function(e2) {
            var t, i2, r2, n2 = getOwn(g.shim, e2) || {}, o2 = n2.exports;
            for (j(); h.length; ) {
              if ((i2 = h.shift())[0] === null) {
                if (i2[0] = e2, t)
                  break;
                t = true;
              } else
                i2[0] === e2 && (t = true);
              a(i2);
            }
            if (l.defQueueMap = {}, r2 = getOwn(p, e2), !t && !hasProp(m, e2) && r2 && !r2.inited) {
              if (!(!g.enforceDefine || o2 && getGlobal(o2)))
                return w(e2) ? void 0 : O(makeError("nodefine", "No define call for " + e2, null, [e2]));
              a([e2, n2.deps || [], n2.exportsFn]);
            }
            R();
          }, nameToUrl: function(e2, t, i2) {
            var r2, n2, o2, a2, s3, u2, c2 = getOwn(g.pkgs, e2);
            if (c2 && (e2 = c2), u2 = getOwn(v, e2))
              return l.nameToUrl(u2, t, i2);
            if (req.jsExtRegExp.test(e2))
              a2 = e2 + (t || "");
            else {
              for (r2 = g.paths, o2 = (n2 = e2.split("/")).length; 0 < o2; o2 -= 1)
                if (s3 = getOwn(r2, n2.slice(0, o2).join("/"))) {
                  isArray(s3) && (s3 = s3[0]), n2.splice(0, o2, s3);
                  break;
                }
              a2 = n2.join("/"), a2 = ((a2 += t || (/^data\:|^blob\:|\?/.test(a2) || i2 ? "" : ".js")).charAt(0) === "/" || a2.match(/^[\w\+\.\-]+:/) ? "" : g.baseUrl) + a2;
            }
            return g.urlArgs && !/^blob\:/.test(a2) ? a2 + g.urlArgs(e2, a2) : a2;
          }, load: function(e2, t) {
            req.load(l, e2, t);
          }, execCb: function(e2, t, i2, r2) {
            return t.apply(r2, i2);
          }, onScriptLoad: function(e2) {
            if (e2.type === "load" || readyRegExp.test((e2.currentTarget || e2.srcElement).readyState)) {
              interactiveScript = null;
              var t = s2(e2);
              l.completeLoad(t.id);
            }
          }, onScriptError: function(e2) {
            var i2 = s2(e2);
            if (!w(i2.id)) {
              var r2 = [];
              return eachProp(p, function(e3, t) {
                t.indexOf("_@r") !== 0 && each(e3.depMaps, function(e4) {
                  if (e4.id === i2.id)
                    return r2.push(t), true;
                });
              }), O(makeError("scripterror", 'Script error for "' + i2.id + (r2.length ? '", needed by: ' + r2.join(", ") : '"'), e2, [i2.id]));
            }
          } }).require = l.makeRequire(), l;
        }
        function getInteractiveScript() {
          return interactiveScript && interactiveScript.readyState === "interactive" || eachReverse(scripts(), function(e) {
            if (e.readyState === "interactive")
              return interactiveScript = e;
          }), interactiveScript;
        }
      }(exports, typeof setTimeout == "undefined" ? void 0 : setTimeout);
    }
  });

  // node_modules/axios/lib/helpers/bind.js
  var require_bind = __commonJS({
    "node_modules/axios/lib/helpers/bind.js"(exports2, module2) {
      "use strict";
      module2.exports = function bind2(fn, thisArg) {
        return function wrap() {
          var args = new Array(arguments.length);
          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i];
          }
          return fn.apply(thisArg, args);
        };
      };
    }
  });

  // node_modules/axios/lib/utils.js
  var require_utils = __commonJS({
    "node_modules/axios/lib/utils.js"(exports2, module2) {
      "use strict";
      var bind2 = require_bind();
      var toString = Object.prototype.toString;
      function isArray2(val) {
        return toString.call(val) === "[object Array]";
      }
      function isUndefined(val) {
        return typeof val === "undefined";
      }
      function isBuffer(val) {
        return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
      }
      function isArrayBuffer(val) {
        return toString.call(val) === "[object ArrayBuffer]";
      }
      function isFormData(val) {
        return typeof FormData !== "undefined" && val instanceof FormData;
      }
      function isArrayBufferView(val) {
        var result;
        if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
          result = ArrayBuffer.isView(val);
        } else {
          result = val && val.buffer && val.buffer instanceof ArrayBuffer;
        }
        return result;
      }
      function isString(val) {
        return typeof val === "string";
      }
      function isNumber(val) {
        return typeof val === "number";
      }
      function isObject(val) {
        return val !== null && typeof val === "object";
      }
      function isPlainObject(val) {
        if (toString.call(val) !== "[object Object]") {
          return false;
        }
        var prototype = Object.getPrototypeOf(val);
        return prototype === null || prototype === Object.prototype;
      }
      function isDate(val) {
        return toString.call(val) === "[object Date]";
      }
      function isFile(val) {
        return toString.call(val) === "[object File]";
      }
      function isBlob(val) {
        return toString.call(val) === "[object Blob]";
      }
      function isFunction2(val) {
        return toString.call(val) === "[object Function]";
      }
      function isStream(val) {
        return isObject(val) && isFunction2(val.pipe);
      }
      function isURLSearchParams(val) {
        return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
      }
      function trim(str) {
        return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
      }
      function isStandardBrowserEnv() {
        if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
          return false;
        }
        return typeof window !== "undefined" && typeof document !== "undefined";
      }
      function forEach(obj, fn) {
        if (obj === null || typeof obj === "undefined") {
          return;
        }
        if (typeof obj !== "object") {
          obj = [obj];
        }
        if (isArray2(obj)) {
          for (var i = 0, l = obj.length; i < l; i++) {
            fn.call(null, obj[i], i, obj);
          }
        } else {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) {
              fn.call(null, obj[key], key, obj);
            }
          }
        }
      }
      function merge() {
        var result = {};
        function assignValue(val, key) {
          if (isPlainObject(result[key]) && isPlainObject(val)) {
            result[key] = merge(result[key], val);
          } else if (isPlainObject(val)) {
            result[key] = merge({}, val);
          } else if (isArray2(val)) {
            result[key] = val.slice();
          } else {
            result[key] = val;
          }
        }
        for (var i = 0, l = arguments.length; i < l; i++) {
          forEach(arguments[i], assignValue);
        }
        return result;
      }
      function extend(a, b, thisArg) {
        forEach(b, function assignValue(val, key) {
          if (thisArg && typeof val === "function") {
            a[key] = bind2(val, thisArg);
          } else {
            a[key] = val;
          }
        });
        return a;
      }
      function stripBOM(content) {
        if (content.charCodeAt(0) === 65279) {
          content = content.slice(1);
        }
        return content;
      }
      module2.exports = {
        isArray: isArray2,
        isArrayBuffer,
        isBuffer,
        isFormData,
        isArrayBufferView,
        isString,
        isNumber,
        isObject,
        isPlainObject,
        isUndefined,
        isDate,
        isFile,
        isBlob,
        isFunction: isFunction2,
        isStream,
        isURLSearchParams,
        isStandardBrowserEnv,
        forEach,
        merge,
        extend,
        trim,
        stripBOM
      };
    }
  });

  // node_modules/axios/lib/helpers/buildURL.js
  var require_buildURL = __commonJS({
    "node_modules/axios/lib/helpers/buildURL.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      function encode(val) {
        return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
      }
      module2.exports = function buildURL(url, params, paramsSerializer) {
        if (!params) {
          return url;
        }
        var serializedParams;
        if (paramsSerializer) {
          serializedParams = paramsSerializer(params);
        } else if (utils.isURLSearchParams(params)) {
          serializedParams = params.toString();
        } else {
          var parts = [];
          utils.forEach(params, function serialize(val, key) {
            if (val === null || typeof val === "undefined") {
              return;
            }
            if (utils.isArray(val)) {
              key = key + "[]";
            } else {
              val = [val];
            }
            utils.forEach(val, function parseValue(v) {
              if (utils.isDate(v)) {
                v = v.toISOString();
              } else if (utils.isObject(v)) {
                v = JSON.stringify(v);
              }
              parts.push(encode(key) + "=" + encode(v));
            });
          });
          serializedParams = parts.join("&");
        }
        if (serializedParams) {
          var hashmarkIndex = url.indexOf("#");
          if (hashmarkIndex !== -1) {
            url = url.slice(0, hashmarkIndex);
          }
          url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
        }
        return url;
      };
    }
  });

  // node_modules/axios/lib/core/InterceptorManager.js
  var require_InterceptorManager = __commonJS({
    "node_modules/axios/lib/core/InterceptorManager.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      function InterceptorManager() {
        this.handlers = [];
      }
      InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
        this.handlers.push({
          fulfilled,
          rejected,
          synchronous: options ? options.synchronous : false,
          runWhen: options ? options.runWhen : null
        });
        return this.handlers.length - 1;
      };
      InterceptorManager.prototype.eject = function eject(id) {
        if (this.handlers[id]) {
          this.handlers[id] = null;
        }
      };
      InterceptorManager.prototype.forEach = function forEach(fn) {
        utils.forEach(this.handlers, function forEachHandler(h) {
          if (h !== null) {
            fn(h);
          }
        });
      };
      module2.exports = InterceptorManager;
    }
  });

  // node_modules/axios/lib/helpers/normalizeHeaderName.js
  var require_normalizeHeaderName = __commonJS({
    "node_modules/axios/lib/helpers/normalizeHeaderName.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      module2.exports = function normalizeHeaderName(headers, normalizedName) {
        utils.forEach(headers, function processHeader(value, name) {
          if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
            headers[normalizedName] = value;
            delete headers[name];
          }
        });
      };
    }
  });

  // node_modules/axios/lib/core/enhanceError.js
  var require_enhanceError = __commonJS({
    "node_modules/axios/lib/core/enhanceError.js"(exports2, module2) {
      "use strict";
      module2.exports = function enhanceError(error, config, code, request, response) {
        error.config = config;
        if (code) {
          error.code = code;
        }
        error.request = request;
        error.response = response;
        error.isAxiosError = true;
        error.toJSON = function toJSON() {
          return {
            message: this.message,
            name: this.name,
            description: this.description,
            number: this.number,
            fileName: this.fileName,
            lineNumber: this.lineNumber,
            columnNumber: this.columnNumber,
            stack: this.stack,
            config: this.config,
            code: this.code,
            status: this.response && this.response.status ? this.response.status : null
          };
        };
        return error;
      };
    }
  });

  // node_modules/axios/lib/core/createError.js
  var require_createError = __commonJS({
    "node_modules/axios/lib/core/createError.js"(exports2, module2) {
      "use strict";
      var enhanceError = require_enhanceError();
      module2.exports = function createError(message, config, code, request, response) {
        var error = new Error(message);
        return enhanceError(error, config, code, request, response);
      };
    }
  });

  // node_modules/axios/lib/core/settle.js
  var require_settle = __commonJS({
    "node_modules/axios/lib/core/settle.js"(exports2, module2) {
      "use strict";
      var createError = require_createError();
      module2.exports = function settle(resolve, reject, response) {
        var validateStatus = response.config.validateStatus;
        if (!response.status || !validateStatus || validateStatus(response.status)) {
          resolve(response);
        } else {
          reject(createError("Request failed with status code " + response.status, response.config, null, response.request, response));
        }
      };
    }
  });

  // node_modules/axios/lib/helpers/cookies.js
  var require_cookies = __commonJS({
    "node_modules/axios/lib/helpers/cookies.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      module2.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() {
        return {
          write: function write(name, value, expires, path, domain, secure) {
            var cookie = [];
            cookie.push(name + "=" + encodeURIComponent(value));
            if (utils.isNumber(expires)) {
              cookie.push("expires=" + new Date(expires).toGMTString());
            }
            if (utils.isString(path)) {
              cookie.push("path=" + path);
            }
            if (utils.isString(domain)) {
              cookie.push("domain=" + domain);
            }
            if (secure === true) {
              cookie.push("secure");
            }
            document.cookie = cookie.join("; ");
          },
          read: function read(name) {
            var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
            return match ? decodeURIComponent(match[3]) : null;
          },
          remove: function remove(name) {
            this.write(name, "", Date.now() - 864e5);
          }
        };
      }() : function nonStandardBrowserEnv() {
        return {
          write: function write() {
          },
          read: function read() {
            return null;
          },
          remove: function remove() {
          }
        };
      }();
    }
  });

  // node_modules/axios/lib/helpers/isAbsoluteURL.js
  var require_isAbsoluteURL = __commonJS({
    "node_modules/axios/lib/helpers/isAbsoluteURL.js"(exports2, module2) {
      "use strict";
      module2.exports = function isAbsoluteURL(url) {
        return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
      };
    }
  });

  // node_modules/axios/lib/helpers/combineURLs.js
  var require_combineURLs = __commonJS({
    "node_modules/axios/lib/helpers/combineURLs.js"(exports2, module2) {
      "use strict";
      module2.exports = function combineURLs(baseURL, relativeURL) {
        return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
      };
    }
  });

  // node_modules/axios/lib/core/buildFullPath.js
  var require_buildFullPath = __commonJS({
    "node_modules/axios/lib/core/buildFullPath.js"(exports2, module2) {
      "use strict";
      var isAbsoluteURL = require_isAbsoluteURL();
      var combineURLs = require_combineURLs();
      module2.exports = function buildFullPath(baseURL, requestedURL) {
        if (baseURL && !isAbsoluteURL(requestedURL)) {
          return combineURLs(baseURL, requestedURL);
        }
        return requestedURL;
      };
    }
  });

  // node_modules/axios/lib/helpers/parseHeaders.js
  var require_parseHeaders = __commonJS({
    "node_modules/axios/lib/helpers/parseHeaders.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var ignoreDuplicateOf = [
        "age",
        "authorization",
        "content-length",
        "content-type",
        "etag",
        "expires",
        "from",
        "host",
        "if-modified-since",
        "if-unmodified-since",
        "last-modified",
        "location",
        "max-forwards",
        "proxy-authorization",
        "referer",
        "retry-after",
        "user-agent"
      ];
      module2.exports = function parseHeaders(headers) {
        var parsed = {};
        var key;
        var val;
        var i;
        if (!headers) {
          return parsed;
        }
        utils.forEach(headers.split("\n"), function parser(line) {
          i = line.indexOf(":");
          key = utils.trim(line.substr(0, i)).toLowerCase();
          val = utils.trim(line.substr(i + 1));
          if (key) {
            if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
              return;
            }
            if (key === "set-cookie") {
              parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
            } else {
              parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
            }
          }
        });
        return parsed;
      };
    }
  });

  // node_modules/axios/lib/helpers/isURLSameOrigin.js
  var require_isURLSameOrigin = __commonJS({
    "node_modules/axios/lib/helpers/isURLSameOrigin.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      module2.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() {
        var msie = /(msie|trident)/i.test(navigator.userAgent);
        var urlParsingNode = document.createElement("a");
        var originURL;
        function resolveURL(url) {
          var href = url;
          if (msie) {
            urlParsingNode.setAttribute("href", href);
            href = urlParsingNode.href;
          }
          urlParsingNode.setAttribute("href", href);
          return {
            href: urlParsingNode.href,
            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
            host: urlParsingNode.host,
            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
            hostname: urlParsingNode.hostname,
            port: urlParsingNode.port,
            pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
          };
        }
        originURL = resolveURL(window.location.href);
        return function isURLSameOrigin(requestURL) {
          var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
          return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
        };
      }() : function nonStandardBrowserEnv() {
        return function isURLSameOrigin() {
          return true;
        };
      }();
    }
  });

  // node_modules/axios/lib/cancel/Cancel.js
  var require_Cancel = __commonJS({
    "node_modules/axios/lib/cancel/Cancel.js"(exports2, module2) {
      "use strict";
      function Cancel(message) {
        this.message = message;
      }
      Cancel.prototype.toString = function toString() {
        return "Cancel" + (this.message ? ": " + this.message : "");
      };
      Cancel.prototype.__CANCEL__ = true;
      module2.exports = Cancel;
    }
  });

  // node_modules/axios/lib/adapters/xhr.js
  var require_xhr = __commonJS({
    "node_modules/axios/lib/adapters/xhr.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var settle = require_settle();
      var cookies = require_cookies();
      var buildURL = require_buildURL();
      var buildFullPath = require_buildFullPath();
      var parseHeaders = require_parseHeaders();
      var isURLSameOrigin = require_isURLSameOrigin();
      var createError = require_createError();
      var defaults = require_defaults();
      var Cancel = require_Cancel();
      module2.exports = function xhrAdapter(config) {
        return new Promise(function dispatchXhrRequest(resolve, reject) {
          var requestData = config.data;
          var requestHeaders = config.headers;
          var responseType = config.responseType;
          var onCanceled;
          function done() {
            if (config.cancelToken) {
              config.cancelToken.unsubscribe(onCanceled);
            }
            if (config.signal) {
              config.signal.removeEventListener("abort", onCanceled);
            }
          }
          if (utils.isFormData(requestData)) {
            delete requestHeaders["Content-Type"];
          }
          var request = new XMLHttpRequest();
          if (config.auth) {
            var username = config.auth.username || "";
            var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
            requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
          }
          var fullPath = buildFullPath(config.baseURL, config.url);
          request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
          request.timeout = config.timeout;
          function onloadend() {
            if (!request) {
              return;
            }
            var responseHeaders = "getAllResponseHeaders" in request ? parseHeaders(request.getAllResponseHeaders()) : null;
            var responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
            var response = {
              data: responseData,
              status: request.status,
              statusText: request.statusText,
              headers: responseHeaders,
              config,
              request
            };
            settle(function _resolve(value) {
              resolve(value);
              done();
            }, function _reject(err) {
              reject(err);
              done();
            }, response);
            request = null;
          }
          if ("onloadend" in request) {
            request.onloadend = onloadend;
          } else {
            request.onreadystatechange = function handleLoad() {
              if (!request || request.readyState !== 4) {
                return;
              }
              if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
                return;
              }
              setTimeout(onloadend);
            };
          }
          request.onabort = function handleAbort() {
            if (!request) {
              return;
            }
            reject(createError("Request aborted", config, "ECONNABORTED", request));
            request = null;
          };
          request.onerror = function handleError() {
            reject(createError("Network Error", config, null, request));
            request = null;
          };
          request.ontimeout = function handleTimeout() {
            var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
            var transitional = config.transitional || defaults.transitional;
            if (config.timeoutErrorMessage) {
              timeoutErrorMessage = config.timeoutErrorMessage;
            }
            reject(createError(timeoutErrorMessage, config, transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request));
            request = null;
          };
          if (utils.isStandardBrowserEnv()) {
            var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
            if (xsrfValue) {
              requestHeaders[config.xsrfHeaderName] = xsrfValue;
            }
          }
          if ("setRequestHeader" in request) {
            utils.forEach(requestHeaders, function setRequestHeader(val, key) {
              if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
                delete requestHeaders[key];
              } else {
                request.setRequestHeader(key, val);
              }
            });
          }
          if (!utils.isUndefined(config.withCredentials)) {
            request.withCredentials = !!config.withCredentials;
          }
          if (responseType && responseType !== "json") {
            request.responseType = config.responseType;
          }
          if (typeof config.onDownloadProgress === "function") {
            request.addEventListener("progress", config.onDownloadProgress);
          }
          if (typeof config.onUploadProgress === "function" && request.upload) {
            request.upload.addEventListener("progress", config.onUploadProgress);
          }
          if (config.cancelToken || config.signal) {
            onCanceled = function(cancel) {
              if (!request) {
                return;
              }
              reject(!cancel || cancel && cancel.type ? new Cancel("canceled") : cancel);
              request.abort();
              request = null;
            };
            config.cancelToken && config.cancelToken.subscribe(onCanceled);
            if (config.signal) {
              config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled);
            }
          }
          if (!requestData) {
            requestData = null;
          }
          request.send(requestData);
        });
      };
    }
  });

  // node_modules/axios/lib/defaults.js
  var require_defaults = __commonJS({
    "node_modules/axios/lib/defaults.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var normalizeHeaderName = require_normalizeHeaderName();
      var enhanceError = require_enhanceError();
      var DEFAULT_CONTENT_TYPE = {
        "Content-Type": "application/x-www-form-urlencoded"
      };
      function setContentTypeIfUnset(headers, value) {
        if (!utils.isUndefined(headers) && utils.isUndefined(headers["Content-Type"])) {
          headers["Content-Type"] = value;
        }
      }
      function getDefaultAdapter() {
        var adapter;
        if (typeof XMLHttpRequest !== "undefined") {
          adapter = require_xhr();
        } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
          adapter = require_xhr();
        }
        return adapter;
      }
      function stringifySafely(rawValue, parser, encoder) {
        if (utils.isString(rawValue)) {
          try {
            (parser || JSON.parse)(rawValue);
            return utils.trim(rawValue);
          } catch (e) {
            if (e.name !== "SyntaxError") {
              throw e;
            }
          }
        }
        return (encoder || JSON.stringify)(rawValue);
      }
      var defaults = {
        transitional: {
          silentJSONParsing: true,
          forcedJSONParsing: true,
          clarifyTimeoutError: false
        },
        adapter: getDefaultAdapter(),
        transformRequest: [function transformRequest(data, headers) {
          normalizeHeaderName(headers, "Accept");
          normalizeHeaderName(headers, "Content-Type");
          if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
            return data;
          }
          if (utils.isArrayBufferView(data)) {
            return data.buffer;
          }
          if (utils.isURLSearchParams(data)) {
            setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
            return data.toString();
          }
          if (utils.isObject(data) || headers && headers["Content-Type"] === "application/json") {
            setContentTypeIfUnset(headers, "application/json");
            return stringifySafely(data);
          }
          return data;
        }],
        transformResponse: [function transformResponse(data) {
          var transitional = this.transitional || defaults.transitional;
          var silentJSONParsing = transitional && transitional.silentJSONParsing;
          var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
          var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
          if (strictJSONParsing || forcedJSONParsing && utils.isString(data) && data.length) {
            try {
              return JSON.parse(data);
            } catch (e) {
              if (strictJSONParsing) {
                if (e.name === "SyntaxError") {
                  throw enhanceError(e, this, "E_JSON_PARSE");
                }
                throw e;
              }
            }
          }
          return data;
        }],
        timeout: 0,
        xsrfCookieName: "XSRF-TOKEN",
        xsrfHeaderName: "X-XSRF-TOKEN",
        maxContentLength: -1,
        maxBodyLength: -1,
        validateStatus: function validateStatus(status) {
          return status >= 200 && status < 300;
        },
        headers: {
          common: {
            "Accept": "application/json, text/plain, */*"
          }
        }
      };
      utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
        defaults.headers[method] = {};
      });
      utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
        defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
      });
      module2.exports = defaults;
    }
  });

  // node_modules/axios/lib/core/transformData.js
  var require_transformData = __commonJS({
    "node_modules/axios/lib/core/transformData.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var defaults = require_defaults();
      module2.exports = function transformData(data, headers, fns) {
        var context = this || defaults;
        utils.forEach(fns, function transform(fn) {
          data = fn.call(context, data, headers);
        });
        return data;
      };
    }
  });

  // node_modules/axios/lib/cancel/isCancel.js
  var require_isCancel = __commonJS({
    "node_modules/axios/lib/cancel/isCancel.js"(exports2, module2) {
      "use strict";
      module2.exports = function isCancel(value) {
        return !!(value && value.__CANCEL__);
      };
    }
  });

  // node_modules/axios/lib/core/dispatchRequest.js
  var require_dispatchRequest = __commonJS({
    "node_modules/axios/lib/core/dispatchRequest.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var transformData = require_transformData();
      var isCancel = require_isCancel();
      var defaults = require_defaults();
      var Cancel = require_Cancel();
      function throwIfCancellationRequested(config) {
        if (config.cancelToken) {
          config.cancelToken.throwIfRequested();
        }
        if (config.signal && config.signal.aborted) {
          throw new Cancel("canceled");
        }
      }
      module2.exports = function dispatchRequest(config) {
        throwIfCancellationRequested(config);
        config.headers = config.headers || {};
        config.data = transformData.call(config, config.data, config.headers, config.transformRequest);
        config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
        utils.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
          delete config.headers[method];
        });
        var adapter = config.adapter || defaults.adapter;
        return adapter(config).then(function onAdapterResolution(response) {
          throwIfCancellationRequested(config);
          response.data = transformData.call(config, response.data, response.headers, config.transformResponse);
          return response;
        }, function onAdapterRejection(reason) {
          if (!isCancel(reason)) {
            throwIfCancellationRequested(config);
            if (reason && reason.response) {
              reason.response.data = transformData.call(config, reason.response.data, reason.response.headers, config.transformResponse);
            }
          }
          return Promise.reject(reason);
        });
      };
    }
  });

  // node_modules/axios/lib/core/mergeConfig.js
  var require_mergeConfig = __commonJS({
    "node_modules/axios/lib/core/mergeConfig.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      module2.exports = function mergeConfig(config1, config2) {
        config2 = config2 || {};
        var config = {};
        function getMergedValue(target, source) {
          if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
            return utils.merge(target, source);
          } else if (utils.isPlainObject(source)) {
            return utils.merge({}, source);
          } else if (utils.isArray(source)) {
            return source.slice();
          }
          return source;
        }
        function mergeDeepProperties(prop) {
          if (!utils.isUndefined(config2[prop])) {
            return getMergedValue(config1[prop], config2[prop]);
          } else if (!utils.isUndefined(config1[prop])) {
            return getMergedValue(void 0, config1[prop]);
          }
        }
        function valueFromConfig2(prop) {
          if (!utils.isUndefined(config2[prop])) {
            return getMergedValue(void 0, config2[prop]);
          }
        }
        function defaultToConfig2(prop) {
          if (!utils.isUndefined(config2[prop])) {
            return getMergedValue(void 0, config2[prop]);
          } else if (!utils.isUndefined(config1[prop])) {
            return getMergedValue(void 0, config1[prop]);
          }
        }
        function mergeDirectKeys(prop) {
          if (prop in config2) {
            return getMergedValue(config1[prop], config2[prop]);
          } else if (prop in config1) {
            return getMergedValue(void 0, config1[prop]);
          }
        }
        var mergeMap = {
          "url": valueFromConfig2,
          "method": valueFromConfig2,
          "data": valueFromConfig2,
          "baseURL": defaultToConfig2,
          "transformRequest": defaultToConfig2,
          "transformResponse": defaultToConfig2,
          "paramsSerializer": defaultToConfig2,
          "timeout": defaultToConfig2,
          "timeoutMessage": defaultToConfig2,
          "withCredentials": defaultToConfig2,
          "adapter": defaultToConfig2,
          "responseType": defaultToConfig2,
          "xsrfCookieName": defaultToConfig2,
          "xsrfHeaderName": defaultToConfig2,
          "onUploadProgress": defaultToConfig2,
          "onDownloadProgress": defaultToConfig2,
          "decompress": defaultToConfig2,
          "maxContentLength": defaultToConfig2,
          "maxBodyLength": defaultToConfig2,
          "transport": defaultToConfig2,
          "httpAgent": defaultToConfig2,
          "httpsAgent": defaultToConfig2,
          "cancelToken": defaultToConfig2,
          "socketPath": defaultToConfig2,
          "responseEncoding": defaultToConfig2,
          "validateStatus": mergeDirectKeys
        };
        utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
          var merge = mergeMap[prop] || mergeDeepProperties;
          var configValue = merge(prop);
          utils.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
        });
        return config;
      };
    }
  });

  // node_modules/axios/lib/env/data.js
  var require_data = __commonJS({
    "node_modules/axios/lib/env/data.js"(exports2, module2) {
      module2.exports = {
        "version": "0.23.0"
      };
    }
  });

  // node_modules/axios/lib/helpers/validator.js
  var require_validator = __commonJS({
    "node_modules/axios/lib/helpers/validator.js"(exports2, module2) {
      "use strict";
      var VERSION = require_data().version;
      var validators = {};
      ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
        validators[type] = function validator(thing) {
          return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
        };
      });
      var deprecatedWarnings = {};
      validators.transitional = function transitional(validator, version2, message) {
        function formatMessage(opt, desc) {
          return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
        }
        return function(value, opt, opts) {
          if (validator === false) {
            throw new Error(formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : "")));
          }
          if (version2 && !deprecatedWarnings[opt]) {
            deprecatedWarnings[opt] = true;
            console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future"));
          }
          return validator ? validator(value, opt, opts) : true;
        };
      };
      function assertOptions(options, schema, allowUnknown) {
        if (typeof options !== "object") {
          throw new TypeError("options must be an object");
        }
        var keys = Object.keys(options);
        var i = keys.length;
        while (i-- > 0) {
          var opt = keys[i];
          var validator = schema[opt];
          if (validator) {
            var value = options[opt];
            var result = value === void 0 || validator(value, opt, options);
            if (result !== true) {
              throw new TypeError("option " + opt + " must be " + result);
            }
            continue;
          }
          if (allowUnknown !== true) {
            throw Error("Unknown option " + opt);
          }
        }
      }
      module2.exports = {
        assertOptions,
        validators
      };
    }
  });

  // node_modules/axios/lib/core/Axios.js
  var require_Axios = __commonJS({
    "node_modules/axios/lib/core/Axios.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var buildURL = require_buildURL();
      var InterceptorManager = require_InterceptorManager();
      var dispatchRequest = require_dispatchRequest();
      var mergeConfig = require_mergeConfig();
      var validator = require_validator();
      var validators = validator.validators;
      function Axios(instanceConfig) {
        this.defaults = instanceConfig;
        this.interceptors = {
          request: new InterceptorManager(),
          response: new InterceptorManager()
        };
      }
      Axios.prototype.request = function request(config) {
        if (typeof config === "string") {
          config = arguments[1] || {};
          config.url = arguments[0];
        } else {
          config = config || {};
        }
        config = mergeConfig(this.defaults, config);
        if (config.method) {
          config.method = config.method.toLowerCase();
        } else if (this.defaults.method) {
          config.method = this.defaults.method.toLowerCase();
        } else {
          config.method = "get";
        }
        var transitional = config.transitional;
        if (transitional !== void 0) {
          validator.assertOptions(transitional, {
            silentJSONParsing: validators.transitional(validators.boolean),
            forcedJSONParsing: validators.transitional(validators.boolean),
            clarifyTimeoutError: validators.transitional(validators.boolean)
          }, false);
        }
        var requestInterceptorChain = [];
        var synchronousRequestInterceptors = true;
        this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
          if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
            return;
          }
          synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
          requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
        });
        var responseInterceptorChain = [];
        this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
          responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
        });
        var promise;
        if (!synchronousRequestInterceptors) {
          var chain = [dispatchRequest, void 0];
          Array.prototype.unshift.apply(chain, requestInterceptorChain);
          chain = chain.concat(responseInterceptorChain);
          promise = Promise.resolve(config);
          while (chain.length) {
            promise = promise.then(chain.shift(), chain.shift());
          }
          return promise;
        }
        var newConfig = config;
        while (requestInterceptorChain.length) {
          var onFulfilled = requestInterceptorChain.shift();
          var onRejected = requestInterceptorChain.shift();
          try {
            newConfig = onFulfilled(newConfig);
          } catch (error) {
            onRejected(error);
            break;
          }
        }
        try {
          promise = dispatchRequest(newConfig);
        } catch (error) {
          return Promise.reject(error);
        }
        while (responseInterceptorChain.length) {
          promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
        }
        return promise;
      };
      Axios.prototype.getUri = function getUri(config) {
        config = mergeConfig(this.defaults, config);
        return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
      };
      utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
        Axios.prototype[method] = function(url, config) {
          return this.request(mergeConfig(config || {}, {
            method,
            url,
            data: (config || {}).data
          }));
        };
      });
      utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
        Axios.prototype[method] = function(url, data, config) {
          return this.request(mergeConfig(config || {}, {
            method,
            url,
            data
          }));
        };
      });
      module2.exports = Axios;
    }
  });

  // node_modules/axios/lib/cancel/CancelToken.js
  var require_CancelToken = __commonJS({
    "node_modules/axios/lib/cancel/CancelToken.js"(exports2, module2) {
      "use strict";
      var Cancel = require_Cancel();
      function CancelToken(executor) {
        if (typeof executor !== "function") {
          throw new TypeError("executor must be a function.");
        }
        var resolvePromise;
        this.promise = new Promise(function promiseExecutor(resolve) {
          resolvePromise = resolve;
        });
        var token = this;
        this.promise.then(function(cancel) {
          if (!token._listeners)
            return;
          var i;
          var l = token._listeners.length;
          for (i = 0; i < l; i++) {
            token._listeners[i](cancel);
          }
          token._listeners = null;
        });
        this.promise.then = function(onfulfilled) {
          var _resolve;
          var promise = new Promise(function(resolve) {
            token.subscribe(resolve);
            _resolve = resolve;
          }).then(onfulfilled);
          promise.cancel = function reject() {
            token.unsubscribe(_resolve);
          };
          return promise;
        };
        executor(function cancel(message) {
          if (token.reason) {
            return;
          }
          token.reason = new Cancel(message);
          resolvePromise(token.reason);
        });
      }
      CancelToken.prototype.throwIfRequested = function throwIfRequested() {
        if (this.reason) {
          throw this.reason;
        }
      };
      CancelToken.prototype.subscribe = function subscribe(listener) {
        if (this.reason) {
          listener(this.reason);
          return;
        }
        if (this._listeners) {
          this._listeners.push(listener);
        } else {
          this._listeners = [listener];
        }
      };
      CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
        if (!this._listeners) {
          return;
        }
        var index = this._listeners.indexOf(listener);
        if (index !== -1) {
          this._listeners.splice(index, 1);
        }
      };
      CancelToken.source = function source() {
        var cancel;
        var token = new CancelToken(function executor(c) {
          cancel = c;
        });
        return {
          token,
          cancel
        };
      };
      module2.exports = CancelToken;
    }
  });

  // node_modules/axios/lib/helpers/spread.js
  var require_spread = __commonJS({
    "node_modules/axios/lib/helpers/spread.js"(exports2, module2) {
      "use strict";
      module2.exports = function spread(callback) {
        return function wrap(arr) {
          return callback.apply(null, arr);
        };
      };
    }
  });

  // node_modules/axios/lib/helpers/isAxiosError.js
  var require_isAxiosError = __commonJS({
    "node_modules/axios/lib/helpers/isAxiosError.js"(exports2, module2) {
      "use strict";
      module2.exports = function isAxiosError(payload) {
        return typeof payload === "object" && payload.isAxiosError === true;
      };
    }
  });

  // node_modules/axios/lib/axios.js
  var require_axios = __commonJS({
    "node_modules/axios/lib/axios.js"(exports2, module2) {
      "use strict";
      var utils = require_utils();
      var bind2 = require_bind();
      var Axios = require_Axios();
      var mergeConfig = require_mergeConfig();
      var defaults = require_defaults();
      function createInstance(defaultConfig) {
        var context = new Axios(defaultConfig);
        var instance = bind2(Axios.prototype.request, context);
        utils.extend(instance, Axios.prototype, context);
        utils.extend(instance, context);
        instance.create = function create(instanceConfig) {
          return createInstance(mergeConfig(defaultConfig, instanceConfig));
        };
        return instance;
      }
      var axios2 = createInstance(defaults);
      axios2.Axios = Axios;
      axios2.Cancel = require_Cancel();
      axios2.CancelToken = require_CancelToken();
      axios2.isCancel = require_isCancel();
      axios2.VERSION = require_data().version;
      axios2.all = function all(promises) {
        return Promise.all(promises);
      };
      axios2.spread = require_spread();
      axios2.isAxiosError = require_isAxiosError();
      module2.exports = axios2;
      module2.exports.default = axios2;
    }
  });

  // node_modules/axios/index.js
  var require_axios2 = __commonJS({
    "node_modules/axios/index.js"(exports2, module2) {
      module2.exports = require_axios();
    }
  });

  // src/index.ts
  require_require();
  var axios = require_axios2();
  cb.settings_choices = [];
  for (i = 1; i <= 10; i++) {
    cb.settings_choices.push({
      label: "Tip Amount " + i,
      name: "tipamount" + i,
      required: false,
      type: "int"
    }, {
      label: "Tip Msg " + i,
      name: "tipmsg" + i,
      required: false,
      type: "str"
    });
  }
  var i;
  cb.onTip(function(tip) {
    return __async(this, null, function* () {
      let resp = yield axios.get("https://neemsworld.com/api/test");
      cb.sendNotice(`got response: ${resp.data.msg}`);
      var msgPublic = "";
      for (var n = 1; n <= 10; n++) {
        if (parseInt(tip["amount"]) == cb.settings["tipamount" + n]) {
          msgPublic = cb.settings["tipmsg" + n];
        }
      }
      if (msgPublic) {
        msgPublic = msgPublic.replace("[tipper]", tip["from_user"]);
        cb.sendNotice(msgPublic, "", "test", "", "bold", "");
      }
    });
  });
})();