zar 0.1.3 → 0.2.0

package/dist/zar.es.js

@@ -18,95 +18,107 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-function dotProp(t2, e2, l2, n2, r2) {
+function i$3(t2, e2, l2, n2, r2) {
   for (e2 = e2.split ? e2.split(".") : e2, n2 = 0; n2 < e2.length; n2++)
     t2 = t2 ? t2[e2[n2]] : r2;
   return t2 === r2 ? l2 : t2;
 }
-var F$4 = typeof process != "undefined" ? process : {};
-F$4.env && F$4.env.NODE_ENV || "";
-var $$5 = typeof window != "undefined";
-F$4.versions != null && F$4.versions.node != null;
+var e = "undefined", o$2 = "object", g$1 = "any", m$1 = "*", j$1 = "__", F$2 = typeof process != "undefined" ? process : {};
+F$2.env && F$2.env.NODE_ENV || "";
+var $$1 = typeof window != "undefined";
+F$2.versions != null && F$2.versions.node != null;
 typeof Deno != "undefined" && Deno.core !== void 0;
-$$5 && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-function M$5(n2, t2) {
+$$1 && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
+function M$1(n2, t2) {
   return t2.charAt(0)[n2]() + t2.slice(1);
 }
-var U$4 = M$5.bind(null, "toUpperCase"), H$5 = M$5.bind(null, "toLowerCase");
-function J$4(n2) {
-  return Y$4(n2) ? U$4("null") : typeof n2 == "object" ? yn$4(n2) : Object.prototype.toString.call(n2).slice(8, -1);
+var U$1 = M$1.bind(null, "toUpperCase"), H$1 = M$1.bind(null, "toLowerCase");
+function J$2(n2) {
+  return Y$1(n2) ? U$1("null") : typeof n2 == "object" ? yn(n2) : Object.prototype.toString.call(n2).slice(8, -1);
 }
-function R$4(n2, t2) {
+function R$1(n2, t2) {
   t2 === void 0 && (t2 = true);
-  var e2 = J$4(n2);
-  return t2 ? H$5(e2) : e2;
+  var e2 = J$2(n2);
+  return t2 ? H$1(e2) : e2;
 }
-function V$4(n2, t2) {
+function V$1(n2, t2) {
   return typeof t2 === n2;
 }
-var W$4 = V$4.bind(null, "function"), q$4 = V$4.bind(null, "string");
-V$4.bind(null, "undefined");
-V$4.bind(null, "boolean");
-V$4.bind(null, "symbol");
-function Y$4(n2) {
+var W$1 = V$1.bind(null, "function"), q$1 = V$1.bind(null, "string"), I$2 = V$1.bind(null, "undefined");
+var Q$1 = V$1.bind(null, "boolean");
+V$1.bind(null, "symbol");
+function Y$1(n2) {
   return n2 === null;
 }
-function nn$4(n2) {
-  return R$4(n2) === "number" && !isNaN(n2);
+function nn(n2) {
+  return R$1(n2) === "number" && !isNaN(n2);
+}
+function rn(n2) {
+  return R$1(n2) === "array";
 }
-function yn$4(n2) {
-  return W$4(n2.constructor) ? n2.constructor.name : null;
+function on(n2) {
+  if (!un(n2))
+    return false;
+  for (var t2 = n2; Object.getPrototypeOf(t2) !== null; )
+    t2 = Object.getPrototypeOf(t2);
+  return Object.getPrototypeOf(n2) === t2;
+}
+function un(n2) {
+  return n2 && (typeof n2 == "object" || n2 !== null);
+}
+function yn(n2) {
+  return W$1(n2.constructor) ? n2.constructor.name : null;
 }
-function hn$4(n2) {
-  return n2 instanceof Error || q$4(n2.message) && n2.constructor && nn$4(n2.constructor.stackTraceLimit);
+function hn(n2) {
+  return n2 instanceof Error || q$1(n2.message) && n2.constructor && nn(n2.constructor.stackTraceLimit);
 }
-function On$4(n2, t2) {
-  if (typeof t2 != "object" || Y$4(t2))
+function On(n2, t2) {
+  if (typeof t2 != "object" || Y$1(t2))
     return false;
   if (t2 instanceof n2)
     return true;
-  var e2 = R$4(new n2(""));
-  if (hn$4(t2))
+  var e2 = R$1(new n2(""));
+  if (hn(t2))
     for (; t2; ) {
-      if (R$4(t2) === e2)
+      if (R$1(t2) === e2)
         return true;
       t2 = Object.getPrototypeOf(t2);
     }
   return false;
 }
-On$4.bind(null, TypeError);
-On$4.bind(null, SyntaxError);
-function $n$4(n2, t2) {
+On.bind(null, TypeError);
+On.bind(null, SyntaxError);
+function $n(n2, t2) {
   var e2 = n2 instanceof Element || n2 instanceof HTMLDocument;
-  return e2 && t2 ? Tn$4(n2, t2) : e2;
+  return e2 && t2 ? Tn(n2, t2) : e2;
 }
-function Tn$4(n2, t2) {
+function Tn(n2, t2) {
   return t2 === void 0 && (t2 = ""), n2 && n2.nodeName === t2.toUpperCase();
 }
-function _n$4(n2) {
+function _n(n2) {
   var t2 = [].slice.call(arguments, 1);
   return function() {
     return n2.apply(void 0, [].slice.call(arguments).concat(t2));
   };
 }
-_n$4($n$4, "form");
-_n$4($n$4, "button");
-_n$4($n$4, "input");
-_n$4($n$4, "select");
-function n$5(e2) {
+_n($n, "form");
+_n($n, "button");
+_n($n, "input");
+_n($n, "select");
+function n$1(e2) {
   try {
     return decodeURIComponent(e2.replace(/\+/g, " "));
   } catch (e3) {
     return null;
   }
 }
-function o$8() {
-  if ($$5) {
+function o$1() {
+  if ($$1) {
     var r2 = navigator, t2 = r2.languages;
     return r2.userLanguage || (t2 && t2.length ? t2[0] : r2.language);
   }
 }
-function a$5() {
+function a$3() {
   try {
     return Intl.DateTimeFormat().resolvedOptions().timeZone;
   } catch (e2) {
@@ -115,7 +127,7 @@ function a$5() {
 function s(r2) {
   return function(e2) {
     for (var r3, t2 = /* @__PURE__ */ Object.create(null), o2 = /([^&=]+)=?([^&]*)/g; r3 = o2.exec(e2); ) {
-      var a2 = n$5(r3[1]), i2 = n$5(r3[2]);
+      var a2 = n$1(r3[1]), i2 = n$1(r3[2]);
       a2.substring(a2.length - 2) === "[]" ? (t2[a2 = a2.substring(0, a2.length - 2)] || (t2[a2] = [])).push(i2) : t2[a2] = i2 === "" || i2;
     }
     for (var u2 in t2) {
@@ -130,7 +142,7 @@ function s(r2) {
       var t2 = r3.match(/\?(.*)/);
       return t2 && t2[1] ? t2[1].split("#")[0] : "";
     }
-    return $$5 && window.location.search.substring(1);
+    return $$1 && window.location.search.substring(1);
   }(r2));
 }
 function m(e2, r2, t2) {
@@ -149,3109 +161,954 @@ function y$1() {
   }
   return e2;
 }
-var o$7 = "object", j$3 = "__", F$3 = typeof process != "undefined" ? process : {};
-F$3.env && F$3.env.NODE_ENV || "";
-var $$4 = typeof window != "undefined";
-F$3.versions != null && F$3.versions.node != null;
-typeof Deno != "undefined" && Deno.core !== void 0;
-$$4 && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-function M$4(n2, t2) {
-  return t2.charAt(0)[n2]() + t2.slice(1);
-}
-var U$3 = M$4.bind(null, "toUpperCase"), H$4 = M$4.bind(null, "toLowerCase");
-function J$3(n2) {
-  return Y$3(n2) ? U$3("null") : typeof n2 == "object" ? yn$3(n2) : Object.prototype.toString.call(n2).slice(8, -1);
+var l = "global", o = j$1 + "global" + j$1, n = typeof self === o$2 && self.self === self && self || typeof global === o$2 && global.global === global && global || void 0;
+function a$2(t2) {
+  return n[o][t2];
 }
-function R$3(n2, t2) {
-  t2 === void 0 && (t2 = true);
-  var e2 = J$3(n2);
-  return t2 ? H$4(e2) : e2;
+function f(t2, e2) {
+  return n[o][t2] = e2;
 }
-function V$3(n2, t2) {
-  return typeof t2 === n2;
+function i$2(t2) {
+  delete n[o][t2];
 }
-var W$3 = V$3.bind(null, "function"), q$3 = V$3.bind(null, "string");
-V$3.bind(null, "undefined");
-V$3.bind(null, "boolean");
-V$3.bind(null, "symbol");
-function Y$3(n2) {
-  return n2 === null;
+function u$1(t2, e2, r2) {
+  var l2;
+  try {
+    if (b$2(t2)) {
+      var o2 = window[t2];
+      l2 = o2[e2].bind(o2);
+    }
+  } catch (t3) {
+  }
+  return l2 || r2;
 }
-function nn$3(n2) {
-  return R$3(n2) === "number" && !isNaN(n2);
+n[o] || (n[o] = {});
+var c$1 = {};
+function b$2(t2) {
+  if (typeof c$1[t2] !== e)
+    return c$1[t2];
+  try {
+    var e$1 = window[t2];
+    e$1.setItem(e, e), e$1.removeItem(e);
+  } catch (e2) {
+    return c$1[t2] = false;
+  }
+  return c$1[t2] = true;
+}
+function v() {
+  return v = Object.assign || function(e2) {
+    for (var n2 = 1; n2 < arguments.length; n2++) {
+      var t2 = arguments[n2];
+      for (var r2 in t2)
+        Object.prototype.hasOwnProperty.call(t2, r2) && (e2[r2] = t2[r2]);
+    }
+    return e2;
+  }, v.apply(this, arguments);
+}
+var y = "function", b$1 = "undefined", I$1 = "@@redux/" + Math.random().toString(36), w = /* @__PURE__ */ function() {
+  return typeof Symbol === y && Symbol.observable || "@@observable";
+}(), E$1 = " != " + y;
+function P(e2, n2, t2) {
+  var r2;
+  if (typeof n2 === y && typeof t2 === b$1 && (t2 = n2, n2 = void 0), typeof t2 !== b$1) {
+    if (typeof t2 !== y)
+      throw new Error("enhancer" + E$1);
+    return t2(P)(e2, n2);
+  }
+  if (typeof e2 !== y)
+    throw new Error("reducer" + E$1);
+  var i2 = e2, a2 = n2, o2 = [], u2 = o2, c2 = false;
+  function s2() {
+    u2 === o2 && (u2 = o2.slice());
+  }
+  function f2() {
+    return a2;
+  }
+  function d2(e3) {
+    if (typeof e3 !== y)
+      throw new Error("Listener" + E$1);
+    var n3 = true;
+    return s2(), u2.push(e3), function() {
+      if (n3) {
+        n3 = false, s2();
+        var t3 = u2.indexOf(e3);
+        u2.splice(t3, 1);
+      }
+    };
+  }
+  function p(e3) {
+    if (!on(e3))
+      throw new Error("Act != obj");
+    if (typeof e3.type === b$1)
+      throw new Error("ActType " + b$1);
+    if (c2)
+      throw new Error("Dispatch in reducer");
+    try {
+      c2 = true, a2 = i2(a2, e3);
+    } finally {
+      c2 = false;
+    }
+    for (var n3 = o2 = u2, t3 = 0; t3 < n3.length; t3++)
+      (0, n3[t3])();
+    return e3;
+  }
+  return p({ type: "@@redux/INIT" }), (r2 = { dispatch: p, subscribe: d2, getState: f2, replaceReducer: function(e3) {
+    if (typeof e3 !== y)
+      throw new Error("next reducer" + E$1);
+    i2 = e3, p({ type: "@@redux/INIT" });
+  } })[w] = function() {
+    var e3, n3 = d2;
+    return (e3 = { subscribe: function(e4) {
+      if (typeof e4 != "object")
+        throw new TypeError("Observer != obj");
+      function t3() {
+        e4.next && e4.next(f2());
+      }
+      return t3(), { unsubscribe: n3(t3) };
+    } })[w] = function() {
+      return this;
+    }, e3;
+  }, r2;
+}
+function S(e2, n2) {
+  var t2 = n2 && n2.type;
+  return "action " + (t2 && t2.toString() || "?") + "reducer " + e2 + " returns " + b$1;
+}
+function N$1() {
+  var e2 = [].slice.call(arguments);
+  return e2.length === 0 ? function(e3) {
+    return e3;
+  } : e2.length === 1 ? e2[0] : e2.reduce(function(e3, n2) {
+    return function() {
+      return e3(n2.apply(void 0, [].slice.call(arguments)));
+    };
+  });
 }
-function yn$3(n2) {
-  return W$3(n2.constructor) ? n2.constructor.name : null;
+function O$1() {
+  var e2 = arguments;
+  return function(n2) {
+    return function(t2, r2, i2) {
+      var a2, o2 = n2(t2, r2, i2), u2 = o2.dispatch, c2 = { getState: o2.getState, dispatch: function(e3) {
+        return u2(e3);
+      } };
+      return a2 = [].slice.call(e2).map(function(e3) {
+        return e3(c2);
+      }), v({}, o2, { dispatch: u2 = N$1.apply(void 0, a2)(o2.dispatch) });
+    };
+  };
 }
-function hn$3(n2) {
-  return n2 instanceof Error || q$3(n2.message) && n2.constructor && nn$3(n2.constructor.stackTraceLimit);
+var A$1 = j$1 + "anon_id", _ = j$1 + "user_id", x$1 = j$1 + "user_traits", j = "userId", T = "anonymousId", z = ["bootstrap", "params", "campaign", "initializeStart", "initialize", "initializeEnd", "ready", "resetStart", "reset", "resetEnd", "pageStart", "page", "pageEnd", "pageAborted", "trackStart", "track", "trackEnd", "trackAborted", "identifyStart", "identify", "identifyEnd", "identifyAborted", "userIdChanged", "registerPlugins", "enablePlugin", "disablePlugin", "online", "offline", "setItemStart", "setItem", "setItemEnd", "setItemAborted", "removeItemStart", "removeItem", "removeItemEnd", "removeItemAborted"], M = ["name", "EVENTS", "config", "loaded"], q = z.reduce(function(e2, n2) {
+  return e2[n2] = n2, e2;
+}, { registerPluginType: function(e2) {
+  return "registerPlugin:" + e2;
+}, pluginReadyType: function(e2) {
+  return "ready:" + e2;
+} }), U = /^utm_/, V = /^an_prop_/, L$1 = /^an_trait_/;
+function C$1(e2) {
+  var n2 = e2.storage.setItem;
+  return function(t2) {
+    return function(r2) {
+      return function(i2) {
+        if (i2.type === q.bootstrap) {
+          var a2 = i2.params, o2 = i2.user, u2 = i2.persistedUser, c2 = i2.initialUser, s2 = u2.userId === o2.userId;
+          u2.anonymousId !== o2.anonymousId && n2(A$1, o2.anonymousId), s2 || n2(_, o2.userId), c2.traits && n2(x$1, v({}, s2 && u2.traits ? u2.traits : {}, c2.traits));
+          var l2 = Object.keys(i2.params);
+          if (l2.length) {
+            var f2 = a2.an_uid, d2 = a2.an_event, p = l2.reduce(function(e3, n3) {
+              if (n3.match(U) || n3.match(/^(d|g)clid/)) {
+                var t3 = n3.replace(U, "");
+                e3.campaign[t3 === "campaign" ? "name" : t3] = a2[n3];
+              }
+              return n3.match(V) && (e3.props[n3.replace(V, "")] = a2[n3]), n3.match(L$1) && (e3.traits[n3.replace(L$1, "")] = a2[n3]), e3;
+            }, { campaign: {}, props: {}, traits: {} });
+            t2.dispatch(v({ type: q.params, raw: a2 }, p, f2 ? { userId: f2 } : {})), f2 && setTimeout(function() {
+              return e2.identify(f2, p.traits);
+            }, 0), d2 && setTimeout(function() {
+              return e2.track(d2, p.props);
+            }, 0), Object.keys(p.campaign).length && t2.dispatch({ type: q.campaign, campaign: p.campaign });
+          }
+        }
+        return r2(i2);
+      };
+    };
+  };
 }
-function On$3(n2, t2) {
-  if (typeof t2 != "object" || Y$3(t2))
-    return false;
-  if (t2 instanceof n2)
-    return true;
-  var e2 = R$3(new n2(""));
-  if (hn$3(t2))
-    for (; t2; ) {
-      if (R$3(t2) === e2)
-        return true;
-      t2 = Object.getPrototypeOf(t2);
+function R(e2) {
+  return function(n2, t2) {
+    if (n2 === void 0 && (n2 = {}), t2 === void 0 && (t2 = {}), t2.type === q.setItemEnd) {
+      if (t2.key === A$1)
+        return v({}, n2, { anonymousId: t2.value });
+      if (t2.key === _)
+        return v({}, n2, { userId: t2.value });
+    }
+    switch (t2.type) {
+      case q.identify:
+        return Object.assign({}, n2, { userId: t2.userId, traits: v({}, n2.traits, t2.traits) });
+      case q.reset:
+        return [_, A$1, x$1].forEach(function(n3) {
+          e2.removeItem(n3);
+        }), Object.assign({}, n2, { userId: null, anonymousId: null, traits: {} });
+      default:
+        return n2;
     }
-  return false;
-}
-On$3.bind(null, TypeError);
-On$3.bind(null, SyntaxError);
-function $n$3(n2, t2) {
-  var e2 = n2 instanceof Element || n2 instanceof HTMLDocument;
-  return e2 && t2 ? Tn$3(n2, t2) : e2;
+  };
 }
-function Tn$3(n2, t2) {
-  return t2 === void 0 && (t2 = ""), n2 && n2.nodeName === t2.toUpperCase();
+function $(e2) {
+  return { userId: e2.getItem(_), anonymousId: e2.getItem(A$1), traits: e2.getItem(x$1) };
 }
-function _n$3(n2) {
-  var t2 = [].slice.call(arguments, 1);
-  return function() {
-    return n2.apply(void 0, [].slice.call(arguments).concat(t2));
+var D = function(e2) {
+  return j$1 + "TEMP" + j$1 + e2;
+};
+function B(n2) {
+  var t2 = n2.storage, r2 = t2.setItem, i2 = t2.removeItem, a2 = t2.getItem;
+  return function(n3) {
+    return function(t3) {
+      return function(u2) {
+        var c2 = u2.userId, s2 = u2.traits, l2 = u2.options;
+        if (u2.type === q.reset && ([_, x$1, A$1].forEach(function(e2) {
+          i2(e2);
+        }), [j, T, "traits"].forEach(function(e2) {
+          i$2(D(e2));
+        })), u2.type === q.identify) {
+          a2(A$1) || r2(A$1, y$1());
+          var f2 = a2(_), d2 = a2(x$1) || {};
+          f2 && f2 !== c2 && n3.dispatch({ type: q.userIdChanged, old: { userId: f2, traits: d2 }, new: { userId: c2, traits: s2 }, options: l2 }), c2 && r2(_, c2), s2 && r2(x$1, v({}, d2, s2));
+        }
+        return t3(u2);
+      };
+    };
   };
 }
-_n$3($n$3, "form");
-_n$3($n$3, "button");
-_n$3($n$3, "input");
-_n$3($n$3, "select");
-var o$6 = j$3 + "global" + j$3, n$4 = typeof self === o$7 && self.self === self && self || typeof global === o$7 && global.global === global && global || void 0;
-function a$4(t2) {
-  return n$4[o$6][t2];
+var X = {};
+function J$1(e2, n2) {
+  X[e2] && W$1(X[e2]) && (X[e2](n2), delete X[e2]);
 }
-function f$4(t2, e2) {
-  return n$4[o$6][t2] = e2;
+function W(e2, n2, t2) {
+  return new Promise(function(r2, i2) {
+    return n2() ? r2(e2) : t2 < 1 ? i2(v({}, e2, { queue: true })) : new Promise(function(e3) {
+      return setTimeout(e3, 10);
+    }).then(function(a2) {
+      return W(e2, n2, t2 - 10).then(r2, i2);
+    });
+  });
 }
-function i$4(t2) {
-  delete n$4[o$6][t2];
+function H(e2, n2, t2) {
+  var r2 = n2(), i2 = e2.getState(), a2 = i2.plugins, o2 = i2.queue, u2 = i2.user;
+  if (!i2.context.offline && o2 && o2.actions && o2.actions.length) {
+    var c2 = o2.actions.reduce(function(e3, n3, t3) {
+      return a2[n3.plugin].loaded ? (e3.process.push(n3), e3.processIndex.push(t3)) : (e3.requeue.push(n3), e3.requeueIndex.push(t3)), e3;
+    }, { processIndex: [], process: [], requeue: [], requeueIndex: [] });
+    if (c2.processIndex && c2.processIndex.length) {
+      c2.processIndex.forEach(function(n3) {
+        var i3 = o2.actions[n3], c3 = i3.plugin, s3 = i3.payload.type, l2 = r2[c3][s3];
+        if (l2 && W$1(l2)) {
+          var f2 = function(e3, n4) {
+            return e3 === void 0 && (e3 = {}), n4 === void 0 && (n4 = {}), [j, T].reduce(function(t3, r3) {
+              return e3.hasOwnProperty(r3) && n4[r3] && n4[r3] !== e3[r3] && (t3[r3] = n4[r3]), t3;
+            }, e3);
+          }(i3.payload, u2);
+          l2({ payload: f2, config: a2[c3].config, instance: t2 });
+          var p = s3 + ":" + c3;
+          e2.dispatch(v({}, f2, { type: p, _: { called: p, from: "queueDrain" } }));
+        }
+      });
+      var s2 = o2.actions.filter(function(e3, n3) {
+        return !~c2.processIndex.indexOf(n3);
+      });
+      o2.actions = s2;
+    }
+  }
 }
-n$4[o$6] || (n$4[o$6] = {});
-var n$3, f$3 = "any", l$1 = "*", p = "__", h$1 = typeof process != "undefined" ? process : {};
-((n$3 = h$1.env) == null ? void 0 : n$3.NODE_ENV) || "";
-var z = typeof window != "undefined";
-h$1.versions != null && h$1.versions.node != null;
-typeof Deno != "undefined" && Deno.core !== void 0;
-z && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-function C$1(n2, e2) {
-  return typeof e2 === n2;
+var F$1 = function(e2) {
+  var n2 = e2.data, t2 = e2.action, r2 = e2.instance, i2 = e2.state, a2 = e2.allPlugins, o2 = e2.allMatches, u2 = e2.store, c2 = e2.EVENTS;
+  try {
+    var s2 = i2.plugins, f2 = i2.context, p = t2.type, m2 = p.match(G$1), g2 = n2.exact.map(function(e3) {
+      return e3.pluginName;
+    });
+    m2 && (g2 = o2.during.map(function(e3) {
+      return e3.pluginName;
+    }));
+    var h2 = function(e3, n3) {
+      return function(t3, r3, i3) {
+        var a3 = r3.config, o3 = r3.name, u3 = o3 + "." + t3.type;
+        i3 && (u3 = i3.event);
+        var c3 = t3.type.match(G$1) ? function(e4, n4, t4, r4, i4) {
+          return function(a4, o4) {
+            var u4 = r4 ? r4.name : e4, c4 = o4 && ie(o4) ? o4 : t4;
+            if (r4 && (!(c4 = o4 && ie(o4) ? o4 : [e4]).includes(e4) || c4.length !== 1))
+              throw new Error("Method " + n4 + " can only abort " + e4 + " plugin. " + JSON.stringify(c4) + " input valid");
+            return v({}, i4, { abort: { reason: a4, plugins: c4, caller: n4, _: u4 } });
+          };
+        }(o3, u3, n3, i3, t3) : function(e4, n4) {
+          return function() {
+            throw new Error(e4.type + " action not cancellable. Remove abort in " + n4);
+          };
+        }(t3, u3);
+        return { payload: ue(t3), instance: e3, config: a3 || {}, abort: c3 };
+      };
+    }(r2, g2), y2 = n2.exact.reduce(function(e3, n3) {
+      var t3 = n3.pluginName, r3 = n3.methodName, i3 = false;
+      return r3.match(/^initialize/) || r3.match(/^reset/) || (i3 = !s2[t3].loaded), f2.offline && r3.match(/^(page|track|identify)/) && (i3 = true), e3["" + t3] = i3, e3;
+    }, {});
+    return Promise.resolve(n2.exact.reduce(function(e3, i3, o3) {
+      var u3 = i3.pluginName;
+      return Promise.resolve(e3).then(function(e4) {
+        function i4() {
+          return Promise.resolve(e4);
+        }
+        var o4 = function() {
+          if (n2.namespaced && n2.namespaced[u3])
+            return Promise.resolve(n2.namespaced[u3].reduce(function(e5, n3, t3) {
+              return Promise.resolve(e5).then(function(e6) {
+                return n3.method && W$1(n3.method) ? (function(e7, n4) {
+                  var t5 = oe(e7);
+                  if (t5 && t5.name === n4) {
+                    var r3 = oe(t5.method);
+                    throw new Error([n4 + " plugin is calling method " + e7, "Plugins cant call self", "Use " + t5.method + " " + (r3 ? "or " + r3.method : "") + " in " + n4 + " plugin insteadof " + e7].join("\n"));
+                  }
+                }(n3.methodName, n3.pluginName), Promise.resolve(n3.method({ payload: e6, instance: r2, abort: (t4 = e6, i5 = u3, o5 = n3.pluginName, function(e7, n4) {
+                  return v({}, t4, { abort: { reason: e7, plugins: n4 || [i5], caller: p, from: o5 || i5 } });
+                }), config: Z(n3.pluginName, s2, a2), plugins: s2 })).then(function(n4) {
+                  var t5 = on(n4) ? n4 : {};
+                  return Promise.resolve(v({}, e6, t5));
+                })) : e6;
+                var t4, i5, o5;
+              });
+            }, Promise.resolve(t2))).then(function(n3) {
+              e4[u3] = n3;
+            });
+          e4[u3] = t2;
+        }();
+        return o4 && o4.then ? o4.then(i4) : i4();
+      });
+    }, Promise.resolve({}))).then(function(e3) {
+      return Promise.resolve(n2.exact.reduce(function(t3, i3, o3) {
+        try {
+          var c3 = n2.exact.length === o3 + 1, f3 = i3.pluginName, d2 = a2[f3];
+          return Promise.resolve(t3).then(function(n3) {
+            var t4 = e3[f3] ? e3[f3] : {};
+            if (m2 && (t4 = n3), te(t4, f3))
+              return Y({ data: t4, method: p, instance: r2, pluginName: f3, store: u2 }), Promise.resolve(n3);
+            if (te(n3, f3))
+              return c3 && Y({ data: n3, method: p, instance: r2, store: u2 }), Promise.resolve(n3);
+            if (y2.hasOwnProperty(f3) && y2[f3] === true)
+              return u2.dispatch({ type: "queue", plugin: f3, payload: t4, _: { called: "queue", from: "queueMechanism" } }), Promise.resolve(n3);
+            var i4 = h2(e3[f3], a2[f3]);
+            return Promise.resolve(d2[p]({ abort: i4.abort, payload: t4, instance: r2, config: Z(f3, s2, a2), plugins: s2 })).then(function(i5) {
+              var a3 = on(i5) ? i5 : {}, o4 = v({}, n3, a3), c4 = e3[f3];
+              if (te(c4, f3))
+                Y({ data: c4, method: p, instance: r2, pluginName: f3, store: u2 });
+              else {
+                var s3 = p + ":" + f3;
+                (s3.match(/:/g) || []).length < 2 && !p.match(K) && !p.match(Q) && r2.dispatch(v({}, m2 ? o4 : t4, { type: s3, _: { called: s3, from: "submethod" } }));
+              }
+              return Promise.resolve(o4);
+            });
+          });
+        } catch (e4) {
+          return Promise.reject(e4);
+        }
+      }, Promise.resolve(t2))).then(function(e4) {
+        if (!(p.match(G$1) || p.match(/^registerPlugin/) || p.match(Q) || p.match(K) || p.match(/^params/) || p.match(/^userIdChanged/))) {
+          if (c2.plugins.includes(p), e4._ && e4._.originalAction === p)
+            return e4;
+          var t3 = v({}, e4, { _: { originalAction: e4.type, called: e4.type, from: "engineEnd" } });
+          re(e4, n2.exact.length) && !p.match(/End$/) && (t3 = v({}, t3, { type: e4.type + "Aborted" })), u2.dispatch(t3);
+        }
+        return e4;
+      });
+    });
+  } catch (e3) {
+    return Promise.reject(e3);
+  }
+}, G$1 = /Start$/, K = /^bootstrap/, Q = /^ready/;
+function Y(e2) {
+  var n2 = e2.pluginName, t2 = e2.method + "Aborted" + (n2 ? ":" + n2 : "");
+  e2.store.dispatch(v({}, e2.data, { type: t2, _: { called: t2, from: "abort" } }));
 }
-var _ = C$1.bind(null, "function"), L$1 = C$1.bind(null, "string"), $$3 = C$1.bind(null, "undefined"), x$1 = C$1.bind(null, "boolean");
-function G(n2) {
-  return Object.prototype.toString.call(n2) === "[object Array]";
+function Z(e2, n2, t2) {
+  var r2 = n2[e2] || t2[e2];
+  return r2 && r2.config ? r2.config : {};
 }
-function H$3(n2) {
-  return n2 && (typeof n2 == "object" || n2 !== null);
+function ee(e2, n2) {
+  return n2.reduce(function(n3, t2) {
+    return t2[e2] ? n3.concat({ methodName: e2, pluginName: t2.name, method: t2[e2] }) : n3;
+  }, []);
+}
+function ne(e2, n2) {
+  var t2 = e2.replace(G$1, ""), r2 = n2 ? ":" + n2 : "";
+  return ["" + e2 + r2, "" + t2 + r2, t2 + "End" + r2];
 }
-function M$3(n2) {
-  if (!H$3(n2))
+function te(e2, n2) {
+  var t2 = e2.abort;
+  return !!t2 && (t2 === true || ae(t2, n2) || t2 && ae(t2.plugins, n2));
+}
+function re(e2, n2) {
+  var t2 = e2.abort;
+  if (!t2)
     return false;
-  for (var e2 = n2; Object.getPrototypeOf(e2) !== null; )
-    e2 = Object.getPrototypeOf(e2);
-  return Object.getPrototypeOf(n2) === e2;
+  if (t2 === true || q$1(t2))
+    return true;
+  var r2 = t2.plugins;
+  return ie(t2) && t2.length === n2 || ie(r2) && r2.length === n2;
 }
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length)
-    len = arr.length;
-  for (var i2 = 0, arr2 = new Array(len); i2 < len; i2++) {
-    arr2[i2] = arr[i2];
-  }
-  return arr2;
+function ie(e2) {
+  return Array.isArray(e2);
 }
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr))
-    return _arrayLikeToArray(arr);
+function ae(e2, n2) {
+  return !(!e2 || !ie(e2)) && e2.includes(n2);
 }
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
-    return Array.from(iter);
+function oe(e2) {
+  var n2 = e2.match(/(.*):(.*)/);
+  return !!n2 && { method: n2[1], name: n2[2] };
 }
-function _unsupportedIterableToArray(o2, minLen) {
-  if (!o2)
-    return;
-  if (typeof o2 === "string")
-    return _arrayLikeToArray(o2, minLen);
-  var n2 = Object.prototype.toString.call(o2).slice(8, -1);
-  if (n2 === "Object" && o2.constructor)
-    n2 = o2.constructor.name;
-  if (n2 === "Map" || n2 === "Set")
-    return Array.from(o2);
-  if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
-    return _arrayLikeToArray(o2, minLen);
+function ue(e2) {
+  return Object.keys(e2).reduce(function(n2, t2) {
+    return t2 === "type" || (n2[t2] = on(e2[t2]) ? Object.assign({}, e2[t2]) : e2[t2]), n2;
+  }, {});
+}
+function ce(e2, n2, t2) {
+  var r2 = {};
+  return function(i2) {
+    return function(a2) {
+      return function(o2) {
+        try {
+          var u2, c2 = function(e3) {
+            return u2 ? e3 : a2(f2);
+          }, s2 = o2.type, l2 = o2.plugins, f2 = o2;
+          if (o2.abort)
+            return Promise.resolve(a2(o2));
+          if (s2 === q.enablePlugin && i2.dispatch({ type: q.initializeStart, plugins: l2, disabled: [], fromEnable: true, meta: o2.meta }), s2 === q.disablePlugin && setTimeout(function() {
+            return J$1(o2.meta.rid, { payload: o2 });
+          }, 0), s2 === q.initializeEnd) {
+            var m2 = n2(), g2 = Object.keys(m2), h2 = g2.filter(function(e3) {
+              return l2.includes(e3);
+            }).map(function(e3) {
+              return m2[e3];
+            }), y2 = [], b2 = [], I2 = o2.disabled, w2 = h2.map(function(e3) {
+              var n3 = e3.name;
+              return W(e3, e3.loaded, 1e4).then(function(t3) {
+                return r2[n3] || (i2.dispatch({ type: q.pluginReadyType(n3), name: n3, events: Object.keys(e3).filter(function(e4) {
+                  return !M.includes(e4);
+                }) }), r2[n3] = true), y2 = y2.concat(n3), e3;
+              }).catch(function(e4) {
+                if (e4 instanceof Error)
+                  throw new Error(e4);
+                return b2 = b2.concat(e4.name), e4;
+              });
+            });
+            Promise.all(w2).then(function(e3) {
+              var n3 = { plugins: y2, failed: b2, disabled: I2 };
+              setTimeout(function() {
+                g2.length === w2.length + I2.length && i2.dispatch(v({}, { type: q.ready }, n3));
+              }, 0);
+            });
+          }
+          var E2 = function() {
+            if (s2 !== q.bootstrap)
+              return /^ready:([^:]*)$/.test(s2) && setTimeout(function() {
+                return H(i2, n2, e2);
+              }, 0), Promise.resolve(function(e3, n3, t3, r3, i3) {
+                try {
+                  var a3 = W$1(n3) ? n3() : n3, o3 = e3.type, u3 = o3.replace(G$1, "");
+                  if (e3._ && e3._.called)
+                    return Promise.resolve(e3);
+                  var c3 = t3.getState(), s3 = (m3 = a3, (g3 = c3.plugins) === void 0 && (g3 = {}), (h3 = e3.options) === void 0 && (h3 = {}), Object.keys(m3).filter(function(e4) {
+                    var n4 = h3.plugins || {};
+                    return Q$1(n4[e4]) ? n4[e4] : n4.all !== false && (!g3[e4] || g3[e4].enabled !== false);
+                  }).map(function(e4) {
+                    return m3[e4];
+                  }));
+                  o3 === q.initializeStart && e3.fromEnable && (s3 = Object.keys(c3.plugins).filter(function(n4) {
+                    var t4 = c3.plugins[n4];
+                    return e3.plugins.includes(n4) && !t4.initialized;
+                  }).map(function(e4) {
+                    return a3[e4];
+                  }));
+                  var l3 = s3.map(function(e4) {
+                    return e4.name;
+                  }), f3 = function(e4, n4, t4) {
+                    var r4 = ne(e4).map(function(e5) {
+                      return ee(e5, n4);
+                    });
+                    return n4.reduce(function(t5, r5) {
+                      var i4 = r5.name, a4 = ne(e4, i4).map(function(e5) {
+                        return ee(e5, n4);
+                      }), o4 = a4[0], u4 = a4[1], c4 = a4[2];
+                      return o4.length && (t5.beforeNS[i4] = o4), u4.length && (t5.duringNS[i4] = u4), c4.length && (t5.afterNS[i4] = c4), t5;
+                    }, { before: r4[0], beforeNS: {}, during: r4[1], duringNS: {}, after: r4[2], afterNS: {} });
+                  }(o3, s3);
+                  return Promise.resolve(F$1({ action: e3, data: { exact: f3.before, namespaced: f3.beforeNS }, state: c3, allPlugins: a3, allMatches: f3, instance: t3, store: r3, EVENTS: i3 })).then(function(e4) {
+                    function n4() {
+                      var n5 = function() {
+                        if (o3.match(G$1))
+                          return Promise.resolve(F$1({ action: v({}, s4, { type: u3 + "End" }), data: { exact: f3.after, namespaced: f3.afterNS }, state: c3, allPlugins: a3, allMatches: f3, instance: t3, store: r3, EVENTS: i3 })).then(function(e5) {
+                            e5.meta && e5.meta.hasCallback && J$1(e5.meta.rid, { payload: e5 });
+                          });
+                      }();
+                      return n5 && n5.then ? n5.then(function() {
+                        return e4;
+                      }) : e4;
+                    }
+                    if (re(e4, l3.length))
+                      return e4;
+                    var s4, d2 = function() {
+                      if (o3 !== u3)
+                        return Promise.resolve(F$1({ action: v({}, e4, { type: u3 }), data: { exact: f3.during, namespaced: f3.duringNS }, state: c3, allPlugins: a3, allMatches: f3, instance: t3, store: r3, EVENTS: i3 })).then(function(e5) {
+                          s4 = e5;
+                        });
+                      s4 = e4;
+                    }();
+                    return d2 && d2.then ? d2.then(n4) : n4();
+                  });
+                } catch (e4) {
+                  return Promise.reject(e4);
+                }
+                var m3, g3, h3;
+              }(o2, n2, e2, i2, t2)).then(function(e3) {
+                var n3 = a2(e3);
+                return u2 = 1, n3;
+              });
+          }();
+          return Promise.resolve(E2 && E2.then ? E2.then(c2) : c2(E2));
+        } catch (e3) {
+          return Promise.reject(e3);
+        }
+      };
+    };
+  };
 }
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function se(e2) {
+  return function(n2) {
+    return function(n3) {
+      return function(t2) {
+        var r2 = t2.type, i2 = t2.key, a2 = t2.value, o2 = t2.options;
+        if (r2 === q.setItem || r2 === q.removeItem) {
+          if (t2.abort)
+            return n3(t2);
+          r2 === q.setItem ? e2.setItem(i2, a2, o2) : e2.removeItem(i2, o2);
+        }
+        return n3(t2);
+      };
+    };
+  };
+}
+var le = function() {
+  var e2 = this;
+  this.before = [], this.after = [], this.addMiddleware = function(n2, t2) {
+    e2[t2] = e2[t2].concat(n2);
+  }, this.removeMiddleware = function(n2, t2) {
+    var r2 = e2[t2].findIndex(function(e3) {
+      return e3 === n2;
+    });
+    r2 !== -1 && (e2[t2] = [].concat(e2[t2].slice(0, r2), e2[t2].slice(r2 + 1)));
+  }, this.dynamicMiddlewares = function(n2) {
+    return function(t2) {
+      return function(r2) {
+        return function(i2) {
+          var a2 = { getState: t2.getState, dispatch: function(e3) {
+            return t2.dispatch(e3);
+          } }, o2 = e2[n2].map(function(e3) {
+            return e3(a2);
+          });
+          return N$1.apply(void 0, o2)(r2)(i2);
+        };
+      };
+    };
+  };
+};
+function fe(e2) {
+  return function(n2, t2) {
+    n2 === void 0 && (n2 = {});
+    var r2 = {};
+    if (t2.type === "initialize:aborted")
+      return n2;
+    if (/^registerPlugin:([^:]*)$/.test(t2.type)) {
+      var i2 = de(t2.type, "registerPlugin"), a2 = e2()[i2];
+      if (!a2 || !i2)
+        return n2;
+      var o2 = t2.enabled;
+      return r2[i2] = { enabled: o2, initialized: !!o2 && Boolean(!a2.initialize), loaded: !!o2 && Boolean(a2.loaded()), config: a2.config || {} }, v({}, n2, r2);
+    }
+    if (/^initialize:([^:]*)$/.test(t2.type)) {
+      var u2 = de(t2.type, q.initialize), c2 = e2()[u2];
+      return c2 && u2 ? (r2[u2] = v({}, n2[u2], { initialized: true, loaded: Boolean(c2.loaded()) }), v({}, n2, r2)) : n2;
+    }
+    if (/^ready:([^:]*)$/.test(t2.type))
+      return r2[t2.name] = v({}, n2[t2.name], { loaded: true }), v({}, n2, r2);
+    switch (t2.type) {
+      case q.disablePlugin:
+        return v({}, n2, pe(t2.plugins, false, n2));
+      case q.enablePlugin:
+        return v({}, n2, pe(t2.plugins, true, n2));
+      default:
+        return n2;
+    }
+  };
 }
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+function de(e2, n2) {
+  return e2.substring(n2.length + 1, e2.length);
 }
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-  return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
-    return typeof obj2;
-  } : function(obj2) {
-    return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-  }, _typeof(obj);
+function pe(e2, n2, t2) {
+  return e2.reduce(function(e3, r2) {
+    return e3[r2] = v({}, t2[r2], { enabled: n2 }), e3;
+  }, t2);
 }
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+function me(e2) {
   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);
+    return JSON.parse(JSON.stringify(e2));
+  } catch (e3) {
   }
+  return e2;
 }
-function _asyncToGenerator(fn) {
-  return function() {
-    var self2 = this, args = arguments;
-    return new Promise(function(resolve, reject) {
-      var gen = fn.apply(self2, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(void 0);
-    });
-  };
+var ge = { last: {}, history: [] };
+function he(e2, n2) {
+  e2 === void 0 && (e2 = ge);
+  var t2 = n2.options, r2 = n2.meta;
+  if (n2.type === q.track) {
+    var i2 = me(v({ event: n2.event, properties: n2.properties }, Object.keys(t2).length && { options: t2 }, { meta: r2 }));
+    return v({}, e2, { last: i2, history: e2.history.concat(i2) });
+  }
+  return e2;
 }
-function _defineProperty$2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
+var ve = { actions: [] };
+function ye(e2, n2) {
+  e2 === void 0 && (e2 = ve);
+  var t2 = n2.payload;
+  switch (n2.type) {
+    case "queue":
+      var r2;
+      return r2 = t2 && t2.type && t2.type === q.identify ? [n2].concat(e2.actions) : e2.actions.concat(n2), v({}, e2, { actions: r2 });
+    case "dequeue":
+      return [];
+    default:
+      return e2;
+  }
+}
+var be = /#.*$/;
+function Ie(e2) {
+  var n2 = /(http[s]?:\/\/)?([^\/\s]+\/)(.*)/g.exec(e2);
+  return "/" + (n2 && n2[3] ? n2[3].split("?")[0].replace(be, "") : "");
+}
+var we, Ee, Pe, Se, Ne = function(e2) {
+  if (e2 === void 0 && (e2 = {}), !$$1)
+    return e2;
+  var n2 = document, t2 = n2.title, r2 = n2.referrer, i2 = window, a2 = i2.location, o2 = i2.innerWidth, u2 = i2.innerHeight, c2 = a2.hash, s2 = a2.search, l2 = function(e3) {
+    var n3 = function() {
+      if ($$1) {
+        for (var e4, n4 = document.getElementsByTagName("link"), t3 = 0; e4 = n4[t3]; t3++)
+          if (e4.getAttribute("rel") === "canonical")
+            return e4.getAttribute("href");
+      }
+    }();
+    return n3 ? n3.match(/\?/) ? n3 : n3 + e3 : window.location.href.replace(be, "");
+  }(s2), f2 = { title: t2, url: l2, path: Ie(l2), hash: c2, search: s2, width: o2, height: u2 };
+  return r2 && r2 !== "" && (f2.referrer = r2), v({}, f2, e2);
+}, Oe = { last: {}, history: [] };
+function Ae(e2, n2) {
+  e2 === void 0 && (e2 = Oe);
+  var t2 = n2.options;
+  if (n2.type === q.page) {
+    var r2 = me(v({ properties: n2.properties, meta: n2.meta }, Object.keys(t2).length && { options: t2 }));
+    return v({}, e2, { last: r2, history: e2.history.concat(r2) });
   }
-  return obj;
+  return e2;
 }
-function ownKeys$1(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function(sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
+we = function() {
+  if (!$$1)
+    return false;
+  var e2 = navigator.appVersion;
+  return ~e2.indexOf("Win") ? "Windows" : ~e2.indexOf("Mac") ? "MacOS" : ~e2.indexOf("X11") ? "UNIX" : ~e2.indexOf("Linux") ? "Linux" : "Unknown OS";
+}(), Ee = $$1 ? document.referrer : null, Pe = o$1(), Se = a$3();
+var _e = { initialized: false, sessionId: y$1(), app: null, version: null, debug: false, offline: !!$$1 && !navigator.onLine, os: { name: we }, userAgent: $$1 ? navigator.userAgent : "node", library: { name: "analytics", version: "0.11.0" }, timezone: Se, locale: Pe, campaign: {}, referrer: Ee };
+function xe(e2, n2) {
+  e2 === void 0 && (e2 = _e);
+  var t2 = e2.initialized, r2 = n2.campaign;
+  switch (n2.type) {
+    case q.campaign:
+      return v({}, e2, { campaign: r2 });
+    case q.offline:
+      return v({}, e2, { offline: true });
+    case q.online:
+      return v({}, e2, { offline: false });
+    default:
+      return t2 ? e2 : v({}, _e, e2, { initialized: true });
   }
-  return keys;
 }
-function _objectSpread2$1(target) {
-  for (var i2 = 1; i2 < arguments.length; i2++) {
-    var source = arguments[i2] != null ? arguments[i2] : {};
-    i2 % 2 ? ownKeys$1(Object(source), true).forEach(function(key) {
-      _defineProperty$2(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function(key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+var ke = ["plugins", "reducers", "storage"];
+function je(e2, n2, t2) {
+  if ($$1) {
+    var r2 = window[(t2 ? "add" : "remove") + "EventListener"];
+    e2.split(" ").forEach(function(e3) {
+      r2(e3, n2);
     });
   }
-  return target;
 }
-var runtime = { exports: {} };
-(function(module) {
-  var runtime2 = function(exports) {
-    var Op = Object.prototype;
-    var hasOwn = Op.hasOwnProperty;
-    var undefined$1;
-    var $Symbol = typeof Symbol === "function" ? Symbol : {};
-    var iteratorSymbol = $Symbol.iterator || "@@iterator";
-    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-    function define(obj, key, value) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-      return obj[key];
-    }
+function Te(e2) {
+  var n2 = je.bind(null, "online offline", function(n3) {
+    return Promise.resolve(!navigator.onLine).then(e2);
+  });
+  return n2(true), function(e3) {
+    return n2(false);
+  };
+}
+function ze() {
+  return f("analytics", []), function(e2) {
+    return function(n$12, t2, r2) {
+      var i2 = e2(n$12, t2, r2), a2 = i2.dispatch;
+      return Object.assign(i2, { dispatch: function(e3) {
+        return n[o].analytics.push(e3.action || e3), a2(e3);
+      } });
+    };
+  };
+}
+function Me(e2) {
+  return function() {
+    return N$1(N$1.apply(null, arguments), ze());
+  };
+}
+function qe(e2) {
+  return e2 ? rn(e2) ? e2 : [e2] : [];
+}
+function Ue(n2, t2, r2) {
+  n2 === void 0 && (n2 = {});
+  var i2, a2, o2 = y$1();
+  return t2 && (X[o2] = (i2 = t2, a2 = function(e2) {
+    for (var n3, t3 = e2 || Array.prototype.slice.call(arguments), r3 = 0; r3 < t3.length; r3++)
+      if (W$1(t3[r3])) {
+        n3 = t3[r3];
+        break;
+      }
+    return n3;
+  }(r2), function(e2) {
+    a2 && a2(e2), i2(e2);
+  })), v({}, n2, { rid: o2, ts: new Date().getTime() }, t2 ? { hasCallback: true } : {});
+}
+function Ve(n2) {
+  n2 === void 0 && (n2 = {});
+  var t2 = n2.reducers || {}, c2 = n2.initialUser || {}, s$1 = (n2.plugins || []).reduce(function(e2, n3) {
+    if (W$1(n3))
+      return e2.middlewares = e2.middlewares.concat(n3), e2;
+    if (n3.NAMESPACE && (n3.name = n3.NAMESPACE), !n3.name)
+      throw new Error("https://lytics.dev/errors/1");
+    var t3 = n3.EVENTS ? Object.keys(n3.EVENTS).map(function(e3) {
+      return n3.EVENTS[e3];
+    }) : [];
+    e2.pluginEnabled[n3.name] = !(n3.enabled === false || n3.config && n3.config.enabled === false), delete n3.enabled, n3.methods && (e2.methods[n3.name] = Object.keys(n3.methods).reduce(function(e3, t4) {
+      var r3;
+      return e3[t4] = (r3 = n3.methods[t4], function() {
+        for (var e4 = Array.prototype.slice.call(arguments), n4 = new Array(r3.length), t5 = 0; t5 < e4.length; t5++)
+          n4[t5] = e4[t5];
+        return n4[n4.length] = K2, r3.apply({ instance: K2 }, n4);
+      }), e3;
+    }, {}), delete n3.methods);
+    var r2 = Object.keys(n3).concat(t3), i2 = new Set(e2.events.concat(r2));
+    if (e2.events = Array.from(i2), e2.pluginsArray = e2.pluginsArray.concat(n3), e2.plugins[n3.name])
+      throw new Error(n3.name + "AlreadyLoaded");
+    return e2.plugins[n3.name] = n3, e2.plugins[n3.name].loaded || (e2.plugins[n3.name].loaded = function() {
+      return true;
+    }), e2;
+  }, { plugins: {}, pluginEnabled: {}, methods: {}, pluginsArray: [], middlewares: [], events: [] }), f$1 = n2.storage ? n2.storage : { getItem: a$2, setItem: f, removeItem: i$2 }, p = function(e2) {
+    return function(n3, t3, r2) {
+      return t3.getState("user")[n3] || (r2 && on(r2) && r2[n3] ? r2[n3] : $(e2)[n3] || a$2(D(n3)) || null);
+    };
+  }(f$1), h2 = s$1.plugins, w2 = s$1.events.filter(function(e2) {
+    return !M.includes(e2);
+  }).sort(), E2 = new Set(w2.concat(z).filter(function(e2) {
+    return !M.includes(e2);
+  })), _2 = Array.from(E2).sort(), x2 = function() {
+    return h2;
+  }, k2 = new le(), U2 = k2.addMiddleware, V2 = k2.removeMiddleware, L2 = k2.dynamicMiddlewares, X2 = function() {
+    throw new Error("Abort disabled inListener");
+  }, J2 = s(), W2 = $(f$1), F2 = v({}, W2, c2, J2.an_uid ? { userId: J2.an_uid } : {}, J2.an_aid ? { anonymousId: J2.an_aid } : {});
+  F2.anonymousId || (F2.anonymousId = y$1());
+  var G2 = v({ enable: function(e2, n3) {
+    return new Promise(function(t3) {
+      oe2.dispatch({ type: q.enablePlugin, plugins: qe(e2), _: { originalAction: q.enablePlugin } }, t3, [n3]);
+    });
+  }, disable: function(e2, n3) {
+    return new Promise(function(t3) {
+      oe2.dispatch({ type: q.disablePlugin, plugins: qe(e2), _: { originalAction: q.disablePlugin } }, t3, [n3]);
+    });
+  } }, s$1.methods), K2 = { identify: function(e2, n3, t3, r2) {
     try {
-      define({}, "");
-    } catch (err) {
-      define = function(obj, key, value) {
-        return obj[key] = value;
-      };
+      var i2 = q$1(e2) ? e2 : null, a2 = on(e2) ? e2 : n3, o2 = t3 || {}, c3 = K2.user();
+      f(D(j), i2);
+      var s2 = i2 || a2.userId || p(j, K2, a2);
+      return Promise.resolve(new Promise(function(e3) {
+        oe2.dispatch(v({ type: q.identifyStart, userId: s2, traits: a2 || {}, options: o2, anonymousId: c3.anonymousId }, c3.id && c3.id !== i2 && { previousId: c3.id }), e3, [n3, t3, r2]);
+      }));
+    } catch (e3) {
+      return Promise.reject(e3);
     }
-    function wrap(innerFn, outerFn, self2, tryLocsList) {
-      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
-      var generator = Object.create(protoGenerator.prototype);
-      var context2 = new Context(tryLocsList || []);
-      generator._invoke = makeInvokeMethod(innerFn, self2, context2);
-      return generator;
+  }, track: function(e2, n3, t3, r2) {
+    try {
+      var i2 = on(e2) ? e2.event : e2;
+      if (!i2 || !q$1(i2))
+        throw new Error("EventMissing");
+      var a2 = on(e2) ? e2 : n3 || {}, o2 = on(t3) ? t3 : {};
+      return Promise.resolve(new Promise(function(e3) {
+        oe2.dispatch({ type: q.trackStart, event: i2, properties: a2, options: o2, userId: p(j, K2, n3), anonymousId: p(T, K2, n3) }, e3, [n3, t3, r2]);
+      }));
+    } catch (e3) {
+      return Promise.reject(e3);
     }
-    exports.wrap = wrap;
-    function tryCatch(fn, obj, arg) {
-      try {
-        return {
-          type: "normal",
-          arg: fn.call(obj, arg)
+  }, page: function(e2, n3, t3) {
+    try {
+      var r2 = on(e2) ? e2 : {}, i2 = on(n3) ? n3 : {};
+      return Promise.resolve(new Promise(function(a2) {
+        oe2.dispatch({ type: q.pageStart, properties: Ne(r2), options: i2, userId: p(j, K2, r2), anonymousId: p(T, K2, r2) }, a2, [e2, n3, t3]);
+      }));
+    } catch (e3) {
+      return Promise.reject(e3);
+    }
+  }, user: function(e2) {
+    if (e2 === j || e2 === "id")
+      return p(j, K2);
+    if (e2 === T || e2 === "anonId")
+      return p(T, K2);
+    var n3 = K2.getState("user");
+    return e2 ? i$3(n3, e2) : n3;
+  }, reset: function(e2) {
+    return new Promise(function(n3) {
+      oe2.dispatch({ type: q.resetStart }, n3, e2);
+    });
+  }, ready: function(e2) {
+    return K2.on(q.ready, e2);
+  }, on: function(e2, n3) {
+    if (!e2 || !W$1(n3))
+      return false;
+    if (e2 === q.bootstrap)
+      throw new Error(".on disabled for " + e2);
+    var t3 = /Start$|Start:/;
+    if (e2 === "*") {
+      var r2 = function(e3) {
+        return function(e4) {
+          return function(r3) {
+            return r3.type.match(t3) && n3({ payload: r3, instance: K2, plugins: h2 }), e4(r3);
+          };
         };
-      } catch (err) {
-        return {
-          type: "throw",
-          arg: err
+      }, i2 = function(e3) {
+        return function(e4) {
+          return function(r3) {
+            return r3.type.match(t3) || n3({ payload: r3, instance: K2, plugins: h2 }), e4(r3);
+          };
         };
-      }
-    }
-    var GenStateSuspendedStart = "suspendedStart";
-    var GenStateSuspendedYield = "suspendedYield";
-    var GenStateExecuting = "executing";
-    var GenStateCompleted = "completed";
-    var ContinueSentinel = {};
-    function Generator() {
-    }
-    function GeneratorFunction() {
-    }
-    function GeneratorFunctionPrototype() {
-    }
-    var IteratorPrototype = {};
-    define(IteratorPrototype, iteratorSymbol, function() {
-      return this;
-    });
-    var getProto = Object.getPrototypeOf;
-    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-    if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
-      IteratorPrototype = NativeIteratorPrototype;
-    }
-    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-    GeneratorFunction.prototype = GeneratorFunctionPrototype;
-    define(Gp, "constructor", GeneratorFunctionPrototype);
-    define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
-    GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction");
-    function defineIteratorMethods(prototype) {
-      ["next", "throw", "return"].forEach(function(method) {
-        define(prototype, method, function(arg) {
-          return this._invoke(method, arg);
-        });
-      });
+      };
+      return U2(r2, Le), U2(i2, Ce), function() {
+        V2(r2, Le), V2(i2, Ce);
+      };
     }
-    exports.isGeneratorFunction = function(genFun) {
-      var ctor = typeof genFun === "function" && genFun.constructor;
-      return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
-    };
-    exports.mark = function(genFun) {
-      if (Object.setPrototypeOf) {
-        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-      } else {
-        genFun.__proto__ = GeneratorFunctionPrototype;
-        define(genFun, toStringTagSymbol, "GeneratorFunction");
-      }
-      genFun.prototype = Object.create(Gp);
-      return genFun;
-    };
-    exports.awrap = function(arg) {
-      return {
-        __await: arg
+    var a2 = e2.match(t3) ? Le : Ce, o2 = function(t4) {
+      return function(t5) {
+        return function(r3) {
+          return r3.type === e2 && n3({ payload: r3, instance: K2, plugins: h2, abort: X2 }), t5(r3);
+        };
       };
     };
-    function AsyncIterator(generator, PromiseImpl) {
-      function invoke(method, arg, resolve, reject) {
-        var record = tryCatch(generator[method], generator, arg);
-        if (record.type === "throw") {
-          reject(record.arg);
-        } else {
-          var result = record.arg;
-          var value = result.value;
-          if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
-            return PromiseImpl.resolve(value.__await).then(function(value2) {
-              invoke("next", value2, resolve, reject);
-            }, function(err) {
-              invoke("throw", err, resolve, reject);
-            });
-          }
-          return PromiseImpl.resolve(value).then(function(unwrapped) {
-            result.value = unwrapped;
-            resolve(result);
-          }, function(error) {
-            return invoke("throw", error, resolve, reject);
-          });
-        }
-      }
-      var previousPromise;
-      function enqueue(method, arg) {
-        function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function(resolve, reject) {
-            invoke(method, arg, resolve, reject);
-          });
-        }
-        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-      this._invoke = enqueue;
-    }
-    defineIteratorMethods(AsyncIterator.prototype);
-    define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
-      return this;
-    });
-    exports.AsyncIterator = AsyncIterator;
-    exports.async = function(innerFn, outerFn, self2, tryLocsList, PromiseImpl) {
-      if (PromiseImpl === void 0)
-        PromiseImpl = Promise;
-      var iter = new AsyncIterator(wrap(innerFn, outerFn, self2, tryLocsList), PromiseImpl);
-      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
-        return result.done ? result.value : iter.next();
-      });
-    };
-    function makeInvokeMethod(innerFn, self2, context2) {
-      var state = GenStateSuspendedStart;
-      return function invoke(method, arg) {
-        if (state === GenStateExecuting) {
-          throw new Error("Generator is already running");
-        }
-        if (state === GenStateCompleted) {
-          if (method === "throw") {
-            throw arg;
-          }
-          return doneResult();
-        }
-        context2.method = method;
-        context2.arg = arg;
-        while (true) {
-          var delegate = context2.delegate;
-          if (delegate) {
-            var delegateResult = maybeInvokeDelegate(delegate, context2);
-            if (delegateResult) {
-              if (delegateResult === ContinueSentinel)
-                continue;
-              return delegateResult;
-            }
-          }
-          if (context2.method === "next") {
-            context2.sent = context2._sent = context2.arg;
-          } else if (context2.method === "throw") {
-            if (state === GenStateSuspendedStart) {
-              state = GenStateCompleted;
-              throw context2.arg;
-            }
-            context2.dispatchException(context2.arg);
-          } else if (context2.method === "return") {
-            context2.abrupt("return", context2.arg);
-          }
-          state = GenStateExecuting;
-          var record = tryCatch(innerFn, self2, context2);
-          if (record.type === "normal") {
-            state = context2.done ? GenStateCompleted : GenStateSuspendedYield;
-            if (record.arg === ContinueSentinel) {
-              continue;
-            }
-            return {
-              value: record.arg,
-              done: context2.done
-            };
-          } else if (record.type === "throw") {
-            state = GenStateCompleted;
-            context2.method = "throw";
-            context2.arg = record.arg;
-          }
-        }
-      };
-    }
-    function maybeInvokeDelegate(delegate, context2) {
-      var method = delegate.iterator[context2.method];
-      if (method === undefined$1) {
-        context2.delegate = null;
-        if (context2.method === "throw") {
-          if (delegate.iterator["return"]) {
-            context2.method = "return";
-            context2.arg = undefined$1;
-            maybeInvokeDelegate(delegate, context2);
-            if (context2.method === "throw") {
-              return ContinueSentinel;
-            }
-          }
-          context2.method = "throw";
-          context2.arg = new TypeError("The iterator does not provide a 'throw' method");
-        }
-        return ContinueSentinel;
-      }
-      var record = tryCatch(method, delegate.iterator, context2.arg);
-      if (record.type === "throw") {
-        context2.method = "throw";
-        context2.arg = record.arg;
-        context2.delegate = null;
-        return ContinueSentinel;
-      }
-      var info = record.arg;
-      if (!info) {
-        context2.method = "throw";
-        context2.arg = new TypeError("iterator result is not an object");
-        context2.delegate = null;
-        return ContinueSentinel;
-      }
-      if (info.done) {
-        context2[delegate.resultName] = info.value;
-        context2.next = delegate.nextLoc;
-        if (context2.method !== "return") {
-          context2.method = "next";
-          context2.arg = undefined$1;
-        }
-      } else {
-        return info;
-      }
-      context2.delegate = null;
-      return ContinueSentinel;
-    }
-    defineIteratorMethods(Gp);
-    define(Gp, toStringTagSymbol, "Generator");
-    define(Gp, iteratorSymbol, function() {
-      return this;
-    });
-    define(Gp, "toString", function() {
-      return "[object Generator]";
-    });
-    function pushTryEntry(locs) {
-      var entry = {
-        tryLoc: locs[0]
-      };
-      if (1 in locs) {
-        entry.catchLoc = locs[1];
-      }
-      if (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(true);
-    }
-    exports.keys = function(object) {
-      var keys = [];
-      for (var key in object) {
-        keys.push(key);
-      }
-      keys.reverse();
-      return function next() {
-        while (keys.length) {
-          var key2 = keys.pop();
-          if (key2 in object) {
-            next.value = key2;
-            next.done = false;
-            return next;
-          }
-        }
-        next.done = true;
-        return next;
-      };
-    };
-    function values(iterable) {
-      if (iterable) {
-        var iteratorMethod = iterable[iteratorSymbol];
-        if (iteratorMethod) {
-          return iteratorMethod.call(iterable);
-        }
-        if (typeof iterable.next === "function") {
-          return iterable;
-        }
-        if (!isNaN(iterable.length)) {
-          var i2 = -1, next = function next2() {
-            while (++i2 < iterable.length) {
-              if (hasOwn.call(iterable, i2)) {
-                next2.value = iterable[i2];
-                next2.done = false;
-                return next2;
-              }
-            }
-            next2.value = undefined$1;
-            next2.done = true;
-            return next2;
-          };
-          return next.next = next;
-        }
-      }
-      return {
-        next: doneResult
-      };
-    }
-    exports.values = values;
-    function doneResult() {
-      return {
-        value: undefined$1,
-        done: true
-      };
-    }
-    Context.prototype = {
-      constructor: Context,
-      reset: function(skipTempReset) {
-        this.prev = 0;
-        this.next = 0;
-        this.sent = this._sent = undefined$1;
-        this.done = false;
-        this.delegate = null;
-        this.method = "next";
-        this.arg = undefined$1;
-        this.tryEntries.forEach(resetTryEntry);
-        if (!skipTempReset) {
-          for (var name in this) {
-            if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
-              this[name] = undefined$1;
-            }
-          }
-        }
-      },
-      stop: function() {
-        this.done = true;
-        var rootEntry = this.tryEntries[0];
-        var rootRecord = rootEntry.completion;
-        if (rootRecord.type === "throw") {
-          throw rootRecord.arg;
-        }
-        return this.rval;
-      },
-      dispatchException: function(exception) {
-        if (this.done) {
-          throw exception;
-        }
-        var context2 = this;
-        function handle(loc, caught) {
-          record.type = "throw";
-          record.arg = exception;
-          context2.next = loc;
-          if (caught) {
-            context2.method = "next";
-            context2.arg = undefined$1;
-          }
-          return !!caught;
-        }
-        for (var i2 = this.tryEntries.length - 1; i2 >= 0; --i2) {
-          var entry = this.tryEntries[i2];
-          var record = entry.completion;
-          if (entry.tryLoc === "root") {
-            return handle("end");
-          }
-          if (entry.tryLoc <= this.prev) {
-            var hasCatch = hasOwn.call(entry, "catchLoc");
-            var hasFinally = hasOwn.call(entry, "finallyLoc");
-            if (hasCatch && hasFinally) {
-              if (this.prev < entry.catchLoc) {
-                return handle(entry.catchLoc, true);
-              } else if (this.prev < entry.finallyLoc) {
-                return handle(entry.finallyLoc);
-              }
-            } else if (hasCatch) {
-              if (this.prev < entry.catchLoc) {
-                return handle(entry.catchLoc, true);
-              }
-            } else if (hasFinally) {
-              if (this.prev < entry.finallyLoc) {
-                return handle(entry.finallyLoc);
-              }
-            } else {
-              throw new Error("try statement without catch or finally");
-            }
-          }
-        }
-      },
-      abrupt: function(type, arg) {
-        for (var i2 = this.tryEntries.length - 1; i2 >= 0; --i2) {
-          var entry = this.tryEntries[i2];
-          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-            var finallyEntry = entry;
-            break;
-          }
-        }
-        if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
-          finallyEntry = null;
-        }
-        var record = finallyEntry ? finallyEntry.completion : {};
-        record.type = type;
-        record.arg = arg;
-        if (finallyEntry) {
-          this.method = "next";
-          this.next = finallyEntry.finallyLoc;
-          return ContinueSentinel;
-        }
-        return this.complete(record);
-      },
-      complete: function(record, afterLoc) {
-        if (record.type === "throw") {
-          throw record.arg;
-        }
-        if (record.type === "break" || record.type === "continue") {
-          this.next = record.arg;
-        } else if (record.type === "return") {
-          this.rval = this.arg = record.arg;
-          this.method = "return";
-          this.next = "end";
-        } else if (record.type === "normal" && afterLoc) {
-          this.next = afterLoc;
-        }
-        return ContinueSentinel;
-      },
-      finish: function(finallyLoc) {
-        for (var i2 = this.tryEntries.length - 1; i2 >= 0; --i2) {
-          var entry = this.tryEntries[i2];
-          if (entry.finallyLoc === finallyLoc) {
-            this.complete(entry.completion, entry.afterLoc);
-            resetTryEntry(entry);
-            return ContinueSentinel;
-          }
-        }
-      },
-      "catch": function(tryLoc) {
-        for (var i2 = this.tryEntries.length - 1; i2 >= 0; --i2) {
-          var entry = this.tryEntries[i2];
-          if (entry.tryLoc === tryLoc) {
-            var record = entry.completion;
-            if (record.type === "throw") {
-              var thrown = record.arg;
-              resetTryEntry(entry);
-            }
-            return thrown;
-          }
-        }
-        throw new Error("illegal catch attempt");
-      },
-      delegateYield: function(iterable, resultName, nextLoc) {
-        this.delegate = {
-          iterator: values(iterable),
-          resultName,
-          nextLoc
-        };
-        if (this.method === "next") {
-          this.arg = undefined$1;
-        }
-        return ContinueSentinel;
-      }
-    };
-    return exports;
-  }(module.exports);
-  try {
-    regeneratorRuntime = runtime2;
-  } catch (accidentalStrictMode) {
-    if (typeof globalThis === "object") {
-      globalThis.regeneratorRuntime = runtime2;
-    } else {
-      Function("r", "regeneratorRuntime = r")(runtime2);
-    }
-  }
-})(runtime);
-var regenerator = runtime.exports;
-var FUNC = "function";
-var UNDEF = "undefined";
-var REDUCER = "reducer";
-var base = "@@redux/";
-var ACTION_INIT = base + "INIT";
-var ACTION_TEST = base + Math.random().toString(36);
-var $$observable = /* @__PURE__ */ function() {
-  return (typeof Symbol === "undefined" ? "undefined" : _typeof(Symbol)) === FUNC && Symbol.observable || "@@observable";
-}();
-var msg = " != " + FUNC;
-function createStore(reducer, preloadedState, enhancer) {
-  if (_typeof(preloadedState) === FUNC && _typeof(enhancer) === UNDEF) {
-    enhancer = preloadedState;
-    preloadedState = void 0;
-  }
-  if (_typeof(enhancer) !== UNDEF) {
-    if (_typeof(enhancer) !== FUNC) {
-      throw new Error("enhancer" + msg);
-    }
-    return enhancer(createStore)(reducer, preloadedState);
-  }
-  if (_typeof(reducer) !== FUNC) {
-    throw new Error(REDUCER + msg);
-  }
-  var currentReducer = reducer;
-  var currentState = preloadedState;
-  var currentListeners = [];
-  var nextListeners = currentListeners;
-  var isDispatching = false;
-  function ensureCanMutateNextListeners() {
-    if (nextListeners === currentListeners) {
-      nextListeners = currentListeners.slice();
-    }
-  }
-  function getState() {
-    return currentState;
-  }
-  function subscribe(listener) {
-    if (_typeof(listener) !== FUNC) {
-      throw new Error("Listener" + msg);
-    }
-    var isSubscribed = true;
-    ensureCanMutateNextListeners();
-    nextListeners.push(listener);
-    return function unsubscribe() {
-      if (!isSubscribed) {
-        return;
-      }
-      isSubscribed = false;
-      ensureCanMutateNextListeners();
-      var index2 = nextListeners.indexOf(listener);
-      nextListeners.splice(index2, 1);
-    };
-  }
-  function dispatch(action) {
-    if (!M$3(action)) {
-      throw new Error("Act != obj");
-    }
-    if (_typeof(action.type) === UNDEF) {
-      throw new Error("ActType " + UNDEF);
-    }
-    if (isDispatching) {
-      throw new Error("Dispatch in " + REDUCER);
-    }
-    try {
-      isDispatching = true;
-      currentState = currentReducer(currentState, action);
-    } finally {
-      isDispatching = false;
-    }
-    var listeners = currentListeners = nextListeners;
-    for (var i2 = 0; i2 < listeners.length; i2++) {
-      var listener = listeners[i2];
-      listener();
-    }
-    return action;
-  }
-  function replaceReducer(nextReducer) {
-    if (_typeof(nextReducer) !== FUNC) {
-      throw new Error("next " + REDUCER + msg);
-    }
-    currentReducer = nextReducer;
-    dispatch({
-      type: ACTION_INIT
-    });
-  }
-  function observable() {
-    var outerSubscribe = subscribe;
-    return _defineProperty$2({
-      subscribe: function subscribe2(observer) {
-        if (_typeof(observer) !== "object") {
-          throw new TypeError("Observer != obj");
-        }
-        function observeState() {
-          if (observer.next) {
-            observer.next(getState());
-          }
-        }
-        observeState();
-        var unsubscribe = outerSubscribe(observeState);
-        return {
-          unsubscribe
-        };
-      }
-    }, $$observable, function() {
-      return this;
-    });
-  }
-  dispatch({
-    type: ACTION_INIT
-  });
-  return _defineProperty$2({
-    dispatch,
-    subscribe,
-    getState,
-    replaceReducer
-  }, $$observable, observable);
-}
-function getUndefinedStateErrorMessage(key, action) {
-  var actionType = action && action.type;
-  var actionName = actionType && actionType.toString() || "?";
-  return "action " + actionName + REDUCER + " " + key + " returns " + UNDEF;
-}
-function assertReducerShape(reducers) {
-  Object.keys(reducers).forEach(function(key) {
-    var reducer = reducers[key];
-    var initialState2 = reducer(void 0, {
-      type: ACTION_INIT
-    });
-    if (_typeof(initialState2) === UNDEF || _typeof(reducer(void 0, {
-      type: ACTION_TEST
-    })) === UNDEF) {
-      throw new Error(REDUCER + " " + key + " " + UNDEF);
-    }
-  });
-}
-function combineReducers(reducers) {
-  var reducerKeys = Object.keys(reducers);
-  var finalReducers = {};
-  for (var i2 = 0; i2 < reducerKeys.length; i2++) {
-    var key = reducerKeys[i2];
-    if (_typeof(reducers[key]) === FUNC) {
-      finalReducers[key] = reducers[key];
-    }
-  }
-  var finalReducerKeys = Object.keys(finalReducers);
-  var shapeAssertionError;
-  try {
-    assertReducerShape(finalReducers);
-  } catch (e2) {
-    shapeAssertionError = e2;
-  }
-  return function combination() {
-    var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var action = arguments.length > 1 ? arguments[1] : void 0;
-    if (shapeAssertionError) {
-      throw shapeAssertionError;
-    }
-    var hasChanged = false;
-    var nextState = {};
-    for (var _i = 0; _i < finalReducerKeys.length; _i++) {
-      var _key = finalReducerKeys[_i];
-      var reducer = finalReducers[_key];
-      var previousStateForKey = state[_key];
-      var nextStateForKey = reducer(previousStateForKey, action);
-      if (_typeof(nextStateForKey) === UNDEF) {
-        var errorMessage = getUndefinedStateErrorMessage(_key, action);
-        throw new Error(errorMessage);
-      }
-      nextState[_key] = nextStateForKey;
-      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
-    }
-    return hasChanged ? nextState : state;
-  };
-}
-function compose() {
-  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
-    funcs[_key] = arguments[_key];
-  }
-  if (funcs.length === 0) {
-    return function(arg) {
-      return arg;
-    };
-  }
-  if (funcs.length === 1) {
-    return funcs[0];
-  }
-  return funcs.reduce(function(a2, b2) {
-    return function() {
-      return a2(b2.apply(void 0, arguments));
-    };
-  });
-}
-function applyMiddleware() {
-  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {
-    middlewares[_key] = arguments[_key];
-  }
-  return function(createStore2) {
-    return function(reducer, preloadedState, enhancer) {
-      var store = createStore2(reducer, preloadedState, enhancer);
-      var _dispatch = store.dispatch;
-      var chain = [];
-      var middlewareAPI = {
-        getState: store.getState,
-        dispatch: function dispatch(action) {
-          return _dispatch(action);
-        }
-      };
-      chain = middlewares.map(function(middleware) {
-        return middleware(middlewareAPI);
-      });
-      _dispatch = compose.apply(void 0, _toConsumableArray(chain))(store.dispatch);
-      return _objectSpread2$1(_objectSpread2$1({}, store), {}, {
-        dispatch: _dispatch
-      });
-    };
-  };
-}
-var ANON_ID = p + "anon_id";
-var USER_ID = p + "user_id";
-var USER_TRAITS = p + "user_traits";
-var LIB_NAME = "analytics";
-var ID = "userId";
-var ANONID = "anonymousId";
-var ERROR_URL = "https://lytics.dev/errors/";
-var coreEvents = [
-  "bootstrap",
-  "params",
-  "campaign",
-  "initializeStart",
-  "initialize",
-  "initializeEnd",
-  "ready",
-  "resetStart",
-  "reset",
-  "resetEnd",
-  "pageStart",
-  "page",
-  "pageEnd",
-  "pageAborted",
-  "trackStart",
-  "track",
-  "trackEnd",
-  "trackAborted",
-  "identifyStart",
-  "identify",
-  "identifyEnd",
-  "identifyAborted",
-  "userIdChanged",
-  "registerPlugins",
-  "enablePlugin",
-  "disablePlugin",
-  "online",
-  "offline",
-  "setItemStart",
-  "setItem",
-  "setItemEnd",
-  "setItemAborted",
-  "removeItemStart",
-  "removeItem",
-  "removeItemEnd",
-  "removeItemAborted"
-];
-var nonEvents = ["name", "EVENTS", "config", "loaded"];
-var pluginEvents = {
-  registerPluginType: function registerPluginType(name) {
-    return "registerPlugin:".concat(name);
-  },
-  pluginReadyType: function pluginReadyType(name) {
-    return "ready:".concat(name);
-  }
-};
-var EVENTS = coreEvents.reduce(function(acc, curr) {
-  acc[curr] = curr;
-  return acc;
-}, pluginEvents);
-var EVENTS$1 = EVENTS;
-function isReservedAction(type) {
-  return coreEvents.includes(type);
-}
-var utmRegex = /^utm_/;
-var propRegex = /^an_prop_/;
-var traitRegex = /^an_trait_/;
-function initializeMiddleware(instance) {
-  var setItem = instance.storage.setItem;
-  return function(store) {
-    return function(next) {
-      return function(action) {
-        if (action.type === EVENTS$1.bootstrap) {
-          var params = action.params, user = action.user, persistedUser = action.persistedUser, initialUser = action.initialUser;
-          var isKnownId = persistedUser.userId === user.userId;
-          if (persistedUser.anonymousId !== user.anonymousId) {
-            setItem(ANON_ID, user.anonymousId);
-          }
-          if (!isKnownId) {
-            setItem(USER_ID, user.userId);
-          }
-          if (initialUser.traits) {
-            setItem(USER_TRAITS, _objectSpread2$1(_objectSpread2$1({}, isKnownId && persistedUser.traits ? persistedUser.traits : {}), initialUser.traits));
-          }
-          var paramsArray = Object.keys(action.params);
-          if (paramsArray.length) {
-            var an_uid = params.an_uid, an_event = params.an_event;
-            var groupedParams = paramsArray.reduce(function(acc, key) {
-              if (key.match(utmRegex) || key.match(/^(d|g)clid/)) {
-                var cleanName = key.replace(utmRegex, "");
-                var keyName = cleanName === "campaign" ? "name" : cleanName;
-                acc.campaign[keyName] = params[key];
-              }
-              if (key.match(propRegex)) {
-                acc.props[key.replace(propRegex, "")] = params[key];
-              }
-              if (key.match(traitRegex)) {
-                acc.traits[key.replace(traitRegex, "")] = params[key];
-              }
-              return acc;
-            }, {
-              campaign: {},
-              props: {},
-              traits: {}
-            });
-            store.dispatch(_objectSpread2$1(_objectSpread2$1({
-              type: EVENTS$1.params,
-              raw: params
-            }, groupedParams), an_uid ? {
-              userId: an_uid
-            } : {}));
-            if (an_uid) {
-              setTimeout(function() {
-                return instance.identify(an_uid, groupedParams.traits);
-              }, 0);
-            }
-            if (an_event) {
-              setTimeout(function() {
-                return instance.track(an_event, groupedParams.props);
-              }, 0);
-            }
-            if (Object.keys(groupedParams.campaign).length) {
-              store.dispatch({
-                type: EVENTS$1.campaign,
-                campaign: groupedParams.campaign
-              });
-            }
-          }
-        }
-        return next(action);
-      };
-    };
-  };
-}
-function userReducer(storage2) {
-  return function user() {
-    var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var action = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    if (action.type === EVENTS$1.setItemEnd) {
-      if (action.key === ANON_ID) {
-        return _objectSpread2$1(_objectSpread2$1({}, state), {
-          anonymousId: action.value
-        });
-      }
-      if (action.key === USER_ID) {
-        return _objectSpread2$1(_objectSpread2$1({}, state), {
-          userId: action.value
-        });
-      }
-    }
-    switch (action.type) {
-      case EVENTS$1.identify:
-        return Object.assign({}, state, {
-          userId: action.userId,
-          traits: _objectSpread2$1(_objectSpread2$1({}, state.traits), action.traits)
-        });
-      case EVENTS$1.reset:
-        [USER_ID, ANON_ID, USER_TRAITS].forEach(function(key) {
-          storage2.removeItem(key);
-        });
-        return Object.assign({}, state, {
-          userId: null,
-          anonymousId: null,
-          traits: {}
-        });
-      default:
-        return state;
-    }
-  };
-}
-function getPersistedUserData(storage2) {
-  return {
-    userId: storage2.getItem(USER_ID),
-    anonymousId: storage2.getItem(ANON_ID),
-    traits: storage2.getItem(USER_TRAITS)
-  };
-}
-var tempKey = function tempKey2(key) {
-  return p + "TEMP" + p + key;
-};
-function getUserPropFunc(storage2) {
-  return function getUserProp(key, instance, payload) {
-    var currentId = instance.getState("user")[key];
-    if (currentId) {
-      return currentId;
-    }
-    if (payload && M$3(payload) && payload[key]) {
-      return payload[key];
-    }
-    var persistedInfo = getPersistedUserData(storage2)[key];
-    if (persistedInfo) {
-      return persistedInfo;
-    }
-    return a$4(tempKey(key)) || null;
-  };
-}
-function identifyMiddleware(instance) {
-  var _instance$storage = instance.storage, setItem = _instance$storage.setItem, removeItem = _instance$storage.removeItem, getItem = _instance$storage.getItem;
-  return function(store) {
-    return function(next) {
-      return function(action) {
-        var userId = action.userId, traits = action.traits, options = action.options;
-        if (action.type === EVENTS$1.reset) {
-          [USER_ID, USER_TRAITS, ANON_ID].forEach(function(key) {
-            removeItem(key);
-          });
-          [ID, ANONID, "traits"].forEach(function(key) {
-            i$4(tempKey(key));
-          });
-        }
-        if (action.type === EVENTS$1.identify) {
-          if (!getItem(ANON_ID)) {
-            setItem(ANON_ID, y$1());
-          }
-          var currentId = getItem(USER_ID);
-          var currentTraits = getItem(USER_TRAITS) || {};
-          if (currentId && currentId !== userId) {
-            store.dispatch({
-              type: EVENTS$1.userIdChanged,
-              old: {
-                userId: currentId,
-                traits: currentTraits
-              },
-              "new": {
-                userId,
-                traits
-              },
-              options
-            });
-          }
-          if (userId) {
-            setItem(USER_ID, userId);
-          }
-          if (traits) {
-            setItem(USER_TRAITS, _objectSpread2$1(_objectSpread2$1({}, currentTraits), traits));
-          }
-        }
-        return next(action);
-      };
-    };
-  };
-}
-var stack = {};
-function runCallback(id, payload) {
-  if (stack[id] && _(stack[id])) {
-    stack[id](payload);
-    delete stack[id];
-  }
-}
-function waitForReady(data, predicate, timeout) {
-  return new Promise(function(resolve, reject) {
-    if (predicate()) {
-      return resolve(data);
-    }
-    if (timeout < 1) {
-      return reject(_objectSpread2$1(_objectSpread2$1({}, data), {}, {
-        queue: true
-      }));
-    }
-    return pause(10).then(function(_2) {
-      return waitForReady(data, predicate, timeout - 10).then(resolve, reject);
-    });
-  });
-}
-function pause(ms) {
-  return new Promise(function(resolve) {
-    return setTimeout(resolve, ms);
-  });
-}
-function processQueue(store, getPlugins, instance) {
-  var pluginMethods = getPlugins();
-  var _store$getState = store.getState(), plugins = _store$getState.plugins, context2 = _store$getState.context, queue = _store$getState.queue, user = _store$getState.user;
-  var isOnline = !context2.offline;
-  if (isOnline && queue && queue.actions && queue.actions.length) {
-    var pipeline = queue.actions.reduce(function(acc, item, index2) {
-      var isLoaded = plugins[item.plugin].loaded;
-      if (isLoaded) {
-        acc.process.push(item);
-        acc.processIndex.push(index2);
-      } else {
-        acc.requeue.push(item);
-        acc.requeueIndex.push(index2);
-      }
-      return acc;
-    }, {
-      processIndex: [],
-      process: [],
-      requeue: [],
-      requeueIndex: []
-    });
-    if (pipeline.processIndex && pipeline.processIndex.length) {
-      pipeline.processIndex.forEach(function(i2) {
-        var processAction = queue.actions[i2];
-        var currentPlugin = processAction.plugin;
-        var currentMethod = processAction.payload.type;
-        var method = pluginMethods[currentPlugin][currentMethod];
-        if (method && _(method)) {
-          var enrichedPayload = enrich(processAction.payload, user);
-          method({
-            payload: enrichedPayload,
-            config: plugins[currentPlugin].config,
-            instance
-          });
-          var pluginEvent = "".concat(currentMethod, ":").concat(currentPlugin);
-          store.dispatch(_objectSpread2$1(_objectSpread2$1({}, enrichedPayload), {}, {
-            type: pluginEvent,
-            _: {
-              called: pluginEvent,
-              from: "queueDrain"
-            }
-          }));
-        }
-      });
-      var reQueueActions = queue.actions.filter(function(value, index2) {
-        return !~pipeline.processIndex.indexOf(index2);
-      });
-      queue.actions = reQueueActions;
-    }
-  }
-}
-function heartBeat(store, getPlugins, instance) {
-  return setInterval(function() {
-    return processQueue(store, getPlugins, instance);
-  }, 3e3);
-}
-function enrich() {
-  var payload = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  var user = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  return [ID, ANONID].reduce(function(acc, key) {
-    if (payload.hasOwnProperty(key) && user[key] && user[key] !== payload[key]) {
-      acc[key] = user[key];
-    }
-    return acc;
-  }, payload);
-}
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr))
-    return arr;
-}
-function _iterableToArrayLimit(arr, i2) {
-  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-  if (_i == null)
-    return;
-  var _arr = [];
-  var _n2 = true;
-  var _d = false;
-  var _s, _e;
-  try {
-    for (_i = _i.call(arr); !(_n2 = (_s = _i.next()).done); _n2 = true) {
-      _arr.push(_s.value);
-      if (i2 && _arr.length === i2)
-        break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n2 && _i["return"] != null)
-        _i["return"]();
-    } finally {
-      if (_d)
-        throw _e;
-    }
-  }
-  return _arr;
-}
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _slicedToArray(arr, i2) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
-}
-function fitlerDisabledPlugins(allPlugins) {
-  var settings = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-  return Object.keys(allPlugins).filter(function(name) {
-    var fromCallOptions = options.plugins || {};
-    if (x$1(fromCallOptions[name])) {
-      return fromCallOptions[name];
-    }
-    if (fromCallOptions.all === false) {
-      return false;
-    }
-    if (settings[name] && settings[name].enabled === false) {
-      return false;
-    }
-    return true;
-  }).map(function(name) {
-    return allPlugins[name];
-  });
-}
-var endsWithStartRegex = /Start$/;
-var bootstrapRegex = /^bootstrap/;
-var readyRegex = /^ready/;
-function runPlugins(_x, _x2, _x3, _x4, _x5) {
-  return _ref.apply(this, arguments);
-}
-function _ref() {
-  _ref = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee(action, getPlugins, instance, store, eventsInfo) {
-    var pluginObject, originalType, updatedType, state, activePlugins, allActivePluginKeys, allMatches, actionBefore, actionDuring, afterName, actionAfter;
-    return regenerator.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            pluginObject = _(getPlugins) ? getPlugins() : getPlugins;
-            originalType = action.type;
-            updatedType = originalType.replace(endsWithStartRegex, "");
-            if (!(action._ && action._.called)) {
-              _context.next = 5;
-              break;
-            }
-            return _context.abrupt("return", action);
-          case 5:
-            state = instance.getState();
-            activePlugins = fitlerDisabledPlugins(pluginObject, state.plugins, action.options);
-            if (originalType === EVENTS$1.initializeStart && action.fromEnable) {
-              activePlugins = Object.keys(state.plugins).filter(function(name) {
-                var info = state.plugins[name];
-                return action.plugins.includes(name) && !info.initialized;
-              }).map(function(name) {
-                return pluginObject[name];
-              });
-            }
-            allActivePluginKeys = activePlugins.map(function(p2) {
-              return p2.name;
-            });
-            allMatches = getAllMatchingCalls(originalType, activePlugins);
-            _context.next = 12;
-            return processEvent({
-              action,
-              data: {
-                exact: allMatches.before,
-                namespaced: allMatches.beforeNS
-              },
-              state,
-              allPlugins: pluginObject,
-              allMatches,
-              instance,
-              store,
-              EVENTS: eventsInfo
-            });
-          case 12:
-            actionBefore = _context.sent;
-            if (!shouldAbortAll(actionBefore, allActivePluginKeys.length)) {
-              _context.next = 15;
-              break;
-            }
-            return _context.abrupt("return", actionBefore);
-          case 15:
-            if (!(originalType === updatedType)) {
-              _context.next = 19;
-              break;
-            }
-            actionDuring = actionBefore;
-            _context.next = 22;
-            break;
-          case 19:
-            _context.next = 21;
-            return processEvent({
-              action: _objectSpread2$1(_objectSpread2$1({}, actionBefore), {}, {
-                type: updatedType
-              }),
-              data: {
-                exact: allMatches.during,
-                namespaced: allMatches.duringNS
-              },
-              state,
-              allPlugins: pluginObject,
-              allMatches,
-              instance,
-              store,
-              EVENTS: eventsInfo
-            });
-          case 21:
-            actionDuring = _context.sent;
-          case 22:
-            if (!originalType.match(endsWithStartRegex)) {
-              _context.next = 28;
-              break;
-            }
-            afterName = "".concat(updatedType, "End");
-            _context.next = 26;
-            return processEvent({
-              action: _objectSpread2$1(_objectSpread2$1({}, actionDuring), {}, {
-                type: afterName
-              }),
-              data: {
-                exact: allMatches.after,
-                namespaced: allMatches.afterNS
-              },
-              state,
-              allPlugins: pluginObject,
-              allMatches,
-              instance,
-              store,
-              EVENTS: eventsInfo
-            });
-          case 26:
-            actionAfter = _context.sent;
-            if (actionAfter.meta && actionAfter.meta.hasCallback) {
-              runCallback(actionAfter.meta.rid, {
-                payload: actionAfter
-              });
-            }
-          case 28:
-            return _context.abrupt("return", actionBefore);
-          case 29:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _ref.apply(this, arguments);
-}
-function processEvent(_x6) {
-  return _processEvent.apply(this, arguments);
-}
-function _processEvent() {
-  _processEvent = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee5(_ref2) {
-    var data, action, instance, state, allPlugins, allMatches, store, EVENTS2, plugins, context2, method, isStartEvent, abortable, makeArgs, queueData, payloads, resolvedAction, endAction;
-    return regenerator.wrap(function _callee5$(_context5) {
-      while (1) {
-        switch (_context5.prev = _context5.next) {
-          case 0:
-            data = _ref2.data, action = _ref2.action, instance = _ref2.instance, state = _ref2.state, allPlugins = _ref2.allPlugins, allMatches = _ref2.allMatches, store = _ref2.store, EVENTS2 = _ref2.EVENTS;
-            plugins = state.plugins, context2 = state.context;
-            method = action.type;
-            isStartEvent = method.match(endsWithStartRegex);
-            abortable = data.exact.map(function(x2) {
-              return x2.pluginName;
-            });
-            if (isStartEvent) {
-              abortable = allMatches.during.map(function(x2) {
-                return x2.pluginName;
-              });
-            }
-            makeArgs = argumentFactory(instance, abortable);
-            queueData = data.exact.reduce(function(acc, thing) {
-              var pluginName = thing.pluginName, methodName = thing.methodName;
-              var addToQueue = false;
-              if (!methodName.match(/^initialize/) && !methodName.match(/^reset/)) {
-                addToQueue = !plugins[pluginName].loaded;
-              }
-              if (context2.offline && methodName.match(/^(page|track|identify)/)) {
-                addToQueue = true;
-              }
-              acc["".concat(pluginName)] = addToQueue;
-              return acc;
-            }, {});
-            _context5.next = 10;
-            return data.exact.reduce(/* @__PURE__ */ function() {
-              var _ref6 = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee3(scoped, curr, i2) {
-                var pluginName, curScope, scopedPayload;
-                return regenerator.wrap(function _callee3$(_context3) {
-                  while (1) {
-                    switch (_context3.prev = _context3.next) {
-                      case 0:
-                        pluginName = curr.pluginName;
-                        _context3.next = 3;
-                        return scoped;
-                      case 3:
-                        curScope = _context3.sent;
-                        if (!(data.namespaced && data.namespaced[pluginName])) {
-                          _context3.next = 11;
-                          break;
-                        }
-                        _context3.next = 7;
-                        return data.namespaced[pluginName].reduce(/* @__PURE__ */ function() {
-                          var _ref7 = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee2(acc, p2, count) {
-                            var curScopeData, genAbort, val, returnValue;
-                            return regenerator.wrap(function _callee2$(_context2) {
-                              while (1) {
-                                switch (_context2.prev = _context2.next) {
-                                  case 0:
-                                    genAbort = function _genAbort(currentAct, pname, otherPlug) {
-                                      return function(reason, plugins2) {
-                                        var callsite = otherPlug || pname;
-                                        return _objectSpread2$1(_objectSpread2$1({}, currentAct), {}, {
-                                          abort: {
-                                            reason,
-                                            plugins: plugins2 || [pname],
-                                            caller: method,
-                                            from: callsite
-                                          }
-                                        });
-                                      };
-                                    };
-                                    _context2.next = 3;
-                                    return acc;
-                                  case 3:
-                                    curScopeData = _context2.sent;
-                                    if (!(!p2.method || !_(p2.method))) {
-                                      _context2.next = 6;
-                                      break;
-                                    }
-                                    return _context2.abrupt("return", curScopeData);
-                                  case 6:
-                                    validateMethod(p2.methodName, p2.pluginName);
-                                    _context2.next = 9;
-                                    return p2.method({
-                                      payload: curScopeData,
-                                      instance,
-                                      abort: genAbort(curScopeData, pluginName, p2.pluginName),
-                                      config: getConfig(p2.pluginName, plugins, allPlugins),
-                                      plugins
-                                    });
-                                  case 9:
-                                    val = _context2.sent;
-                                    returnValue = M$3(val) ? val : {};
-                                    return _context2.abrupt("return", Promise.resolve(_objectSpread2$1(_objectSpread2$1({}, curScopeData), returnValue)));
-                                  case 12:
-                                  case "end":
-                                    return _context2.stop();
-                                }
-                              }
-                            }, _callee2);
-                          }));
-                          return function(_x10, _x11, _x12) {
-                            return _ref7.apply(this, arguments);
-                          };
-                        }(), Promise.resolve(action));
-                      case 7:
-                        scopedPayload = _context3.sent;
-                        curScope[pluginName] = scopedPayload;
-                        _context3.next = 12;
-                        break;
-                      case 11:
-                        curScope[pluginName] = action;
-                      case 12:
-                        return _context3.abrupt("return", Promise.resolve(curScope));
-                      case 13:
-                      case "end":
-                        return _context3.stop();
-                    }
-                  }
-                }, _callee3);
-              }));
-              return function(_x7, _x8, _x9) {
-                return _ref6.apply(this, arguments);
-              };
-            }(), Promise.resolve({}));
-          case 10:
-            payloads = _context5.sent;
-            _context5.next = 13;
-            return data.exact.reduce(/* @__PURE__ */ function() {
-              var _ref8 = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee4(promise, curr, i2) {
-                var lastLoop, pluginName, currentPlugin, currentActionValue, payloadValue, funcArgs, val, returnValue, merged, scopedPayload, nameSpaceEvent, actionDepth, updatedPayload;
-                return regenerator.wrap(function _callee4$(_context4) {
-                  while (1) {
-                    switch (_context4.prev = _context4.next) {
-                      case 0:
-                        lastLoop = data.exact.length === i2 + 1;
-                        pluginName = curr.pluginName;
-                        currentPlugin = allPlugins[pluginName];
-                        _context4.next = 5;
-                        return promise;
-                      case 5:
-                        currentActionValue = _context4.sent;
-                        payloadValue = payloads[pluginName] ? payloads[pluginName] : {};
-                        if (isStartEvent) {
-                          payloadValue = currentActionValue;
-                        }
-                        if (!shouldAbort(payloadValue, pluginName)) {
-                          _context4.next = 11;
-                          break;
-                        }
-                        abortDispatch({
-                          data: payloadValue,
-                          method,
-                          instance,
-                          pluginName,
-                          store
-                        });
-                        return _context4.abrupt("return", Promise.resolve(currentActionValue));
-                      case 11:
-                        if (!shouldAbort(currentActionValue, pluginName)) {
-                          _context4.next = 14;
-                          break;
-                        }
-                        if (lastLoop) {
-                          abortDispatch({
-                            data: currentActionValue,
-                            method,
-                            instance,
-                            store
-                          });
-                        }
-                        return _context4.abrupt("return", Promise.resolve(currentActionValue));
-                      case 14:
-                        if (!(queueData.hasOwnProperty(pluginName) && queueData[pluginName] === true)) {
-                          _context4.next = 17;
-                          break;
-                        }
-                        store.dispatch({
-                          type: "queue",
-                          plugin: pluginName,
-                          payload: payloadValue,
-                          _: {
-                            called: "queue",
-                            from: "queueMechanism"
-                          }
-                        });
-                        return _context4.abrupt("return", Promise.resolve(currentActionValue));
-                      case 17:
-                        funcArgs = makeArgs(payloads[pluginName], allPlugins[pluginName]);
-                        _context4.next = 20;
-                        return currentPlugin[method]({
-                          abort: funcArgs.abort,
-                          payload: payloadValue,
-                          instance,
-                          config: getConfig(pluginName, plugins, allPlugins),
-                          plugins
-                        });
-                      case 20:
-                        val = _context4.sent;
-                        returnValue = M$3(val) ? val : {};
-                        merged = _objectSpread2$1(_objectSpread2$1({}, currentActionValue), returnValue);
-                        scopedPayload = payloads[pluginName];
-                        if (shouldAbort(scopedPayload, pluginName)) {
-                          abortDispatch({
-                            data: scopedPayload,
-                            method,
-                            instance,
-                            pluginName,
-                            store
-                          });
-                        } else {
-                          nameSpaceEvent = "".concat(method, ":").concat(pluginName);
-                          actionDepth = (nameSpaceEvent.match(/:/g) || []).length;
-                          if (actionDepth < 2 && !method.match(bootstrapRegex) && !method.match(readyRegex)) {
-                            updatedPayload = isStartEvent ? merged : payloadValue;
-                            instance.dispatch(_objectSpread2$1(_objectSpread2$1({}, updatedPayload), {}, {
-                              type: nameSpaceEvent,
-                              _: {
-                                called: nameSpaceEvent,
-                                from: "submethod"
-                              }
-                            }));
-                          }
-                        }
-                        return _context4.abrupt("return", Promise.resolve(merged));
-                      case 26:
-                      case "end":
-                        return _context4.stop();
-                    }
-                  }
-                }, _callee4);
-              }));
-              return function(_x13, _x14, _x15) {
-                return _ref8.apply(this, arguments);
-              };
-            }(), Promise.resolve(action));
-          case 13:
-            resolvedAction = _context5.sent;
-            if (!(!method.match(endsWithStartRegex) && !method.match(/^registerPlugin/) && !method.match(readyRegex) && !method.match(bootstrapRegex) && !method.match(/^params/) && !method.match(/^userIdChanged/))) {
-              _context5.next = 21;
-              break;
-            }
-            if (EVENTS2.plugins.includes(method))
-              ;
-            if (!(resolvedAction._ && resolvedAction._.originalAction === method)) {
-              _context5.next = 18;
-              break;
-            }
-            return _context5.abrupt("return", resolvedAction);
-          case 18:
-            endAction = _objectSpread2$1(_objectSpread2$1({}, resolvedAction), {
-              _: {
-                originalAction: resolvedAction.type,
-                called: resolvedAction.type,
-                from: "engineEnd"
-              }
-            });
-            if (shouldAbortAll(resolvedAction, data.exact.length) && !method.match(/End$/)) {
-              endAction = _objectSpread2$1(_objectSpread2$1({}, endAction), {
-                type: resolvedAction.type + "Aborted"
-              });
-            }
-            store.dispatch(endAction);
-          case 21:
-            return _context5.abrupt("return", resolvedAction);
-          case 22:
-          case "end":
-            return _context5.stop();
-        }
-      }
-    }, _callee5);
-  }));
-  return _processEvent.apply(this, arguments);
-}
-function abortDispatch(_ref3) {
-  var data = _ref3.data, method = _ref3.method;
-  _ref3.instance;
-  var pluginName = _ref3.pluginName, store = _ref3.store;
-  var postFix = pluginName ? ":" + pluginName : "";
-  var abortEvent = method + "Aborted" + postFix;
-  store.dispatch(_objectSpread2$1(_objectSpread2$1({}, data), {}, {
-    type: abortEvent,
-    _: {
-      called: abortEvent,
-      from: "abort"
-    }
-  }));
-}
-function getConfig(name, pluginState, allPlugins) {
-  var pluginData = pluginState[name] || allPlugins[name];
-  if (pluginData && pluginData.config) {
-    return pluginData.config;
-  }
-  return {};
-}
-function getPluginFunctions(methodName, plugins) {
-  return plugins.reduce(function(arr, plugin) {
-    return !plugin[methodName] ? arr : arr.concat({
-      methodName,
-      pluginName: plugin.name,
-      method: plugin[methodName]
-    });
-  }, []);
-}
-function formatMethod(type) {
-  return type.replace(endsWithStartRegex, "");
-}
-function getEventNames(eventType, namespace) {
-  var method = formatMethod(eventType);
-  var postFix = namespace ? ":".concat(namespace) : "";
-  var type = "".concat(eventType).concat(postFix);
-  var methodName = "".concat(method).concat(postFix);
-  var end = "".concat(method, "End").concat(postFix);
-  return [type, methodName, end];
-}
-function getAllMatchingCalls(eventType, activePlugins, allPlugins) {
-  var eventNames = getEventNames(eventType);
-  var core = eventNames.map(function(word) {
-    return getPluginFunctions(word, activePlugins);
-  });
-  return activePlugins.reduce(function(acc, plugin) {
-    var name = plugin.name;
-    var nameSpacedEvents = getEventNames(eventType, name);
-    var _nameSpacedEvents$map = nameSpacedEvents.map(function(word) {
-      return getPluginFunctions(word, activePlugins);
-    }), _nameSpacedEvents$map2 = _slicedToArray(_nameSpacedEvents$map, 3), beforeFuncs = _nameSpacedEvents$map2[0], duringFuncs = _nameSpacedEvents$map2[1], afterFuncs = _nameSpacedEvents$map2[2];
-    if (beforeFuncs.length) {
-      acc.beforeNS[name] = beforeFuncs;
-    }
-    if (duringFuncs.length) {
-      acc.duringNS[name] = duringFuncs;
-    }
-    if (afterFuncs.length) {
-      acc.afterNS[name] = afterFuncs;
-    }
-    return acc;
-  }, {
-    before: core[0],
-    beforeNS: {},
-    during: core[1],
-    duringNS: {},
-    after: core[2],
-    afterNS: {}
-  });
-}
-function shouldAbort(_ref4, pluginName) {
-  var abort = _ref4.abort;
-  if (!abort)
-    return false;
-  if (abort === true)
-    return true;
-  return includes(abort, pluginName) || abort && includes(abort.plugins, pluginName);
-}
-function shouldAbortAll(_ref5, pluginsCount) {
-  var abort = _ref5.abort;
-  if (!abort)
-    return false;
-  if (abort === true || L$1(abort))
-    return true;
-  var plugins = abort.plugins;
-  return isArray(abort) && abort.length === pluginsCount || isArray(plugins) && plugins.length === pluginsCount;
-}
-function isArray(arr) {
-  return Array.isArray(arr);
-}
-function includes(arr, name) {
-  if (!arr || !isArray(arr))
-    return false;
-  return arr.includes(name);
-}
-function argumentFactory(instance, abortablePlugins) {
-  return function(action, plugin, otherPlugin) {
-    var config2 = plugin.config, name = plugin.name;
-    var method = "".concat(name, ".").concat(action.type);
-    if (otherPlugin) {
-      method = otherPlugin.event;
-    }
-    var abortF = action.type.match(endsWithStartRegex) ? abortFunction(name, method, abortablePlugins, otherPlugin, action) : notAbortableError(action, method);
-    return {
-      payload: formatPayload(action),
-      instance,
-      config: config2 || {},
-      abort: abortF
-    };
-  };
-}
-function abortFunction(pluginName, method, abortablePlugins, otherPlugin, action) {
-  return function(reason, plugins) {
-    var caller = otherPlugin ? otherPlugin.name : pluginName;
-    var pluginsToAbort = plugins && isArray(plugins) ? plugins : abortablePlugins;
-    if (otherPlugin) {
-      pluginsToAbort = plugins && isArray(plugins) ? plugins : [pluginName];
-      if (!pluginsToAbort.includes(pluginName) || pluginsToAbort.length !== 1) {
-        throw new Error("Method ".concat(method, " can only abort ").concat(pluginName, " plugin. ").concat(JSON.stringify(pluginsToAbort), " input valid"));
-      }
-    }
-    return _objectSpread2$1(_objectSpread2$1({}, action), {}, {
-      abort: {
-        reason,
-        plugins: pluginsToAbort,
-        caller: method,
-        _: caller
-      }
-    });
-  };
-}
-function notAbortableError(action, method) {
-  return function() {
-    throw new Error(action.type + " action not cancellable. Remove abort in " + method);
-  };
-}
-function validateMethod(actionName, pluginName) {
-  var text = getNameSpacedAction(actionName);
-  var methodCallMatchesPluginNamespace = text && text.name === pluginName;
-  if (methodCallMatchesPluginNamespace) {
-    var sub = getNameSpacedAction(text.method);
-    var subText = sub ? "or " + sub.method : "";
-    throw new Error([pluginName + " plugin is calling method " + actionName, "Plugins cant call self", "Use ".concat(text.method, " ").concat(subText, " in ").concat(pluginName, " plugin insteadof ").concat(actionName)].join("\n"));
-  }
-}
-function getNameSpacedAction(event) {
-  var split = event.match(/(.*):(.*)/);
-  if (!split) {
-    return false;
-  }
-  return {
-    method: split[1],
-    name: split[2]
-  };
-}
-function formatPayload(action) {
-  return Object.keys(action).reduce(function(acc, key) {
-    if (key === "type") {
-      return acc;
-    }
-    if (M$3(action[key])) {
-      acc[key] = Object.assign({}, action[key]);
-    } else {
-      acc[key] = action[key];
-    }
-    return acc;
-  }, {});
-}
-function pluginMiddleware(instance, getPlugins, systemEvents) {
-  var isReady = {};
-  return function(store) {
-    return function(next) {
-      return /* @__PURE__ */ function() {
-        var _ref2 = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee(action) {
-          var type, abort, plugins, updatedAction, allPlugins, pluginsArray, allRegisteredPlugins, completed, failed, disabled, waitForPluginsToLoad, updated;
-          return regenerator.wrap(function _callee$(_context) {
-            while (1) {
-              switch (_context.prev = _context.next) {
-                case 0:
-                  type = action.type, abort = action.abort, plugins = action.plugins;
-                  updatedAction = action;
-                  if (!abort) {
-                    _context.next = 4;
-                    break;
-                  }
-                  return _context.abrupt("return", next(action));
-                case 4:
-                  if (type === EVENTS$1.enablePlugin) {
-                    store.dispatch({
-                      type: EVENTS$1.initializeStart,
-                      plugins,
-                      disabled: [],
-                      fromEnable: true,
-                      meta: action.meta
-                    });
-                  }
-                  if (type === EVENTS$1.disablePlugin) {
-                    setTimeout(function() {
-                      return runCallback(action.meta.rid, {
-                        payload: action
-                      });
-                    }, 0);
-                  }
-                  if (type === EVENTS$1.initializeEnd) {
-                    allPlugins = getPlugins();
-                    pluginsArray = Object.keys(allPlugins);
-                    allRegisteredPlugins = pluginsArray.filter(function(name) {
-                      return plugins.includes(name);
-                    }).map(function(name) {
-                      return allPlugins[name];
-                    });
-                    completed = [];
-                    failed = [];
-                    disabled = action.disabled;
-                    waitForPluginsToLoad = allRegisteredPlugins.map(function(plugin) {
-                      var loaded = plugin.loaded, name = plugin.name;
-                      return waitForReady(plugin, loaded, 1e4).then(function(d2) {
-                        if (!isReady[name]) {
-                          store.dispatch({
-                            type: EVENTS$1.pluginReadyType(name),
-                            name,
-                            events: Object.keys(plugin).filter(function(name2) {
-                              return !nonEvents.includes(name2);
-                            })
-                          });
-                          isReady[name] = true;
-                        }
-                        completed = completed.concat(name);
-                        return plugin;
-                      })["catch"](function(e2) {
-                        if (e2 instanceof Error) {
-                          throw new Error(e2);
-                        }
-                        failed = failed.concat(e2.name);
-                        return e2;
-                      });
-                    });
-                    Promise.all(waitForPluginsToLoad).then(function(calls) {
-                      var payload = {
-                        plugins: completed,
-                        failed,
-                        disabled
-                      };
-                      setTimeout(function() {
-                        if (pluginsArray.length === waitForPluginsToLoad.length + disabled.length) {
-                          store.dispatch(_objectSpread2$1(_objectSpread2$1({}, {
-                            type: EVENTS$1.ready
-                          }), payload));
-                        }
-                      }, 0);
-                    });
-                  }
-                  if (!(type !== EVENTS$1.bootstrap)) {
-                    _context.next = 13;
-                    break;
-                  }
-                  if (/^ready:([^:]*)$/.test(type)) {
-                    setTimeout(function() {
-                      return processQueue(store, getPlugins, instance);
-                    }, 0);
-                  }
-                  _context.next = 11;
-                  return runPlugins(action, getPlugins, instance, store, systemEvents);
-                case 11:
-                  updated = _context.sent;
-                  return _context.abrupt("return", next(updated));
-                case 13:
-                  return _context.abrupt("return", next(updatedAction));
-                case 14:
-                case "end":
-                  return _context.stop();
-              }
-            }
-          }, _callee);
-        }));
-        return function(_x) {
-          return _ref2.apply(this, arguments);
-        };
-      }();
-    };
-  };
-}
-function storageMiddleware(storage2) {
-  return function(store) {
-    return function(next) {
-      return function(action) {
-        var type = action.type, key = action.key, value = action.value, options = action.options;
-        if (type === EVENTS$1.setItem || type === EVENTS$1.removeItem) {
-          if (action.abort) {
-            return next(action);
-          }
-          if (type === EVENTS$1.setItem) {
-            storage2.setItem(key, value, options);
-          } else {
-            storage2.removeItem(key, options);
-          }
-        }
-        return next(action);
-      };
-    };
-  };
-}
-function _defineProperties(target, props) {
-  for (var i2 = 0; i2 < props.length; i2++) {
-    var descriptor = props[i2];
-    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 _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-var DynamicMiddleware = /* @__PURE__ */ _createClass(function DynamicMiddleware2() {
-  var _this = this;
-  _classCallCheck(this, DynamicMiddleware2);
-  _defineProperty$2(this, "before", []);
-  _defineProperty$2(this, "after", []);
-  _defineProperty$2(this, "addMiddleware", function(middlewares, position) {
-    _this[position] = _this[position].concat(middlewares);
-  });
-  _defineProperty$2(this, "removeMiddleware", function(middleware, position) {
-    var index2 = _this[position].findIndex(function(d2) {
-      return d2 === middleware;
-    });
-    if (index2 === -1)
-      return;
-    _this[position] = [].concat(_toConsumableArray(_this[position].slice(0, index2)), _toConsumableArray(_this[position].slice(index2 + 1)));
-  });
-  _defineProperty$2(this, "dynamicMiddlewares", function(position) {
-    return function(store) {
-      return function(next) {
-        return function(action) {
-          var middlewareAPI = {
-            getState: store.getState,
-            dispatch: function dispatch(act) {
-              return store.dispatch(act);
-            }
-          };
-          var chain = _this[position].map(function(middleware) {
-            return middleware(middlewareAPI);
-          });
-          return compose.apply(void 0, _toConsumableArray(chain))(next)(action);
-        };
-      };
-    };
-  });
-});
-function createReducer(getPlugins) {
-  return function plugins() {
-    var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var action = arguments.length > 1 ? arguments[1] : void 0;
-    var newState = {};
-    if (action.type === "initialize:aborted") {
-      return state;
-    }
-    if (/^registerPlugin:([^:]*)$/.test(action.type)) {
-      var name = getNameFromEventType(action.type, "registerPlugin");
-      var plugin = getPlugins()[name];
-      if (!plugin || !name) {
-        return state;
-      }
-      var isEnabled = action.enabled;
-      newState[name] = {
-        enabled: isEnabled,
-        initialized: isEnabled ? Boolean(!plugin.initialize) : false,
-        loaded: isEnabled ? Boolean(plugin.loaded()) : false,
-        config: plugin.config || {}
-      };
-      return _objectSpread2$1(_objectSpread2$1({}, state), newState);
-    }
-    if (/^initialize:([^:]*)$/.test(action.type)) {
-      var _name = getNameFromEventType(action.type, EVENTS$1.initialize);
-      var _plugin = getPlugins()[_name];
-      if (!_plugin || !_name) {
-        return state;
-      }
-      newState[_name] = _objectSpread2$1(_objectSpread2$1({}, state[_name]), {
-        initialized: true,
-        loaded: Boolean(_plugin.loaded())
-      });
-      return _objectSpread2$1(_objectSpread2$1({}, state), newState);
-    }
-    if (/^ready:([^:]*)$/.test(action.type)) {
-      newState[action.name] = _objectSpread2$1(_objectSpread2$1({}, state[action.name]), {
-        loaded: true
-      });
-      return _objectSpread2$1(_objectSpread2$1({}, state), newState);
-    }
-    switch (action.type) {
-      case EVENTS$1.disablePlugin:
-        return _objectSpread2$1(_objectSpread2$1({}, state), togglePluginStatus(action.plugins, false, state));
-      case EVENTS$1.enablePlugin:
-        return _objectSpread2$1(_objectSpread2$1({}, state), togglePluginStatus(action.plugins, true, state));
-      default:
-        return state;
-    }
-  };
-}
-function getNameFromEventType(type, baseName) {
-  return type.substring(baseName.length + 1, type.length);
-}
-function togglePluginStatus(plugins, status, currentState) {
-  return plugins.reduce(function(acc, pluginKey) {
-    acc[pluginKey] = _objectSpread2$1(_objectSpread2$1({}, currentState[pluginKey]), {
-      enabled: status
-    });
-    return acc;
-  }, currentState);
-}
-function serialize(obj) {
-  try {
-    return JSON.parse(JSON.stringify(obj));
-  } catch (err) {
-  }
-  return obj;
-}
-var initialState$3 = {
-  last: {},
-  history: []
-};
-function trackReducer() {
-  var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : initialState$3;
-  var action = arguments.length > 1 ? arguments[1] : void 0;
-  var type = action.type, event = action.event, properties = action.properties, options = action.options, meta = action.meta;
-  switch (type) {
-    case EVENTS$1.track:
-      var trackEvent = serialize(_objectSpread2$1(_objectSpread2$1({
-        event,
-        properties
-      }, Object.keys(options).length && {
-        options
-      }), {}, {
-        meta
-      }));
-      return _objectSpread2$1(_objectSpread2$1({}, state), {
-        last: trackEvent,
-        history: state.history.concat(trackEvent)
-      });
-    default:
-      return state;
-  }
-}
-var initialState$2 = {
-  actions: []
-};
-function queueReducer() {
-  var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : initialState$2;
-  var action = arguments.length > 1 ? arguments[1] : void 0;
-  var type = action.type, payload = action.payload;
-  switch (type) {
-    case "queue":
-      var actionChain;
-      if (payload && payload.type && payload.type === EVENTS$1.identify) {
-        actionChain = [action].concat(state.actions);
-      } else {
-        actionChain = state.actions.concat(action);
-      }
-      return _objectSpread2$1(_objectSpread2$1({}, state), {}, {
-        actions: actionChain
-      });
-    case "dequeue":
-      return [];
-    default:
-      return state;
-  }
-}
-var hashRegex = /#.*$/;
-function canonicalUrl() {
-  if (!z)
-    return;
-  var tags = document.getElementsByTagName("link");
-  for (var i2 = 0, tag; tag = tags[i2]; i2++) {
-    if (tag.getAttribute("rel") === "canonical") {
-      return tag.getAttribute("href");
-    }
-  }
-}
-function urlPath(url) {
-  var regex = /(http[s]?:\/\/)?([^\/\s]+\/)(.*)/g;
-  var matches = regex.exec(url);
-  var pathMatch = matches && matches[3] ? matches[3].split("?")[0].replace(hashRegex, "") : "";
-  return "/" + pathMatch;
-}
-function currentUrl(search) {
-  var canonical = canonicalUrl();
-  if (!canonical)
-    return window.location.href.replace(hashRegex, "");
-  return canonical.match(/\?/) ? canonical : canonical + search;
-}
-var getPageData = function getPageData2() {
-  var pageData = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  if (!z)
-    return pageData;
-  var _document = document, title = _document.title, referrer2 = _document.referrer;
-  var _window = window, location = _window.location, innerWidth = _window.innerWidth, innerHeight = _window.innerHeight;
-  var hash = location.hash, search = location.search;
-  var url = currentUrl(search);
-  var page2 = {
-    title,
-    url,
-    path: urlPath(url),
-    hash,
-    search,
-    width: innerWidth,
-    height: innerHeight
-  };
-  if (referrer2 && referrer2 !== "") {
-    page2.referrer = referrer2;
-  }
-  return _objectSpread2$1(_objectSpread2$1({}, page2), pageData);
-};
-var initialState$1 = {
-  last: {},
-  history: []
-};
-function page() {
-  var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : initialState$1;
-  var action = arguments.length > 1 ? arguments[1] : void 0;
-  var properties = action.properties, options = action.options, meta = action.meta;
-  switch (action.type) {
-    case EVENTS$1.page:
-      var viewData = serialize(_objectSpread2$1({
-        properties,
-        meta
-      }, Object.keys(options).length && {
-        options
-      }));
-      return _objectSpread2$1(_objectSpread2$1({}, state), {
-        last: viewData,
-        history: state.history.concat(viewData)
-      });
-    default:
-      return state;
-  }
-}
-function getBrowserOS() {
-  if (!z)
-    return false;
-  var os = navigator.appVersion;
-  if (~os.indexOf("Win"))
-    return "Windows";
-  if (~os.indexOf("Mac"))
-    return "MacOS";
-  if (~os.indexOf("X11"))
-    return "UNIX";
-  if (~os.indexOf("Linux"))
-    return "Linux";
-  return "Unknown OS";
-}
-var osName;
-var referrer;
-var locale;
-var timeZone;
-{
-  osName = getBrowserOS();
-  referrer = z ? document.referrer : null;
-  locale = o$8();
-  timeZone = a$5();
-}
-var initialState = {
-  initialized: false,
-  sessionId: y$1(),
-  app: null,
-  version: null,
-  debug: false,
-  offline: z ? !navigator.onLine : false,
-  os: {
-    name: osName
-  },
-  userAgent: z ? navigator.userAgent : "node",
-  library: {
-    name: LIB_NAME,
-    version: "0.10.22"
-  },
-  timezone: timeZone,
-  locale,
-  campaign: {},
-  referrer
-};
-function context() {
-  var state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : initialState;
-  var action = arguments.length > 1 ? arguments[1] : void 0;
-  var initialized = state.initialized;
-  var type = action.type, campaign = action.campaign;
-  switch (type) {
-    case EVENTS$1.campaign:
-      return _objectSpread2$1(_objectSpread2$1({}, state), {
-        campaign
-      });
-    case EVENTS$1.offline:
-      return _objectSpread2$1(_objectSpread2$1({}, state), {
-        offline: true
-      });
-    case EVENTS$1.online:
-      return _objectSpread2$1(_objectSpread2$1({}, state), {
-        offline: false
-      });
-    default:
-      if (!initialized) {
-        return _objectSpread2$1(_objectSpread2$1(_objectSpread2$1({}, initialState), state), {
-          initialized: true
-        });
-      }
-      return state;
-  }
-}
-var excludeItems = ["plugins", "reducers", "storage"];
-function makeContext(config2) {
-  return Object.keys(config2).reduce(function(acc, current) {
-    if (excludeItems.includes(current)) {
-      return acc;
-    }
-    acc[current] = config2[current];
-    return acc;
-  }, {});
-}
-function listen(events, func, toAdd) {
-  if (!z)
-    return;
-  var fn = window[(toAdd ? "add" : "remove") + "EventListener"];
-  events.split(" ").forEach(function(ev) {
-    fn(ev, func);
-  });
-}
-function check() {
-  return Promise.resolve(!navigator.onLine);
-}
-function watch(cb) {
-  var fn = function fn2(_2) {
-    return check().then(cb);
-  };
-  var listener = listen.bind(null, "online offline", fn);
-  listener(true);
-  return function(_2) {
-    return listener(false);
-  };
-}
-function Debug() {
-  f$4(LIB_NAME, []);
-  return function(createStore2) {
-    return function(reducer, preloadedState, enhancer) {
-      var store = createStore2(reducer, preloadedState, enhancer);
-      var origDispatch = store.dispatch;
-      var dispatch = function dispatch2(action) {
-        var a2 = action.action || action;
-        n$4[o$6][LIB_NAME].push(a2);
-        return origDispatch(action);
-      };
-      return Object.assign(store, {
-        dispatch
-      });
-    };
-  };
-}
-function composeWithDebug(config2) {
-  return function() {
-    return compose(compose.apply(null, arguments), Debug());
-  };
-}
-function ensureArray(singleOrArray) {
-  if (!singleOrArray)
-    return [];
-  if (G(singleOrArray))
-    return singleOrArray;
-  return [singleOrArray];
-}
-function getCallbackFromArgs(argArray) {
-  var args = argArray || Array.prototype.slice.call(arguments);
-  var cb;
-  for (var i2 = 0; i2 < args.length; i2++) {
-    if (_(args[i2])) {
-      cb = args[i2];
-      break;
-    }
-  }
-  return cb;
-}
-function timeStamp() {
-  return new Date().getTime();
-}
-function deferredPromiseResolver(resolver, callback) {
-  return function(data) {
-    if (callback)
-      callback(data);
-    resolver(data);
-  };
-}
-function generateMeta() {
-  var meta = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  var resolve = arguments.length > 1 ? arguments[1] : void 0;
-  var possibleCallbacks = arguments.length > 2 ? arguments[2] : void 0;
-  var rid = y$1();
-  if (resolve) {
-    stack[rid] = deferredPromiseResolver(resolve, getCallbackFromArgs(possibleCallbacks));
-  }
-  return _objectSpread2$1(_objectSpread2$1({}, meta), {}, {
-    rid,
-    ts: timeStamp()
-  }, !resolve ? {} : {
-    hasCallback: true
-  });
-}
-function analytics() {
-  var config2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  var customReducers = config2.reducers || {};
-  var initialUser = config2.initialUser || {};
-  var parsedOptions = (config2.plugins || []).reduce(function(acc, plugin) {
-    if (_(plugin)) {
-      acc.middlewares = acc.middlewares.concat(plugin);
-      return acc;
-    }
-    if (plugin.NAMESPACE)
-      plugin.name = plugin.NAMESPACE;
-    if (!plugin.name) {
-      throw new Error(ERROR_URL + "1");
-    }
-    var definedEvents = plugin.EVENTS ? Object.keys(plugin.EVENTS).map(function(k2) {
-      return plugin.EVENTS[k2];
-    }) : [];
-    var enabledFromMerge = !(plugin.enabled === false);
-    var enabledFromPluginConfig = !(plugin.config && plugin.config.enabled === false);
-    acc.pluginEnabled[plugin.name] = enabledFromMerge && enabledFromPluginConfig;
-    delete plugin.enabled;
-    if (plugin.methods) {
-      acc.methods[plugin.name] = Object.keys(plugin.methods).reduce(function(a2, c2) {
-        a2[c2] = appendArguments(plugin.methods[c2]);
-        return a2;
-      }, {});
-      delete plugin.methods;
-    }
-    var methodsToEvents = Object.keys(plugin);
-    var allEvents = methodsToEvents.concat(definedEvents);
-    var allEventsUnique = new Set(acc.events.concat(allEvents));
-    acc.events = Array.from(allEventsUnique);
-    acc.pluginsArray = acc.pluginsArray.concat(plugin);
-    if (acc.plugins[plugin.name]) {
-      throw new Error(plugin.name + "AlreadyLoaded");
-    }
-    acc.plugins[plugin.name] = plugin;
-    if (!acc.plugins[plugin.name].loaded) {
-      acc.plugins[plugin.name].loaded = function() {
-        return true;
-      };
-    }
-    return acc;
-  }, {
-    plugins: {},
-    pluginEnabled: {},
-    methods: {},
-    pluginsArray: [],
-    middlewares: [],
-    events: []
-  });
-  var storage2 = config2.storage ? config2.storage : {
-    getItem: a$4,
-    setItem: f$4,
-    removeItem: i$4
-  };
-  var getUserProp = getUserPropFunc(storage2);
-  var customPlugins = parsedOptions.plugins;
-  var allPluginEvents = parsedOptions.events.filter(function(name) {
-    return !nonEvents.includes(name);
-  }).sort();
-  var uniqueEvents = new Set(allPluginEvents.concat(coreEvents).filter(function(name) {
-    return !nonEvents.includes(name);
-  }));
-  var allSystemEvents = Array.from(uniqueEvents).sort();
-  var getPlugins = function getPlugins2() {
-    return customPlugins;
-  };
-  var _DynamicMiddleware = new DynamicMiddleware(), addMiddleware = _DynamicMiddleware.addMiddleware, removeMiddleware = _DynamicMiddleware.removeMiddleware, dynamicMiddlewares = _DynamicMiddleware.dynamicMiddlewares;
-  var nonAbortable = function nonAbortable2() {
-    throw new Error("Abort disabled inListener");
-  };
-  var params = s();
-  var persistedUser = getPersistedUserData(storage2);
-  var visitorInfo = _objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1({}, persistedUser), initialUser), !params.an_uid ? {} : {
-    userId: params.an_uid
-  }), !params.an_aid ? {} : {
-    anonymousId: params.an_aid
-  });
-  if (!visitorInfo.anonymousId) {
-    visitorInfo.anonymousId = y$1();
-  }
-  var plugins = _objectSpread2$1({
-    enable: function enable(plugins2, callback) {
-      return new Promise(function(resolve) {
-        store.dispatch({
-          type: EVENTS$1.enablePlugin,
-          plugins: ensureArray(plugins2),
-          _: {
-            originalAction: EVENTS$1.enablePlugin
-          }
-        }, resolve, [callback]);
-      });
-    },
-    disable: function disable(plugins2, callback) {
-      return new Promise(function(resolve) {
-        store.dispatch({
-          type: EVENTS$1.disablePlugin,
-          plugins: ensureArray(plugins2),
-          _: {
-            originalAction: EVENTS$1.disablePlugin
-          }
-        }, resolve, [callback]);
-      });
-    }
-  }, parsedOptions.methods);
-  var instance = {
-    identify: function() {
-      var _identify = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee(userId, traits, options, callback) {
-        var id, data, opts, user, resolvedId;
-        return regenerator.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                id = L$1(userId) ? userId : null;
-                data = M$3(userId) ? userId : traits;
-                opts = options || {};
-                user = instance.user();
-                f$4(tempKey(ID), id);
-                resolvedId = id || data.userId || getUserProp(ID, instance, data);
-                return _context.abrupt("return", new Promise(function(resolve) {
-                  store.dispatch(_objectSpread2$1({
-                    type: EVENTS$1.identifyStart,
-                    userId: resolvedId,
-                    traits: data || {},
-                    options: opts,
-                    anonymousId: user.anonymousId
-                  }, user.id && user.id !== id && {
-                    previousId: user.id
-                  }), resolve, [traits, options, callback]);
-                }));
-              case 7:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee);
-      }));
-      function identify(_x, _x2, _x3, _x4) {
-        return _identify.apply(this, arguments);
-      }
-      return identify;
-    }(),
-    track: function() {
-      var _track = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee2(eventName, payload, options, callback) {
-        var name, data, opts;
-        return regenerator.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                name = M$3(eventName) ? eventName.event : eventName;
-                if (!(!name || !L$1(name))) {
-                  _context2.next = 3;
-                  break;
-                }
-                throw new Error("EventMissing");
-              case 3:
-                data = M$3(eventName) ? eventName : payload || {};
-                opts = M$3(options) ? options : {};
-                return _context2.abrupt("return", new Promise(function(resolve) {
-                  store.dispatch({
-                    type: EVENTS$1.trackStart,
-                    event: name,
-                    properties: data,
-                    options: opts,
-                    userId: getUserProp(ID, instance, payload),
-                    anonymousId: getUserProp(ANONID, instance, payload)
-                  }, resolve, [payload, options, callback]);
-                }));
-              case 6:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }));
-      function track(_x5, _x6, _x7, _x8) {
-        return _track.apply(this, arguments);
-      }
-      return track;
-    }(),
-    page: function() {
-      var _page = _asyncToGenerator(/* @__PURE__ */ regenerator.mark(function _callee3(data, options, callback) {
-        var d2, opts;
-        return regenerator.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                d2 = M$3(data) ? data : {};
-                opts = M$3(options) ? options : {};
-                return _context3.abrupt("return", new Promise(function(resolve) {
-                  store.dispatch({
-                    type: EVENTS$1.pageStart,
-                    properties: getPageData(d2),
-                    options: opts,
-                    userId: getUserProp(ID, instance, d2),
-                    anonymousId: getUserProp(ANONID, instance, d2)
-                  }, resolve, [data, options, callback]);
-                }));
-              case 3:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3);
-      }));
-      function page2(_x9, _x10, _x11) {
-        return _page.apply(this, arguments);
-      }
-      return page2;
-    }(),
-    user: function user(key) {
-      if (key === ID || key === "id") {
-        return getUserProp(ID, instance);
-      }
-      if (key === ANONID || key === "anonId") {
-        return getUserProp(ANONID, instance);
-      }
-      var user2 = instance.getState("user");
-      if (!key)
-        return user2;
-      return dotProp(user2, key);
-    },
-    reset: function reset(callback) {
-      return new Promise(function(resolve) {
-        store.dispatch({
-          type: EVENTS$1.resetStart
-        }, resolve, callback);
-      });
-    },
-    ready: function ready(callback) {
-      return instance.on(EVENTS$1.ready, callback);
-    },
-    on: function on(name, callback) {
-      if (!name || !_(callback)) {
-        return false;
-      }
-      if (name === EVENTS$1.bootstrap) {
-        throw new Error(".on disabled for " + name);
-      }
-      var startRegex = /Start$|Start:/;
-      if (name === "*") {
-        var beforeHandler = function beforeHandler2(store2) {
-          return function(next) {
-            return function(action) {
-              if (action.type.match(startRegex)) {
-                callback({
-                  payload: action,
-                  instance,
-                  plugins: customPlugins
-                });
-              }
-              return next(action);
-            };
-          };
-        };
-        var afterHandler = function afterHandler2(store2) {
-          return function(next) {
-            return function(action) {
-              if (!action.type.match(startRegex)) {
-                callback({
-                  payload: action,
-                  instance,
-                  plugins: customPlugins
-                });
-              }
-              return next(action);
-            };
-          };
-        };
-        addMiddleware(beforeHandler, before);
-        addMiddleware(afterHandler, after);
-        return function() {
-          removeMiddleware(beforeHandler, before);
-          removeMiddleware(afterHandler, after);
-        };
-      }
-      var position = name.match(startRegex) ? before : after;
-      var handler = function handler2(store2) {
-        return function(next) {
-          return function(action) {
-            if (action.type === name) {
-              callback({
-                payload: action,
-                instance,
-                plugins: customPlugins,
-                abort: nonAbortable
-              });
-            }
-            return next(action);
-          };
-        };
-      };
-      addMiddleware(handler, position);
-      return function() {
-        return removeMiddleware(handler, position);
-      };
-    },
-    once: function once(name, callback) {
-      if (!name || !_(callback)) {
-        return false;
-      }
-      if (name === EVENTS$1.bootstrap) {
-        throw new Error(".once disabled for " + name);
-      }
-      var detachListener = instance.on(name, function(_ref2) {
-        var payload = _ref2.payload;
-        callback({
-          payload,
-          instance,
-          plugins: customPlugins,
-          abort: nonAbortable
-        });
-        detachListener();
-      });
-      return detachListener;
-    },
-    getState: function getState(key) {
-      var state = store.getState();
-      if (key)
-        return dotProp(state, key);
-      return Object.assign({}, state);
-    },
-    dispatch: function dispatch(action) {
-      var actionData = L$1(action) ? {
-        type: action
-      } : action;
-      if (isReservedAction(actionData.type)) {
-        throw new Error("reserved action " + actionData.type);
-      }
-      var _private = action._ || {};
-      var dispatchData = _objectSpread2$1(_objectSpread2$1({}, actionData), {}, {
-        _: _objectSpread2$1({
-          originalAction: actionData.type
-        }, _private)
-      });
-      store.dispatch(dispatchData);
-    },
-    enablePlugin: plugins.enable,
-    disablePlugin: plugins.disable,
-    plugins,
-    storage: {
-      getItem: storage2.getItem,
-      setItem: function setItem(key, value, options) {
-        store.dispatch({
-          type: EVENTS$1.setItemStart,
-          key,
-          value,
-          options
-        });
-      },
-      removeItem: function removeItem(key, options) {
-        store.dispatch({
-          type: EVENTS$1.removeItemStart,
-          key,
-          options
-        });
-      }
-    },
-    setAnonymousId: function setAnonymousId(anonymousId, options) {
-      instance.storage.setItem(ANON_ID, anonymousId, options);
-    },
-    events: {
-      all: allSystemEvents,
-      core: coreEvents,
-      plugins: allPluginEvents
-    }
-  };
-  var enrichMiddleware = function enrichMiddleware2(storeAPI) {
-    return function(next) {
-      return function(action) {
-        if (!action.meta) {
-          action.meta = generateMeta();
-        }
-        return next(action);
+    return U2(o2, a2), function() {
+      return V2(o2, a2);
+    };
+  }, once: function(e2, n3) {
+    if (!e2 || !W$1(n3))
+      return false;
+    if (e2 === q.bootstrap)
+      throw new Error(".once disabled for " + e2);
+    var t3 = K2.on(e2, function(e3) {
+      n3({ payload: e3.payload, instance: K2, plugins: h2, abort: X2 }), t3();
+    });
+    return t3;
+  }, getState: function(e2) {
+    var n3 = oe2.getState();
+    return e2 ? i$3(n3, e2) : Object.assign({}, n3);
+  }, dispatch: function(e2) {
+    var n3 = q$1(e2) ? { type: e2 } : e2;
+    if (z.includes(n3.type))
+      throw new Error("reserved action " + n3.type);
+    var t3 = v({}, n3, { _: v({ originalAction: n3.type }, e2._ || {}) });
+    oe2.dispatch(t3);
+  }, enablePlugin: G2.enable, disablePlugin: G2.disable, plugins: G2, storage: { getItem: f$1.getItem, setItem: function(e2, n3, t3) {
+    oe2.dispatch({ type: q.setItemStart, key: e2, value: n3, options: t3 });
+  }, removeItem: function(e2, n3) {
+    oe2.dispatch({ type: q.removeItemStart, key: e2, options: n3 });
+  } }, setAnonymousId: function(e2, n3) {
+    K2.storage.setItem(A$1, e2, n3);
+  }, events: { core: z, plugins: w2 } }, Q2 = s$1.middlewares.concat([function(e2) {
+    return function(e3) {
+      return function(n3) {
+        return n3.meta || (n3.meta = Ue()), e3(n3);
       };
     };
-  };
-  var middlewares = parsedOptions.middlewares.concat([
-    enrichMiddleware,
-    dynamicMiddlewares(before),
-    pluginMiddleware(instance, getPlugins, {
-      all: allSystemEvents,
-      plugins: allPluginEvents
-    }),
-    storageMiddleware(storage2),
-    initializeMiddleware(instance),
-    identifyMiddleware(instance),
-    dynamicMiddlewares(after)
-  ]);
-  var coreReducers = {
-    context,
-    user: userReducer(storage2),
-    page,
-    track: trackReducer,
-    plugins: createReducer(getPlugins),
-    queue: queueReducer
-  };
-  var composeEnhancers = compose;
-  var composeWithGlobalDebug = compose;
-  if (z && config2.debug) {
-    var devTools = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__;
-    if (devTools) {
-      composeEnhancers = devTools({
-        trace: true,
-        traceLimit: 25
-      });
-    }
-    composeWithGlobalDebug = function composeWithGlobalDebug2() {
-      if (arguments.length === 0)
-        return Debug();
-      if (M$3(_typeof(arguments[0])))
-        return composeWithDebug();
-      return composeWithDebug().apply(null, arguments);
+  }, L2(Le), ce(K2, x2, { all: _2, plugins: w2 }), se(f$1), C$1(K2), B(K2), L2(Ce)]), Y2 = { context: xe, user: R(f$1), page: Ae, track: he, plugins: fe(x2), queue: ye }, Z2 = N$1, ee2 = N$1;
+  if ($$1 && n2.debug) {
+    var ne2 = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__;
+    ne2 && (Z2 = ne2({ trace: true, traceLimit: 25 })), ee2 = function() {
+      return arguments.length === 0 ? ze() : on(typeof arguments[0]) ? Me() : Me().apply(null, arguments);
     };
   }
-  var initialConfig = makeContext(config2);
-  var intialPluginState = parsedOptions.pluginsArray.reduce(function(acc, plugin) {
-    var name = plugin.name, config3 = plugin.config, loaded = plugin.loaded;
-    var isEnabled = parsedOptions.pluginEnabled[name];
-    acc[name] = {
-      enabled: isEnabled,
-      initialized: isEnabled ? Boolean(!plugin.initialize) : false,
-      loaded: Boolean(loaded()),
-      config: config3 || {}
-    };
-    return acc;
-  }, {});
-  var initialState2 = {
-    context: initialConfig,
-    user: visitorInfo,
-    plugins: intialPluginState
-  };
-  var store = createStore(combineReducers(_objectSpread2$1(_objectSpread2$1({}, coreReducers), customReducers)), initialState2, composeWithGlobalDebug(composeEnhancers(applyMiddleware.apply(void 0, _toConsumableArray(middlewares)))));
-  function enhanceDispatch(fn) {
-    return function(event, resolver, callbacks) {
-      var meta = generateMeta(event.meta, resolver, ensureArray(callbacks));
-      var newEvent = _objectSpread2$1(_objectSpread2$1({}, event), {
-        meta
-      });
-      return fn.apply(null, [newEvent]);
+  var te2, re2 = function(e2) {
+    return Object.keys(e2).reduce(function(n3, t3) {
+      return ke.includes(t3) || (n3[t3] = e2[t3]), n3;
+    }, {});
+  }(n2), ie2 = s$1.pluginsArray.reduce(function(e2, n3) {
+    var t3 = n3.name, r2 = n3.config, i2 = n3.loaded, a2 = s$1.pluginEnabled[t3];
+    return e2[t3] = { enabled: a2, initialized: !!a2 && Boolean(!n3.initialize), loaded: Boolean(i2()), config: r2 || {} }, e2;
+  }, {}), ae2 = { context: re2, user: F2, plugins: ie2 }, oe2 = P(function(e2) {
+    for (var n3 = Object.keys(e2), t3 = {}, r2 = 0; r2 < n3.length; r2++) {
+      var i2 = n3[r2];
+      typeof e2[i2] === y && (t3[i2] = e2[i2]);
+    }
+    var a2, o2 = Object.keys(t3);
+    try {
+      !function(e3) {
+        Object.keys(e3).forEach(function(n4) {
+          var t4 = e3[n4];
+          if (typeof t4(void 0, { type: "@@redux/INIT" }) === b$1 || typeof t4(void 0, { type: I$1 }) === b$1)
+            throw new Error("reducer " + n4 + " " + b$1);
+        });
+      }(t3);
+    } catch (e3) {
+      a2 = e3;
+    }
+    return function(e3, n4) {
+      if (e3 === void 0 && (e3 = {}), a2)
+        throw a2;
+      for (var r3 = false, i3 = {}, u2 = 0; u2 < o2.length; u2++) {
+        var c3 = o2[u2], s2 = e3[c3], l2 = (0, t3[c3])(s2, n4);
+        if (typeof l2 === b$1) {
+          var f2 = S(c3, n4);
+          throw new Error(f2);
+        }
+        i3[c3] = l2, r3 = r3 || l2 !== s2;
+      }
+      return r3 ? i3 : e3;
     };
-  }
-  store.dispatch = enhanceDispatch(store.dispatch);
-  var pluginKeys = Object.keys(customPlugins);
-  store.dispatch({
-    type: EVENTS$1.bootstrap,
-    plugins: pluginKeys,
-    config: initialConfig,
-    params,
-    user: visitorInfo,
-    initialUser,
-    persistedUser
-  });
-  var enabledPlugins = pluginKeys.filter(function(name) {
-    return parsedOptions.pluginEnabled[name];
+  }(v({}, Y2, t2)), ae2, ee2(Z2(O$1.apply(void 0, Q2))));
+  oe2.dispatch = (te2 = oe2.dispatch, function(e2, n3, t3) {
+    var r2 = v({}, e2, { meta: Ue(e2.meta, n3, qe(t3)) });
+    return te2.apply(null, [r2]);
   });
-  var disabledPlugins = pluginKeys.filter(function(name) {
-    return !parsedOptions.pluginEnabled[name];
+  var ue2 = Object.keys(h2);
+  oe2.dispatch({ type: q.bootstrap, plugins: ue2, config: re2, params: J2, user: F2, initialUser: c2, persistedUser: W2 });
+  var de2 = ue2.filter(function(e2) {
+    return s$1.pluginEnabled[e2];
+  }), pe2 = ue2.filter(function(e2) {
+    return !s$1.pluginEnabled[e2];
   });
-  store.dispatch({
-    type: EVENTS$1.registerPlugins,
-    plugins: pluginKeys,
-    enabled: parsedOptions.pluginEnabled
-  });
-  parsedOptions.pluginsArray.map(function(plugin, i2) {
-    var bootstrap = plugin.bootstrap, config3 = plugin.config, name = plugin.name;
-    if (bootstrap && _(bootstrap)) {
-      bootstrap({
-        instance,
-        config: config3,
-        payload: plugin
-      });
-    }
-    store.dispatch({
-      type: EVENTS$1.registerPluginType(name),
-      name,
-      enabled: parsedOptions.pluginEnabled[name],
-      plugin
-    });
-    if (parsedOptions.pluginsArray.length === i2 + 1) {
-      store.dispatch({
-        type: EVENTS$1.initializeStart,
-        plugins: enabledPlugins,
-        disabled: disabledPlugins
-      });
-    }
-  });
-  {
-    watch(function(offline) {
-      store.dispatch({
-        type: offline ? EVENTS$1.offline : EVENTS$1.online
-      });
-    });
-    heartBeat(store, getPlugins, instance);
-  }
-  function appendArguments(fn) {
-    return function() {
-      var args = Array.prototype.slice.call(arguments);
-      var newArgs = new Array(fn.length);
-      for (var i2 = 0; i2 < args.length; i2++) {
-        newArgs[i2] = args[i2];
-      }
-      newArgs[newArgs.length] = instance;
-      return fn.apply({
-        instance
-      }, newArgs);
-    };
-  }
-  return instance;
-}
-var before = "before";
-var after = "after";
-var o$5 = "object", j$2 = "__", F$2 = typeof process != "undefined" ? process : {};
-F$2.env && F$2.env.NODE_ENV || "";
-var $$2 = typeof window != "undefined";
-F$2.versions != null && F$2.versions.node != null;
-typeof Deno != "undefined" && Deno.core !== void 0;
-$$2 && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-function M$2(n2, t2) {
-  return t2.charAt(0)[n2]() + t2.slice(1);
-}
-var U$2 = M$2.bind(null, "toUpperCase"), H$2 = M$2.bind(null, "toLowerCase");
-function J$2(n2) {
-  return Y$2(n2) ? U$2("null") : typeof n2 == "object" ? yn$2(n2) : Object.prototype.toString.call(n2).slice(8, -1);
-}
-function R$2(n2, t2) {
-  t2 === void 0 && (t2 = true);
-  var e2 = J$2(n2);
-  return t2 ? H$2(e2) : e2;
-}
-function V$2(n2, t2) {
-  return typeof t2 === n2;
-}
-var W$2 = V$2.bind(null, "function"), q$2 = V$2.bind(null, "string");
-V$2.bind(null, "undefined");
-V$2.bind(null, "boolean");
-V$2.bind(null, "symbol");
-function Y$2(n2) {
-  return n2 === null;
-}
-function nn$2(n2) {
-  return R$2(n2) === "number" && !isNaN(n2);
-}
-function yn$2(n2) {
-  return W$2(n2.constructor) ? n2.constructor.name : null;
-}
-function hn$2(n2) {
-  return n2 instanceof Error || q$2(n2.message) && n2.constructor && nn$2(n2.constructor.stackTraceLimit);
-}
-function On$2(n2, t2) {
-  if (typeof t2 != "object" || Y$2(t2))
-    return false;
-  if (t2 instanceof n2)
-    return true;
-  var e2 = R$2(new n2(""));
-  if (hn$2(t2))
-    for (; t2; ) {
-      if (R$2(t2) === e2)
-        return true;
-      t2 = Object.getPrototypeOf(t2);
-    }
-  return false;
-}
-On$2.bind(null, TypeError);
-On$2.bind(null, SyntaxError);
-function $n$2(n2, t2) {
-  var e2 = n2 instanceof Element || n2 instanceof HTMLDocument;
-  return e2 && t2 ? Tn$2(n2, t2) : e2;
-}
-function Tn$2(n2, t2) {
-  return t2 === void 0 && (t2 = ""), n2 && n2.nodeName === t2.toUpperCase();
-}
-function _n$2(n2) {
-  var t2 = [].slice.call(arguments, 1);
-  return function() {
-    return n2.apply(void 0, [].slice.call(arguments).concat(t2));
-  };
-}
-_n$2($n$2, "form");
-_n$2($n$2, "button");
-_n$2($n$2, "input");
-_n$2($n$2, "select");
-var l = "global", o$4 = j$2 + "global" + j$2, n$2 = typeof self === o$5 && self.self === self && self || typeof global === o$5 && global.global === global && global || void 0;
-function a$3(t2) {
-  return n$2[o$4][t2];
-}
-function f$2(t2, e2) {
-  return n$2[o$4][t2] = e2;
-}
-function i$3(t2) {
-  delete n$2[o$4][t2];
-}
-n$2[o$4] || (n$2[o$4] = {});
-var o$3 = "object", j$1 = "__", F$1 = typeof process != "undefined" ? process : {};
-F$1.env && F$1.env.NODE_ENV || "";
-var $$1 = typeof window != "undefined";
-F$1.versions != null && F$1.versions.node != null;
-typeof Deno != "undefined" && Deno.core !== void 0;
-$$1 && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-function M$1(n2, t2) {
-  return t2.charAt(0)[n2]() + t2.slice(1);
-}
-var U$1 = M$1.bind(null, "toUpperCase"), H$1 = M$1.bind(null, "toLowerCase");
-function J$1(n2) {
-  return Y$1(n2) ? U$1("null") : typeof n2 == "object" ? yn$1(n2) : Object.prototype.toString.call(n2).slice(8, -1);
-}
-function R$1(n2, t2) {
-  t2 === void 0 && (t2 = true);
-  var e2 = J$1(n2);
-  return t2 ? H$1(e2) : e2;
-}
-function V$1(n2, t2) {
-  return typeof t2 === n2;
-}
-var W$1 = V$1.bind(null, "function"), q$1 = V$1.bind(null, "string");
-V$1.bind(null, "undefined");
-V$1.bind(null, "boolean");
-V$1.bind(null, "symbol");
-function Y$1(n2) {
-  return n2 === null;
-}
-function nn$1(n2) {
-  return R$1(n2) === "number" && !isNaN(n2);
-}
-function yn$1(n2) {
-  return W$1(n2.constructor) ? n2.constructor.name : null;
-}
-function hn$1(n2) {
-  return n2 instanceof Error || q$1(n2.message) && n2.constructor && nn$1(n2.constructor.stackTraceLimit);
-}
-function On$1(n2, t2) {
-  if (typeof t2 != "object" || Y$1(t2))
-    return false;
-  if (t2 instanceof n2)
-    return true;
-  var e2 = R$1(new n2(""));
-  if (hn$1(t2))
-    for (; t2; ) {
-      if (R$1(t2) === e2)
-        return true;
-      t2 = Object.getPrototypeOf(t2);
-    }
-  return false;
-}
-On$1.bind(null, TypeError);
-On$1.bind(null, SyntaxError);
-function $n$1(n2, t2) {
-  var e2 = n2 instanceof Element || n2 instanceof HTMLDocument;
-  return e2 && t2 ? Tn$1(n2, t2) : e2;
-}
-function Tn$1(n2, t2) {
-  return t2 === void 0 && (t2 = ""), n2 && n2.nodeName === t2.toUpperCase();
-}
-function _n$1(n2) {
-  var t2 = [].slice.call(arguments, 1);
-  return function() {
-    return n2.apply(void 0, [].slice.call(arguments).concat(t2));
-  };
-}
-_n$1($n$1, "form");
-_n$1($n$1, "button");
-_n$1($n$1, "input");
-_n$1($n$1, "select");
-var o$2 = j$1 + "global" + j$1, n$1 = typeof self === o$3 && self.self === self && self || typeof global === o$3 && global.global === global && global || void 0;
-function a$2(t2) {
-  return n$1[o$2][t2];
-}
-function f$1(t2, e2) {
-  return n$1[o$2][t2] = e2;
-}
-function i$2(t2) {
-  delete n$1[o$2][t2];
-}
-n$1[o$2] || (n$1[o$2] = {});
-var t = "cookie", i$1 = a$1(), r$1 = d$1, c$1 = d$1;
-function u$1(o2) {
+  return oe2.dispatch({ type: q.registerPlugins, plugins: ue2, enabled: s$1.pluginEnabled }), s$1.pluginsArray.map(function(e2, n3) {
+    var t3 = e2.bootstrap, r2 = e2.config, i2 = e2.name;
+    t3 && W$1(t3) && t3({ instance: K2, config: r2, payload: e2 }), oe2.dispatch({ type: q.registerPluginType(i2), name: i2, enabled: s$1.pluginEnabled[i2], plugin: e2 }), s$1.pluginsArray.length === n3 + 1 && oe2.dispatch({ type: q.initializeStart, plugins: de2, disabled: pe2 });
+  }), Te(function(e2) {
+    oe2.dispatch({ type: e2 ? q.offline : q.online });
+  }), function(e2, n3, t3) {
+    setInterval(function() {
+      return H(e2, n3, t3);
+    }, 3e3);
+  }(oe2, x2, K2), K2;
+}
+var Le = "before", Ce = "after";
+var t = "cookie", i$1 = a$1(), r$1 = d$1, c = d$1;
+function u(o2) {
   return i$1 ? d$1(o2, "", -1) : i$2(o2);
 }
 function a$1() {
@@ -3259,7 +1116,7 @@ function a$1() {
     return i$1;
   var e2 = "cookiecookie";
   try {
-    d$1(e2, e2), i$1 = document.cookie.indexOf(e2) !== -1, u$1(e2);
+    d$1(e2, e2), i$1 = document.cookie.indexOf(e2) !== -1, u(e2);
   } catch (e3) {
     i$1 = false;
   }
@@ -3268,125 +1125,25 @@ function a$1() {
 function d$1(e2, t2, r2, c2, u2, a2) {
   if (typeof window != "undefined") {
     var d2 = arguments.length > 1;
-    return i$1 === false && (d2 ? f$1(e2, t2) : a$2(e2)), d2 ? document.cookie = e2 + "=" + encodeURIComponent(t2) + (r2 ? "; expires=" + new Date(+new Date() + 1e3 * r2).toUTCString() + (c2 ? "; path=" + c2 : "") + (u2 ? "; domain=" + u2 : "") + (a2 ? "; secure" : "") : "") : decodeURIComponent((("; " + document.cookie).split("; " + e2 + "=")[1] || "").split(";")[0]);
-  }
-}
-var e = "undefined", o$1 = "object", j = "__", F = typeof process != "undefined" ? process : {};
-F.env && F.env.NODE_ENV || "";
-var $ = typeof window != "undefined";
-F.versions != null && F.versions.node != null;
-typeof Deno != "undefined" && Deno.core !== void 0;
-$ && window.name === "nodejs" || typeof navigator != "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-function M(n2, t2) {
-  return t2.charAt(0)[n2]() + t2.slice(1);
-}
-var U = M.bind(null, "toUpperCase"), H = M.bind(null, "toLowerCase");
-function J(n2) {
-  return Y(n2) ? U("null") : typeof n2 == "object" ? yn(n2) : Object.prototype.toString.call(n2).slice(8, -1);
-}
-function R(n2, t2) {
-  t2 === void 0 && (t2 = true);
-  var e2 = J(n2);
-  return t2 ? H(e2) : e2;
-}
-function V(n2, t2) {
-  return typeof t2 === n2;
-}
-var W = V.bind(null, "function"), q = V.bind(null, "string");
-V.bind(null, "undefined");
-V.bind(null, "boolean");
-V.bind(null, "symbol");
-function Y(n2) {
-  return n2 === null;
-}
-function nn(n2) {
-  return R(n2) === "number" && !isNaN(n2);
-}
-function yn(n2) {
-  return W(n2.constructor) ? n2.constructor.name : null;
-}
-function hn(n2) {
-  return n2 instanceof Error || q(n2.message) && n2.constructor && nn(n2.constructor.stackTraceLimit);
-}
-function On(n2, t2) {
-  if (typeof t2 != "object" || Y(t2))
-    return false;
-  if (t2 instanceof n2)
-    return true;
-  var e2 = R(new n2(""));
-  if (hn(t2))
-    for (; t2; ) {
-      if (R(t2) === e2)
-        return true;
-      t2 = Object.getPrototypeOf(t2);
-    }
-  return false;
-}
-On.bind(null, TypeError);
-On.bind(null, SyntaxError);
-function $n(n2, t2) {
-  var e2 = n2 instanceof Element || n2 instanceof HTMLDocument;
-  return e2 && t2 ? Tn(n2, t2) : e2;
-}
-function Tn(n2, t2) {
-  return t2 === void 0 && (t2 = ""), n2 && n2.nodeName === t2.toUpperCase();
-}
-function _n(n2) {
-  var t2 = [].slice.call(arguments, 1);
-  return function() {
-    return n2.apply(void 0, [].slice.call(arguments).concat(t2));
-  };
-}
-_n($n, "form");
-_n($n, "button");
-_n($n, "input");
-_n($n, "select");
-var o = j + "global" + j, n = typeof self === o$1 && self.self === self && self || typeof global === o$1 && global.global === global && global || void 0;
-function a(t2) {
-  return n[o][t2];
-}
-function f(t2, e2) {
-  return n[o][t2] = e2;
-}
-function i(t2) {
-  delete n[o][t2];
-}
-function u(t2, e2, r2) {
-  var l2;
-  try {
-    if (b$1(t2)) {
-      var o2 = window[t2];
-      l2 = o2[e2].bind(o2);
-    }
-  } catch (t3) {
-  }
-  return l2 || r2;
-}
-n[o] || (n[o] = {});
-var c = {};
-function b$1(t2) {
-  if (typeof c[t2] !== e)
-    return c[t2];
-  try {
-    var e$1 = window[t2];
-    e$1.setItem(e, e), e$1.removeItem(e);
-  } catch (e2) {
-    return c[t2] = false;
-  }
-  return c[t2] = true;
-}
-var r = "localStorage", g = b$1.bind(null, "localStorage");
-u("localStorage", "getItem", a);
-u("localStorage", "setItem", f);
-u("localStorage", "removeItem", i);
-function y(t2) {
+    return i$1 === false && (d2 ? f(e2, t2) : a$2(e2)), d2 ? document.cookie = e2 + "=" + encodeURIComponent(t2) + (r2 ? "; expires=" + new Date(+new Date() + 1e3 * r2).toUTCString() + (c2 ? "; path=" + c2 : "") + (u2 ? "; domain=" + u2 : "") + (a2 ? "; secure" : "") : "") : decodeURIComponent((("; " + document.cookie).split("; " + e2 + "=")[1] || "").split(";")[0]);
+  }
+}
+var r = "localStorage", g = b$2.bind(null, "localStorage");
+u$1("localStorage", "getItem", a$2);
+u$1("localStorage", "setItem", f);
+u$1("localStorage", "removeItem", i$2);
+var a = "sessionStorage", i = b$2.bind(null, "sessionStorage");
+u$1("sessionStorage", "getItem", a$2);
+u$1("sessionStorage", "setItem", f);
+u$1("sessionStorage", "removeItem", i$2);
+function I(t2) {
   var o2 = t2;
   try {
     if ((o2 = JSON.parse(t2)) === "true")
       return true;
     if (o2 === "false")
       return false;
-    if (M$3(o2))
+    if (on(o2))
       return o2;
     parseFloat(o2) === o2 && (o2 = parseFloat(o2));
   } catch (t3) {
@@ -3394,52 +1151,57 @@ function y(t2) {
   if (o2 !== null && o2 !== "")
     return o2;
 }
-var S = g(), k = a$1();
-function I(o2, r2) {
+var k = g(), O = i(), x = a$1();
+function C(o2, e2) {
   if (o2) {
-    var e2 = L(r2), a2 = !A(e2), l2 = O(e2) ? y(localStorage.getItem(o2)) : void 0;
-    if (a2 && !$$3(l2))
-      return l2;
-    var n2 = b(e2) ? y(r$1(o2)) : void 0;
+    var r2 = A(e2), a2 = !N(r2), i2 = d(r2) ? I(localStorage.getItem(o2)) : void 0;
+    if (a2 && !I$2(i2))
+      return i2;
+    var n2 = h(r2) ? I(r$1(o2)) : void 0;
     if (a2 && n2)
       return n2;
-    var u2 = a$3(o2);
-    return a2 ? u2 : { localStorage: l2, cookie: n2, global: u2 };
+    var l2 = E(r2) ? I(sessionStorage.getItem(o2)) : void 0;
+    if (a2 && l2)
+      return l2;
+    var u2 = a$2(o2);
+    return a2 ? u2 : { localStorage: i2, sessionStorage: l2, cookie: n2, global: u2 };
   }
 }
-function x(e2, a2, u2) {
-  if (e2 && !$$3(a2)) {
-    var c2 = {}, f2 = L(u2), g2 = JSON.stringify(a2), m2 = !A(f2);
-    return O(f2) && (c2[r] = h(r, a2, y(localStorage.getItem(e2))), localStorage.setItem(e2, g2), m2) ? c2[r] : b(f2) && (c2[t] = h(t, a2, y(r$1(e2))), c$1(e2, g2), m2) ? c2[t] : (c2[l] = h(l, a2, a$3(e2)), f$2(e2, a2), m2 ? c2[l] : c2);
+function L(r$2, a$12, l$1) {
+  if (r$2 && !I$2(a$12)) {
+    var u2 = {}, g2 = A(l$1), m2 = JSON.stringify(a$12), S2 = !N(g2);
+    return d(g2) && (u2[r] = F(r, a$12, I(localStorage.getItem(r$2))), localStorage.setItem(r$2, m2), S2) ? u2[r] : h(g2) && (u2[t] = F(t, a$12, I(r$1(r$2))), c(r$2, m2), S2) ? u2[t] : E(g2) && (u2[a] = F(a, a$12, I(sessionStorage.getItem(r$2))), sessionStorage.setItem(r$2, m2), S2) ? u2[a] : (u2[l] = F(l, a$12, a$2(r$2)), f(r$2, a$12), S2 ? u2[l] : u2);
   }
 }
-function C(t$1, r$12) {
+function b(t$1, e2) {
   if (t$1) {
-    var a2 = L(r$12), i2 = I(t$1, l$1), n2 = {};
-    return !$$3(i2.localStorage) && O(a2) && (localStorage.removeItem(t$1), n2[r] = i2.localStorage), !$$3(i2.cookie) && b(a2) && (u$1(t$1), n2[t] = i2.cookie), !$$3(i2.global) && d(a2, l) && (i$3(t$1), n2[l] = i2.global), n2;
+    var a$12 = A(e2), s2 = C(t$1, m$1), n2 = {};
+    return !I$2(s2.localStorage) && d(a$12) && (localStorage.removeItem(t$1), n2[r] = s2.localStorage), !I$2(s2.cookie) && h(a$12) && (u(t$1), n2[t] = s2.cookie), !I$2(s2.sessionStorage) && E(a$12) && (sessionStorage.removeItem(t$1), n2[a] = s2.sessionStorage), !I$2(s2.global) && G(a$12, l) && (i$2(t$1), n2[l] = s2.global), n2;
   }
 }
-function L(t2) {
-  return t2 ? L$1(t2) ? t2 : t2.storage : f$3;
+function A(t2) {
+  return t2 ? q$1(t2) ? t2 : t2.storage : g$1;
 }
-function O(t2) {
-  return S && d(t2, r);
+function d(t2) {
+  return k && G(t2, r);
 }
-function b(t$1) {
-  return k && d(t$1, t);
+function h(t$1) {
+  return x && G(t$1, t);
 }
-function A(t2) {
-  return t2 === l$1 || t2 === "all";
+function E(t2) {
+  return O && G(t2, a);
 }
-function d(t2, o2) {
-  return t2 === f$3 || t2 === o2 || A(t2);
+function N(t2) {
+  return t2 === m$1 || t2 === "all";
 }
-function h(t2, o2, r2) {
-  return { location: t2, current: o2, previous: r2 };
+function G(t2, o2) {
+  return t2 === g$1 || t2 === o2 || N(t2);
 }
-var N = { setItem: x, getItem: I, removeItem: C };
-var storage = N;
-function _defineProperty$1(obj, key, value) {
+function F(t2, o2, e2) {
+  return { location: t2, current: o2, previous: e2 };
+}
+var J = { setItem: L, getItem: C, removeItem: b };
+function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value,
@@ -3452,169 +1214,78 @@ function _defineProperty$1(obj, key, value) {
   }
   return obj;
 }
-var defineProperty = _defineProperty$1;
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly)
-      symbols = symbols.filter(function(sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      });
-    keys.push.apply(keys, symbols);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
   }
   return keys;
 }
 function _objectSpread2(target) {
   for (var i2 = 1; i2 < arguments.length; i2++) {
     var source = arguments[i2] != null ? arguments[i2] : {};
-    if (i2 % 2) {
-      ownKeys(source, true).forEach(function(key) {
-        defineProperty(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ownKeys(source).forEach(function(key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+    i2 % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
   }
   return target;
 }
-var objectSpread2 = _objectSpread2;
 function analyticsLib() {
   var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   var defaultSettings = {
-    storage
+    storage: J
   };
-  return analytics(objectSpread2(objectSpread2({}, defaultSettings), opts));
-}
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _objectSpread(target) {
-  for (var i2 = 1; i2 < arguments.length; i2++) {
-    var source = arguments[i2] != null ? arguments[i2] : {};
-    var ownKeys2 = Object.keys(source);
-    if (typeof Object.getOwnPropertySymbols === "function") {
-      ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-      }));
-    }
-    ownKeys2.forEach(function(key) {
-      _defineProperty(target, key, source[key]);
-    });
-  }
-  return target;
+  return Ve(_objectSpread2(_objectSpread2({}, defaultSettings), opts));
 }
-var config = {
-  debug: false,
-  containerId: null,
-  dataLayerName: "dataLayer",
-  dataLayer: void 0,
-  preview: void 0,
-  auth: void 0,
-  execution: "async"
-};
-var initializedDataLayerName;
-function googleTagManager$1() {
-  var pluginConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+function facebookScriptInit(f2, b2, e2, v2, n2, t2, s2) {
+  if (f2.fbq)
+    return;
+  n2 = f2.fbq = function() {
+    n2.callMethod ? n2.callMethod.apply(n2, arguments) : n2.queue.push(arguments);
+  };
+  if (!f2._fbq)
+    f2._fbq = n2;
+  n2.push = n2;
+  n2.loaded = true;
+  n2.version = "2.0";
+  n2.queue = [];
+  t2 = b2.createElement(e2);
+  t2.async = true;
+  t2.src = v2;
+  s2 = b2.getElementsByTagName(e2)[0];
+  s2.parentNode.insertBefore(t2, s2);
+}
+function facebookInit({ trackingId }) {
+  facebookScriptInit(window, document, "script", "https://connect.facebook.net/en_US/fbevents.js");
+  window.fbq("init", trackingId);
+}
+function facebook(pluginConfig = {}) {
   return {
-    name: "google-tag-manager",
-    config: _objectSpread({}, config, pluginConfig),
-    initialize: function initialize(_ref2) {
-      var config2 = _ref2.config;
-      var containerId = config2.containerId, dataLayerName = config2.dataLayerName, customScriptSrc = config2.customScriptSrc, preview = config2.preview, auth = config2.auth, execution = config2.execution;
-      if (!containerId) {
-        throw new Error("No google tag manager containerId defined");
-      }
-      if (preview && !auth) {
-        throw new Error("When enabling preview mode, both preview and auth parameters must be defined");
-      }
-      var scriptSrc = customScriptSrc || "https://www.googletagmanager.com/gtm.js";
-      if (!scriptLoaded(containerId)) {
-        (function(w, d2, s2, l2, i2) {
-          w[l2] = w[l2] || [];
-          w[l2].push({
-            "gtm.start": new Date().getTime(),
-            event: "gtm.js"
-          });
-          var f2 = d2.getElementsByTagName(s2)[0], j2 = d2.createElement(s2), dl = l2 != "dataLayer" ? "&l=" + l2 : "", p2 = preview ? "&gtm_preview=" + preview + "&gtm_auth=" + auth + "&gtm_cookies_win=x" : "";
-          if (execution) {
-            j2[execution] = true;
-          }
-          j2.src = "".concat(scriptSrc, "?id=") + i2 + dl + p2;
-          f2.parentNode.insertBefore(j2, f2);
-        })(window, document, "script", dataLayerName, containerId);
-        initializedDataLayerName = dataLayerName;
-        config2.dataLayer = window[dataLayerName];
-      }
+    name: "facebook",
+    config: pluginConfig,
+    initialize: function({ config, instance }) {
+      if (!config.trackingId)
+        throw new Error("No Facebook trackingId defined");
+      facebookInit({ trackingId: config.trackingId });
     },
-    page: function page2(_ref2) {
-      var payload = _ref2.payload;
-      _ref2.options;
-      _ref2.instance;
-      var config2 = _ref2.config;
-      if (typeof config2.dataLayer !== "undefined") {
-        config2.dataLayer.push(payload.properties);
-      }
+    page: function({ payload, config, instance }) {
+      window.fbq("track", "PageView");
     },
-    track: function track(_ref3) {
-      var payload = _ref3.payload;
-      _ref3.options;
-      var config2 = _ref3.config;
-      if (typeof config2.dataLayer !== "undefined") {
-        var anonymousId = payload.anonymousId, userId = payload.userId, properties = payload.properties;
-        var formattedPayload = properties;
-        if (userId) {
-          formattedPayload.userId = userId;
-        }
-        if (anonymousId) {
-          formattedPayload.anonymousId = anonymousId;
-        }
-        if (!properties.category) {
-          formattedPayload.category = "All";
-        }
-        if (config2.debug) {
-          console.log("gtag push", _objectSpread({
-            event: payload.event
-          }, formattedPayload));
-        }
-        config2.dataLayer.push(_objectSpread({
-          event: payload.event
-        }, formattedPayload));
-      }
+    track: function({ payload, config, instance }) {
+      window.fbq("track", payload.event, payload.properties);
     },
-    loaded: function loaded() {
-      var hasDataLayer = !!initializedDataLayerName && !!(window[initializedDataLayerName] && Array.prototype.push !== window[initializedDataLayerName].push);
-      return scriptLoaded(pluginConfig.containerId) && hasDataLayer;
+    identify: function({ payload, config }) {
+    },
+    loaded: function() {
+      return !!window.fbq;
     }
   };
 }
-var regexCache = {};
-function scriptLoaded(containerId) {
-  var regex = regexCache[containerId];
-  if (!regex) {
-    regex = new RegExp("googletagmanager\\.com\\/gtm\\.js.*[?&]id=" + containerId);
-    regexCache[containerId] = regex;
-  }
-  var scripts = document.querySelectorAll("script[src]");
-  return !!Object.keys(scripts).filter(function(key) {
-    return (scripts[key].src || "").match(regex);
-  }).length;
-}
-var index = googleTagManager$1;
 function gtag() {
   window.dataLayer.push(arguments);
 }
@@ -3641,28 +1312,28 @@ function googleAnalytics4(pluginConfig = {}) {
   return {
     name: "google-analytics-4",
     config: pluginConfig,
-    initialize: function({ config: config2, instance }) {
-      if (!config2.trackingId)
+    initialize: function({ config, instance }) {
+      if (!config.trackingId)
         throw new Error("No GA trackingId defined");
       var configParams = {};
       var setParams = {};
-      if (config2.customDimensions) {
+      if (config.customDimensions) {
         var customMap = {};
-        for (var i2 = 0; i2 < config2.customDimensions.length; i2++) {
-          var customDim = config2.customDimensions[i2];
-          configParams[customDim.name] = customDim.callback(instance, config2);
+        for (var i2 = 0; i2 < config.customDimensions.length; i2++) {
+          var customDim = config.customDimensions[i2];
+          configParams[customDim.name] = customDim.callback(instance, config);
           customMap["dimension" + (i2 + 1)] = customDim.name;
         }
         setParams["custom_map"] = customMap;
       }
-      gtagInit({ trackingId: config2.trackingId, configParams, setParams });
+      gtagInit({ trackingId: config.trackingId, configParams, setParams });
     },
-    page: function({ payload, config: config2, instance }) {
+    page: function({ payload, config, instance }) {
     },
-    track: function({ payload, config: config2, instance }) {
+    track: function({ payload, config, instance }) {
       gtag("event", payload.event, payload.properties);
     },
-    identify: function({ payload, config: config2 }) {
+    identify: function({ payload, config }) {
     },
     loaded: function() {
       return !!window.gtag;
@@ -3678,10 +1349,10 @@ function dbg() {
     return;
   console.debug(...arguments);
 }
-function warning(msg2) {
-  console.warn(msg2);
+function warning(msg) {
+  console.warn(msg);
   if (window.Rollbar) {
-    window.Rollbar.warning(msg2);
+    window.Rollbar.warning(msg);
   }
 }
 function isFunc(value) {
@@ -3991,11 +1662,11 @@ function clearPoolIntervals() {
   }
 }
 function getPoolNumber(_0) {
-  return __async(this, arguments, function* ({ poolId, apiUrl, number = null, context: context2 = null }) {
+  return __async(this, arguments, function* ({ poolId, apiUrl, number = null, context = null }) {
     var payload = {
       pool_id: poolId,
       number,
-      context: context2,
+      context,
       properties: {
         zar: getStorage()
       }
@@ -4022,15 +1693,15 @@ function renewTrackingPool() {
     apiUrl = getDefaultApiUrl(),
     contextCallback = null
   } = {}) {
-    var context2 = {};
+    var context = {};
     if (contextCallback) {
-      context2 = contextCallback() || {};
+      context = contextCallback() || {};
     }
     try {
-      var resp = yield getPoolNumber({ poolId, apiUrl, number, context: context2 });
+      var resp = yield getPoolNumber({ poolId, apiUrl, number, context });
     } catch (e2) {
-      var msg2 = "error getting number: " + JSON.stringify(e2);
-      warning(msg2);
+      var msg = "error getting number: " + JSON.stringify(e2);
+      warning(msg);
       getNumberFailureCount++;
       if (getNumberFailureCount >= MAX_GET_NUMBER_FAILURES) {
         warning("max failures, stopping pool");
@@ -4039,7 +1710,7 @@ function renewTrackingPool() {
           revertOverlayNumbers({ elems: overlayElements });
         }
       }
-      return { status: NUMBER_POOL_ERROR, msg: msg2 };
+      return { status: NUMBER_POOL_ERROR, msg };
     }
     if (resp.status === NUMBER_POOL_SUCCESS && resp.number) {
       if (overlayElements) {
@@ -4064,36 +1735,36 @@ function getPoolId(poolId) {
 }
 function initTrackingPool() {
   return __async(this, arguments, function* ({ poolData, poolConfig, apiUrl } = {}) {
-    var msg2;
+    var msg;
     if (!poolConfig || !poolConfig.poolId || !poolConfig.overlayQuerySelector || !apiUrl) {
-      msg2 = "missing pool config: " + JSON.stringify(poolConfig);
-      warning(msg2);
+      msg = "missing pool config: " + JSON.stringify(poolConfig);
+      warning(msg);
       if (poolConfig.initCallback) {
-        poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg: msg2 });
+        poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg });
       }
       return poolIntervals;
     }
-    var context2 = {};
+    var context = {};
     if (poolConfig.contextCallback) {
-      context2 = poolConfig.contextCallback() || {};
+      context = poolConfig.contextCallback() || {};
     }
     var poolId = getPoolId(poolConfig.poolId);
     if (!poolId) {
-      msg2 = "no pool ID";
-      warning(msg2);
+      msg = "no pool ID";
+      warning(msg);
       if (poolConfig.initCallback) {
-        poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg: msg2 });
+        poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg });
       }
       return poolIntervals;
     }
     if (!poolData) {
       try {
-        poolData = yield getPoolNumber({ poolId, apiUrl, number: null, context: context2 });
+        poolData = yield getPoolNumber({ poolId, apiUrl, number: null, context });
       } catch (e2) {
-        msg2 = "error getting number on init: " + JSON.stringify(e2);
-        warning(msg2);
+        msg = "error getting number on init: " + JSON.stringify(e2);
+        warning(msg);
         if (poolConfig.initCallback) {
-          poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg: msg2 });
+          poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg });
         }
         return poolIntervals;
       }
@@ -4102,10 +1773,10 @@ function initTrackingPool() {
       afterDOMContentLoaded(function() {
         var overlayElements = document.querySelectorAll(poolConfig.overlayQuerySelector);
         if (!overlayElements) {
-          var msg3 = "No elems found for:" + poolConfig.overlayQuerySelector;
-          warning(msg3);
+          var msg2 = "No elems found for:" + poolConfig.overlayQuerySelector;
+          warning(msg2);
           if (poolConfig.initCallback) {
-            poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg: msg3 });
+            poolConfig.initCallback({ status: NUMBER_POOL_ERROR, msg: msg2 });
           }
           return;
         }
@@ -4120,8 +1791,8 @@ function initTrackingPool() {
               contextCallback: poolConfig.contextCallback
             });
           } catch (e2) {
-            var msg4 = "error on interval: " + JSON.stringify(e2);
-            warning(msg4);
+            var msg3 = "error on interval: " + JSON.stringify(e2);
+            warning(msg3);
           }
         }, poolConfig.renewalInterval || NUMBER_POOL_RENEWAL_TIME_MS);
         poolIntervals[poolData.pool_id] = interval;
@@ -4138,12 +1809,12 @@ function zar({ apiUrl, poolConfig }) {
   return {
     name: "zar",
     config: { apiUrl, poolConfig },
-    initialize: function({ config: config2 }) {
+    initialize: function({ config }) {
     },
     loaded: function() {
       return true;
     },
-    pageStart: function({ payload, config: config2, instance }) {
+    pageStart: function({ payload, config, instance }) {
       payload.properties.zar = getStorage();
       payload.properties.referrer = document.referrer;
       payload.properties.is_bot = isBot();
@@ -4157,7 +1828,7 @@ function zar({ apiUrl, poolConfig }) {
         delete payload.properties["search"];
       }
       try {
-        var pcfg = config2.poolConfig;
+        var pcfg = config.poolConfig;
         if (pcfg && pcfg.poolId) {
           payload.properties.pool_id = getPoolId(pcfg.poolId);
           if (pcfg.contextCallback) {
@@ -4170,14 +1841,14 @@ function zar({ apiUrl, poolConfig }) {
       return payload;
     },
     page: function(_0) {
-      return __async(this, arguments, function* ({ payload, options, instance, config: config2 }) {
-        dbg("page", payload, options, config2);
+      return __async(this, arguments, function* ({ payload, options, instance, config }) {
+        dbg("page", payload, options, config);
         var tries = 0;
         var maxTries = 3;
         var res;
         while (tries < maxTries) {
           try {
-            res = yield httpPost({ url: `${config2.apiUrl}/page`, data: payload });
+            res = yield httpPost({ url: `${config.apiUrl}/page`, data: payload });
             break;
           } catch (e2) {
             tries++;
@@ -4189,19 +1860,19 @@ function zar({ apiUrl, poolConfig }) {
           }
         }
         if (res && res.pool_data) {
-          initTrackingPool({ poolData: res.pool_data, poolConfig: config2.poolConfig, apiUrl: config2.apiUrl });
+          initTrackingPool({ poolData: res.pool_data, poolConfig: config.poolConfig, apiUrl: config.apiUrl });
         }
       });
     },
-    trackStart: function({ payload, config: config2, instance }) {
+    trackStart: function({ payload, config, instance }) {
       payload.properties.zar = getStorage();
       payload.properties.url = window.location.href;
       payload.properties.referrer = document.referrer;
       return payload;
     },
-    track: function({ payload, options, instance, config: config2 }) {
+    track: function({ payload, options, instance, config }) {
       dbg("track", payload);
-      httpPost({ url: `${config2.apiUrl}/track`, data: payload, beacon: true });
+      httpPost({ url: `${config.apiUrl}/track`, data: payload, beacon: true });
     },
     methods: {
       apiUrl() {
@@ -4265,7 +1936,7 @@ function zar({ apiUrl, poolConfig }) {
     }
   };
 }
-function init({ app, gtmConfig = null, ga4Config = null, apiUrl = null, poolConfig = null }) {
+function init({ app, ga4Config = null, facebookConfig = null, apiUrl = null, poolConfig = null }) {
   if (!apiUrl) {
     apiUrl = getDefaultApiUrl();
   }
@@ -4273,8 +1944,8 @@ function init({ app, gtmConfig = null, ga4Config = null, apiUrl = null, poolConf
   if (ga4Config) {
     plugins.push(googleAnalytics4(ga4Config));
   }
-  if (gtmConfig) {
-    plugins.push(index(gtmConfig));
+  if (facebookConfig) {
+    plugins.push(facebook(facebookConfig));
   }
   return analyticsLib({ app, plugins });
 }