zar 0.0.21 → 0.0.24

package/dist/zar.es.js

@@ -0,0 +1,4301 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e2) {
+        reject(e2);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e2) {
+        reject(e2);
+      }
+    };
+    var step = (x2) => x2.done ? resolve(x2.value) : Promise.resolve(x2.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function dotProp(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;
+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) {
+  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);
+}
+function R$4(n2, t2) {
+  t2 === void 0 && (t2 = true);
+  var e2 = J$4(n2);
+  return t2 ? H$5(e2) : e2;
+}
+function V$4(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) {
+  return n2 === null;
+}
+function nn$4(n2) {
+  return R$4(n2) === "number" && !isNaN(n2);
+}
+function yn$4(n2) {
+  return W$4(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 On$4(n2, t2) {
+  if (typeof t2 != "object" || Y$4(t2))
+    return false;
+  if (t2 instanceof n2)
+    return true;
+  var e2 = R$4(new n2(""));
+  if (hn$4(t2))
+    for (; t2; ) {
+      if (R$4(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) {
+  var e2 = n2 instanceof Element || n2 instanceof HTMLDocument;
+  return e2 && t2 ? Tn$4(n2, t2) : e2;
+}
+function Tn$4(n2, t2) {
+  return t2 === void 0 && (t2 = ""), n2 && n2.nodeName === t2.toUpperCase();
+}
+function _n$4(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$6(e2) {
+  try {
+    return decodeURIComponent(e2.replace(/\+/g, " "));
+  } catch (e3) {
+    return null;
+  }
+}
+function o$9() {
+  if ($$5) {
+    var r2 = navigator, t2 = r2.languages;
+    return r2.userLanguage || (t2 && t2.length ? t2[0] : r2.language);
+  }
+}
+function a$5() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch (e2) {
+  }
+}
+function s(r2) {
+  return function(e2) {
+    for (var r3, t2 = /* @__PURE__ */ Object.create(null), o2 = /([^&=]+)=?([^&]*)/g; r3 = o2.exec(e2); ) {
+      var a2 = n$6(r3[1]), i = n$6(r3[2]);
+      a2.substring(a2.length - 2) === "[]" ? (t2[a2 = a2.substring(0, a2.length - 2)] || (t2[a2] = [])).push(i) : t2[a2] = i === "" || i;
+    }
+    for (var u2 in t2) {
+      var c2 = u2.split("[");
+      c2.length > 1 && (m(t2, c2.map(function(e3) {
+        return e3.replace(/[?[\]\\ ]/g, "");
+      }), t2[u2]), delete t2[u2]);
+    }
+    return t2;
+  }(function(r3) {
+    if (r3) {
+      var t2 = r3.match(/\?(.*)/);
+      return t2 && t2[1] ? t2[1].split("#")[0] : "";
+    }
+    return $$5 && window.location.search.substring(1);
+  }(r2));
+}
+function m(e2, r2, t2) {
+  for (var n2 = r2.length - 1, o2 = 0; o2 < n2; ++o2) {
+    var a2 = r2[o2];
+    if (a2 === "__proto__" || a2 === "constructor")
+      break;
+    a2 in e2 || (e2[a2] = {}), e2 = e2[a2];
+  }
+  e2[r2[n2]] = t2;
+}
+function y$1() {
+  for (var e2 = "", r2 = 0, t2 = 4294967295 * Math.random() | 0; r2++ < 36; ) {
+    var n2 = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"[r2 - 1], o2 = 15 & t2;
+    e2 += n2 == "-" || n2 == "4" ? n2 : (n2 == "x" ? o2 : 3 & o2 | 8).toString(16), t2 = r2 % 8 == 0 ? 4294967295 * Math.random() | 0 : t2 >> 4;
+  }
+  return e2;
+}
+var o$8 = "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);
+}
+function R$3(n2, t2) {
+  t2 === void 0 && (t2 = true);
+  var e2 = J$3(n2);
+  return t2 ? H$4(e2) : e2;
+}
+function V$3(n2, t2) {
+  return typeof t2 === n2;
+}
+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 nn$3(n2) {
+  return R$3(n2) === "number" && !isNaN(n2);
+}
+function yn$3(n2) {
+  return W$3(n2.constructor) ? n2.constructor.name : null;
+}
+function hn$3(n2) {
+  return n2 instanceof Error || q$3(n2.message) && n2.constructor && nn$3(n2.constructor.stackTraceLimit);
+}
+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);
+    }
+  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 _n$3(n2) {
+  var t2 = [].slice.call(arguments, 1);
+  return function() {
+    return n2.apply(void 0, [].slice.call(arguments).concat(t2));
+  };
+}
+_n$3($n$3, "form");
+_n$3($n$3, "button");
+_n$3($n$3, "input");
+_n$3($n$3, "select");
+var o$7 = j$3 + "global" + j$3, n$5 = typeof self === o$8 && self.self === self && self || typeof global === o$8 && global.global === global && global || void 0;
+function a$4(t2) {
+  return n$5[o$7][t2];
+}
+function f$5(t2, e2) {
+  return n$5[o$7][t2] = e2;
+}
+function i$5(t2) {
+  delete n$5[o$7][t2];
+}
+n$5[o$7] || (n$5[o$7] = {});
+var n$4, f$4 = "any", l$2 = "*", p = "__", h$1 = typeof process != "undefined" ? process : {};
+((n$4 = h$1.env) == null ? void 0 : n$4.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 _ = 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 H$3(n2) {
+  return n2 && (typeof n2 == "object" || n2 !== null);
+}
+function M$3(n2) {
+  if (!H$3(n2))
+    return false;
+  for (var e2 = n2; Object.getPrototypeOf(e2) !== null; )
+    e2 = Object.getPrototypeOf(e2);
+  return Object.getPrototypeOf(n2) === e2;
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr))
+    return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+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 _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 _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function() {
+    var 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);
+    });
+  };
+}
+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;
+  }
+  return obj;
+}
+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);
+  }
+  return keys;
+}
+function _objectSpread2$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    i % 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));
+    });
+  }
+  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];
+    }
+    try {
+      define({}, "");
+    } catch (err) {
+      define = function(obj, key, value) {
+        return obj[key] = value;
+      };
+    }
+    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;
+    }
+    exports.wrap = wrap;
+    function tryCatch(fn, obj, arg) {
+      try {
+        return {
+          type: "normal",
+          arg: fn.call(obj, arg)
+        };
+      } catch (err) {
+        return {
+          type: "throw",
+          arg: err
+        };
+      }
+    }
+    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);
+        });
+      });
+    }
+    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
+      };
+    };
+    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 i = -1, next = function next2() {
+            while (++i < iterable.length) {
+              if (hasOwn.call(iterable, i)) {
+                next2.value = iterable[i];
+                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 i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          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 i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+            var finallyEntry = entry;
+            break;
+          }
+        }
+        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 i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.finallyLoc === finallyLoc) {
+            this.complete(entry.completion, entry.afterLoc);
+            resetTryEntry(entry);
+            return ContinueSentinel;
+          }
+        }
+      },
+      "catch": function(tryLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc === tryLoc) {
+            var record = entry.completion;
+            if (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 i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      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 i = 0; i < reducerKeys.length; i++) {
+    var key = reducerKeys[i];
+    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$5(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(i) {
+        var processAction = queue.actions[i];
+        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, i) {
+  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 (i && _arr.length === i)
+        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, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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, i) {
+                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, i) {
+                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 === i + 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 i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _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 i = 0, tag; tag = tags[i]; i++) {
+    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$9();
+  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$5(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$5[o$7][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 i = 0; i < args.length; i++) {
+    if (_(args[i])) {
+      cb = args[i];
+      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$5,
+    removeItem: i$5
+  };
+  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$5(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);
+      };
+    };
+  };
+  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);
+    };
+  }
+  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]);
+    };
+  }
+  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];
+  });
+  var disabledPlugins = pluginKeys.filter(function(name) {
+    return !parsedOptions.pluginEnabled[name];
+  });
+  store.dispatch({
+    type: EVENTS$1.registerPlugins,
+    plugins: pluginKeys,
+    enabled: parsedOptions.pluginEnabled
+  });
+  parsedOptions.pluginsArray.map(function(plugin, i) {
+    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 === i + 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 i = 0; i < args.length; i++) {
+        newArgs[i] = args[i];
+      }
+      newArgs[newArgs.length] = instance;
+      return fn.apply({
+        instance
+      }, newArgs);
+    };
+  }
+  return instance;
+}
+var before = "before";
+var after = "after";
+var o$6 = "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$1 = "global", o$5 = j$2 + "global" + j$2, n$3 = typeof self === o$6 && self.self === self && self || typeof global === o$6 && global.global === global && global || void 0;
+function a$3(t2) {
+  return n$3[o$5][t2];
+}
+function f$3(t2, e2) {
+  return n$3[o$5][t2] = e2;
+}
+function i$4(t2) {
+  delete n$3[o$5][t2];
+}
+n$3[o$5] || (n$3[o$5] = {});
+var o$4 = "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$3 = j$1 + "global" + j$1, n$2 = typeof self === o$4 && self.self === self && self || typeof global === o$4 && global.global === global && global || void 0;
+function a$2(t2) {
+  return n$2[o$3][t2];
+}
+function f$2(t2, e2) {
+  return n$2[o$3][t2] = e2;
+}
+function i$3(t2) {
+  delete n$2[o$3][t2];
+}
+n$2[o$3] || (n$2[o$3] = {});
+var t = "cookie", i$2 = a$1(), r$1 = d$1, c$1 = d$1;
+function u$1(o2) {
+  return i$2 ? d$1(o2, "", -1) : i$3(o2);
+}
+function a$1() {
+  if (i$2 !== void 0)
+    return i$2;
+  var e2 = "cookiecookie";
+  try {
+    d$1(e2, e2), i$2 = document.cookie.indexOf(e2) !== -1, u$1(e2);
+  } catch (e3) {
+    i$2 = false;
+  }
+  return i$2;
+}
+function d$1(e2, t2, r2, c2, u2, a2) {
+  if (typeof window != "undefined") {
+    var d2 = arguments.length > 1;
+    return i$2 === false && (d2 ? f$2(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$1 = "undefined", o$2 = "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$1 = j + "global" + j, n$1 = typeof self === o$2 && self.self === self && self || typeof global === o$2 && global.global === global && global || void 0;
+function a(t2) {
+  return n$1[o$1][t2];
+}
+function f$1(t2, e2) {
+  return n$1[o$1][t2] = e2;
+}
+function i$1(t2) {
+  delete n$1[o$1][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$1[o$1] || (n$1[o$1] = {});
+var c = {};
+function b$1(t2) {
+  if (typeof c[t2] !== e$1)
+    return c[t2];
+  try {
+    var e2 = window[t2];
+    e2.setItem(e$1, e$1), e2.removeItem(e$1);
+  } catch (e3) {
+    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$1);
+u("localStorage", "removeItem", i$1);
+function y(t2) {
+  var o2 = t2;
+  try {
+    if ((o2 = JSON.parse(t2)) === "true")
+      return true;
+    if (o2 === "false")
+      return false;
+    if (M$3(o2))
+      return o2;
+    parseFloat(o2) === o2 && (o2 = parseFloat(o2));
+  } catch (t3) {
+  }
+  if (o2 !== null && o2 !== "")
+    return o2;
+}
+var S = g(), k = a$1();
+function I(o2, r2) {
+  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;
+    if (a2 && n2)
+      return n2;
+    var u2 = a$3(o2);
+    return a2 ? u2 : { localStorage: 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$1] = h(l$1, a2, a$3(e2)), f$3(e2, a2), m2 ? c2[l$1] : c2);
+  }
+}
+function C(t$1, r$12) {
+  if (t$1) {
+    var a2 = L(r$12), i = I(t$1, l$2), n2 = {};
+    return !$$3(i.localStorage) && O(a2) && (localStorage.removeItem(t$1), n2[r] = i.localStorage), !$$3(i.cookie) && b(a2) && (u$1(t$1), n2[t] = i.cookie), !$$3(i.global) && d(a2, l$1) && (i$4(t$1), n2[l$1] = i.global), n2;
+  }
+}
+function L(t2) {
+  return t2 ? L$1(t2) ? t2 : t2.storage : f$4;
+}
+function O(t2) {
+  return S && d(t2, r);
+}
+function b(t$1) {
+  return k && d(t$1, t);
+}
+function A(t2) {
+  return t2 === l$2 || t2 === "all";
+}
+function d(t2, o2) {
+  return t2 === f$4 || t2 === o2 || A(t2);
+}
+function h(t2, o2, r2) {
+  return { location: t2, current: o2, previous: r2 };
+}
+var N = { setItem: x, getItem: I, removeItem: C };
+var storage = N;
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    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);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 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));
+      });
+    }
+  }
+  return target;
+}
+var objectSpread2 = _objectSpread2;
+function analyticsLib() {
+  var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var defaultSettings = {
+    storage
+  };
+  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 i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    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;
+}
+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] : {};
+  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, i) {
+          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=") + i + dl + p2;
+          f2.parentNode.insertBefore(j2, f2);
+        })(window, document, "script", dataLayerName, containerId);
+        initializedDataLayerName = dataLayerName;
+        config2.dataLayer = window[dataLayerName];
+      }
+    },
+    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);
+      }
+    },
+    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));
+      }
+    },
+    loaded: function loaded() {
+      var hasDataLayer = !!initializedDataLayerName && !!(window[initializedDataLayerName] && Array.prototype.push !== window[initializedDataLayerName].push);
+      return scriptLoaded(pluginConfig.containerId) && hasDataLayer;
+    }
+  };
+}
+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);
+}
+window.gtag = gtag;
+function gtagInit({ trackingId, configParams = {}, setParams = {} }) {
+  var scriptId = "ga-gtag";
+  if (document.getElementById(scriptId))
+    return;
+  var head = document.head;
+  var script = document.createElement("script");
+  script.id = scriptId;
+  script.type = "text/javascript";
+  script.async = true;
+  script.src = "https://www.googletagmanager.com/gtag/js?id=" + trackingId;
+  head.insertBefore(script, head.firstChild);
+  window.dataLayer = window.dataLayer || [];
+  gtag("js", new Date());
+  if (setParams) {
+    gtag("set", setParams);
+  }
+  gtag("config", trackingId, configParams);
+}
+function googleAnalytics4(pluginConfig = {}) {
+  return {
+    name: "google-analytics-4",
+    config: pluginConfig,
+    initialize: function({ config: config2, instance }) {
+      if (!config2.trackingId)
+        throw new Error("No GA trackingId defined");
+      var configParams = {};
+      var setParams = {};
+      if (config2.customDimensions) {
+        var customMap = {};
+        for (var i = 0; i < config2.customDimensions.length; i++) {
+          var customDim = config2.customDimensions[i];
+          configParams[customDim.name] = customDim.callback(instance, config2);
+          customMap["dimension" + (i + 1)] = customDim.name;
+        }
+        setParams["custom_map"] = customMap;
+      }
+      gtagInit({ trackingId: config2.trackingId, configParams, setParams });
+    },
+    page: function({ payload, config: config2, instance }) {
+    },
+    track: function({ payload, config: config2, instance }) {
+      gtag("event", payload.event, payload.properties);
+    },
+    identify: function({ payload, config: config2 }) {
+    },
+    loaded: function() {
+      return !!window.gtag;
+    }
+  };
+}
+var l = typeof self == "object" && self.self === self && self || typeof global == "object" && global.global === global && global || void 0, e = "undefined";
+function o(e2) {
+  return l[e2];
+}
+function f(e2, o2) {
+  return l[e2] = o2, o2;
+}
+function n(l2) {
+  f(l2);
+}
+var urlParams = new URLSearchParams(window.location.search);
+var DEBUG = urlParams.get("zdbg");
+function dbg() {
+  if (DEBUG != 1)
+    return;
+  console.debug(...arguments);
+}
+function rbWarning(msg2) {
+  if (window.Rollbar) {
+    window.Rollbar.warning(msg2);
+  }
+}
+var supportsSessionStorage = hasSessionStorage();
+function hasSessionStorage() {
+  if (typeof supportsSessionStorage !== e) {
+    return supportsSessionStorage;
+  }
+  supportsSessionStorage = true;
+  try {
+    sessionStorage.setItem(e, e);
+    sessionStorage.removeItem(e);
+  } catch (e2) {
+    supportsSessionStorage = false;
+  }
+  return supportsSessionStorage;
+}
+function getSessionStorage(key) {
+  var value;
+  var globalValue = o(key) || void 0;
+  if (supportsSessionStorage) {
+    value = sessionStorage.getItem(key);
+    if (!value && globalValue) {
+      value = globalValue;
+      sessionStorage.setItem(key, value);
+    }
+  } else {
+    value = globalValue;
+  }
+  return value ? JSON.parse(value) : void 0;
+}
+function setSessionStorage(key, value) {
+  var value_str = JSON.stringify(value);
+  if (supportsSessionStorage) {
+    sessionStorage.setItem(key, value_str);
+  }
+  f(key, value_str);
+}
+function removeSessionStorage(key) {
+  if (supportsSessionStorage) {
+    sessionStorage.removeItem(key);
+  }
+  n(key);
+}
+var lut = [];
+for (var i = 0; i < 256; i++) {
+  lut[i] = (i < 16 ? "0" : "") + i.toString(16);
+}
+function uuid() {
+  var d0 = Math.random() * 4294967296 >>> 0;
+  var d1 = Math.random() * 4294967296 >>> 0;
+  var d2 = Math.random() * 4294967296 >>> 0;
+  var d3 = Math.random() * 4294967296 >>> 0;
+  return lut[d0 & 255] + lut[d0 >> 8 & 255] + lut[d0 >> 16 & 255] + lut[d0 >> 24 & 255] + "-" + lut[d1 & 255] + lut[d1 >> 8 & 255] + "-" + lut[d1 >> 16 & 15 | 64] + lut[d1 >> 24 & 255] + "-" + lut[d2 & 63 | 128] + lut[d2 >> 8 & 255] + "-" + lut[d2 >> 16 & 255] + lut[d2 >> 24 & 255] + lut[d3 & 255] + lut[d3 >> 8 & 255] + lut[d3 >> 16 & 255] + lut[d3 >> 24 & 255];
+}
+var inBrowser = typeof document !== "undefined";
+function hasAdBlock() {
+  if (!inBrowser)
+    return false;
+  var fakeAd = document.createElement("div");
+  fakeAd.innerHTML = "&nbsp;";
+  fakeAd.className = "pub_300x250 pub_300x250m pub_728x90 text-ad textAd text_ad text_ads text-ads text-ad-links";
+  fakeAd.setAttribute("style", "width: 1px !important; height: 1px !important; position: absolute !important; left: -10000px !important; top: -1000px !important;");
+  try {
+    document.body.appendChild(fakeAd);
+    if (document.body.getAttribute("abp") !== null || fakeAd.offsetHeight === 0 || fakeAd.clientHeight === 0) {
+      return true;
+    }
+    if (typeof getComputedStyle !== "undefined") {
+      var css = window.getComputedStyle(fakeAd, null);
+      if (css && (css.getPropertyValue("display") === "none" || css.getPropertyValue("visibility") === "hidden")) {
+        return true;
+      }
+    }
+    document.body.removeChild(fakeAd);
+  } catch (e2) {
+  }
+  return false;
+}
+function makeRequest({ method, url, data, json = true }) {
+  return new Promise(function(resolve, reject) {
+    var xhr = new XMLHttpRequest();
+    xhr.open(method, url);
+    xhr.withCredentials = true;
+    if (json) {
+      xhr.setRequestHeader("Accept", "application/json");
+      xhr.setRequestHeader("Content-Type", "application/json");
+    }
+    xhr.onload = function() {
+      if (this.status >= 200 && this.status < 300) {
+        if (json) {
+          resolve(JSON.parse(xhr.response));
+        } else {
+          resolve(xhr.response);
+        }
+      } else {
+        reject({
+          status: this.status,
+          message: xhr.statusText
+        });
+      }
+    };
+    xhr.onerror = function() {
+      reject({
+        status: this.status,
+        message: "Network Error"
+      });
+    };
+    if (data) {
+      xhr.send(data);
+    } else {
+      xhr.send();
+    }
+  });
+}
+function formatParams(params) {
+  return "?" + Object.keys(params).map(function(key) {
+    return key + "=" + encodeURIComponent(params[key]);
+  }).join("&");
+}
+function postBeacon(_0) {
+  return __async(this, arguments, function* ({ url, data }) {
+    if (window && window.navigator && typeof window.navigator.sendBeacon === "function" && typeof window.Blob === "function") {
+      try {
+        if (window.navigator.sendBeacon(url, JSON.stringify(data))) {
+          return true;
+        }
+        return false;
+      } catch (e2) {
+        return false;
+      }
+    }
+    return false;
+  });
+}
+function httpGet(_0) {
+  return __async(this, arguments, function* ({ url, params = null, json = true }) {
+    var finalUrl = url;
+    if (params) {
+      finalUrl = finalUrl + formatParams(params);
+    }
+    return yield makeRequest({ method: "GET", url: finalUrl, json });
+  });
+}
+function httpPost(_0) {
+  return __async(this, arguments, function* ({ url, data, json = true, beacon = false }) {
+    var finalData = data;
+    if (json) {
+      finalData = JSON.stringify(finalData);
+    }
+    if (beacon) {
+      var res = yield postBeacon({ url, data });
+      if (res) {
+        return;
+      }
+      dbg("Beacon failed");
+    }
+    return yield makeRequest({ method: "POST", url, data: finalData, json });
+  });
+}
+var CID_KEY = "__zar_cid";
+var SID_KEY = "__zar_sid";
+var VID_KEY = "__zar_vid";
+var NUMBER_POOL_KEY = "__zar_pool";
+var NUMBER_POOL_SUCCESS = "success";
+var NUMBER_POOL_ERROR = "error";
+var NUMBER_POOL_RENEWAL_TIME_MS = 30 * 1e3;
+var POOL_DEFAULT_URL_FLAG = "pl";
+var DAY_TTL = 1e3 * 60 * 60 * 24;
+var POOL_STORAGE_TTL = DAY_TTL * 7;
+var numberOverlayMap = /* @__PURE__ */ new Map();
+function generateClientId() {
+  return uuid();
+}
+function generateSessionId() {
+  return uuid();
+}
+function generateVisitId() {
+  return Date.now().toString(36) + "." + Math.random().toString(36).substring(2);
+}
+function initId(key, generator, getter, setter) {
+  var id;
+  var isNew = false;
+  var origReferrer = null;
+  var idObj = getter(key);
+  if (!idObj || !idObj.id) {
+    id = generator();
+    origReferrer = document.referrer;
+    isNew = true;
+    dbg("Generated ID for", key, "-", id);
+  } else {
+    id = idObj.id;
+    origReferrer = idObj.origReferrer;
+  }
+  var result = { id, t: Date.now(), origReferrer, isNew };
+  setter(key, result);
+  return result;
+}
+function initIds() {
+  var vidResult = initId(VID_KEY, generateVisitId, getSessionStorage, setSessionStorage);
+  var sidResult = initId(SID_KEY, generateSessionId, getSessionStorage, setSessionStorage);
+  var cidResult = initId(CID_KEY, generateClientId, getSessionStorage, setSessionStorage);
+  return { cid: cidResult.id, sid: sidResult.id, vid: vidResult.id };
+}
+function getDefaultApiUrl() {
+  return window.location.host + "/api/v1";
+}
+function getIDObj(key) {
+  return getSessionStorage(key);
+}
+function getID(key) {
+  var obj = getIDObj(key);
+  return obj ? obj.id : null;
+}
+function getStorage() {
+  return {
+    cid: getIDObj(CID_KEY),
+    sid: getIDObj(SID_KEY),
+    vid: getIDObj(VID_KEY)
+  };
+}
+function getIds() {
+  return {
+    cid: getID(CID_KEY),
+    sid: getID(SID_KEY),
+    vid: getID(VID_KEY)
+  };
+}
+function updateID(key, val) {
+  var obj = getIDObj(key);
+  if (!obj) {
+    console.warn("could not update " + key);
+    return;
+  }
+  obj.id = val;
+  setSessionStorage(key, obj);
+}
+function removeID(key) {
+  removeSessionStorage(key);
+}
+function removeIds() {
+  removeID(VID_KEY);
+  removeID(SID_KEY);
+  removeID(CID_KEY);
+}
+function getPoolNumber(_0) {
+  return __async(this, arguments, function* ({ poolId, apiUrl, number = null, context: context2 = null }) {
+    var payload = {
+      pool_id: poolId,
+      number,
+      context: context2,
+      properties: {
+        zar: getStorage()
+      }
+    };
+    var resp = yield httpPost({ url: `${apiUrl}/number_pool`, data: payload });
+    return resp;
+  });
+}
+function getPoolStats(_0) {
+  return __async(this, arguments, function* ({ apiUrl, key = null, with_contexts = false }) {
+    var params = {
+      key,
+      with_contexts
+    };
+    var resp = yield httpGet({ url: `${apiUrl}/number_pool_stats`, params });
+    return resp;
+  });
+}
+function extractPhoneNumber({ elem }) {
+  var numberText = null;
+  var number = null;
+  var href = null;
+  var regex = new RegExp("\\+?\\(?\\d*\\)? ?\\(?\\d+\\)?\\d*([\\s./-]?\\d{2,})+", "g");
+  if (elem.href && elem.href.startsWith("tel:")) {
+    href = elem.href;
+  }
+  var text = elem.innerText;
+  var html = elem.innerHTML;
+  var match = regex.exec(text);
+  if (match) {
+    numberText = match[0].trim();
+    number = numberText.replace("+", "").replace(/-/g, "").replace(/ /g, "").replace("(", "").replace(")", "").replace(/^1/, "");
+  }
+  return { text, html, numberText, href, number };
+}
+function overlayPhoneNumber({ elems, number }) {
+  var origNum;
+  var overlayNum = number;
+  if (!number.startsWith("+1")) {
+    overlayNum = "+1" + number;
+  }
+  for (var i = 0; i < elems.length; i++) {
+    if (numberOverlayMap.has(elems[i])) {
+      dbg("pool: skipping element already in overlay map:", elems[i]);
+      continue;
+    }
+    var elemNum = extractPhoneNumber({ elem: elems[i] });
+    if (!origNum) {
+      origNum = elemNum;
+    } else if (elemNum.number && origNum.number && origNum.number !== elemNum.number) {
+      console.warn("pool: overlaying multiple phone numbers with a single number!", origNum.number, elemNum.number);
+    }
+    dbg("pool: overlaying number", overlayNum, "on", elems[i]);
+    numberOverlayMap.set(elems[i], elemNum);
+    if (elemNum.href) {
+      elems[i].href = "tel:" + overlayNum;
+    }
+    if (elemNum.numberText) {
+      elems[i].innerHTML = "";
+      if (elemNum.text) {
+        var overlay = overlayNum;
+        if (elemNum.numberText.indexOf("-") > -1) {
+          overlay = overlayNum.slice(2, 5) + "-" + overlayNum.slice(5, 8) + "-" + overlayNum.slice(8, 12);
+        }
+        if (elemNum.html.indexOf("<img") > -1) {
+          var numberHtml = elemNum.html.replace(elemNum.numberText, overlay);
+          elems[i].innerHTML = numberHtml;
+        } else {
+          var numberText = elemNum.text.replace(elemNum.numberText, overlay);
+          elems[i].appendChild(document.createTextNode(numberText));
+        }
+      } else {
+        elems[i].appendChild(document.createTextNode(overlayNum));
+      }
+    } else {
+      dbg("pool: no number text found on", elems[i]);
+    }
+  }
+}
+function revertOverlayNumbers({ elems }) {
+  for (var i = 0; i < elems.length; i++) {
+    if (numberOverlayMap.has(elems[i])) {
+      var currentHTML = elems[i].innerHTML;
+      var origElemData = numberOverlayMap.get(elems[i]);
+      dbg("orig:", origElemData);
+      var origHTML = origElemData.html;
+      dbg("pool: reverting", currentHTML, "to", origHTML);
+      elems[i].innerHTML = origHTML;
+      if (origElemData.href) {
+        elems[i].href = origElemData.href;
+      }
+      numberOverlayMap.delete(elems[i]);
+    } else {
+      dbg("pool: element not in map:", elems[i]);
+    }
+  }
+}
+function removePoolSession({ overlayElements }) {
+  C(NUMBER_POOL_KEY, l$2);
+  revertOverlayNumbers({ elems: overlayElements });
+}
+function clearPoolIntervals(poolData) {
+  if (!poolData || !poolData.poolNumbers) {
+    return;
+  }
+  for (var poolId in poolData.poolNumbers) {
+    clearInterval(poolData.poolNumbers[poolId].interval);
+  }
+}
+function poolSessionExpired(obj) {
+  if (obj && obj.t && obj.t + POOL_STORAGE_TTL < Date.now()) {
+    return true;
+  }
+  return false;
+}
+function getPoolSession() {
+  return I(NUMBER_POOL_KEY);
+}
+function initTrackingPool() {
+  return __async(this, arguments, function* ({
+    poolId,
+    overlayElements,
+    apiUrl = getDefaultApiUrl(),
+    urlParam = POOL_DEFAULT_URL_FLAG,
+    renew = true,
+    renewalInterval = NUMBER_POOL_RENEWAL_TIME_MS,
+    callback = null
+  } = {}) {
+    var poolEnabled = false;
+    var seshData = getPoolSession();
+    var expired = poolSessionExpired(seshData);
+    if (!expired) {
+      if (seshData && seshData.poolEnabled) {
+        poolEnabled = true;
+      } else {
+        if (urlParams.get(urlParam) === "1") {
+          poolEnabled = true;
+        }
+      }
+    } else {
+      clearPoolIntervals(seshData);
+      removePoolSession({ overlayElements });
+    }
+    if (!poolEnabled) {
+      dbg("pool: not enabled");
+      if (callback) {
+        callback(null);
+      }
+      return null;
+    }
+    var seshNumber = null;
+    var seshInterval = null;
+    if (seshData && seshData.poolNumbers && seshData.poolNumbers[poolId]) {
+      var poolResult = seshData.poolNumbers[poolId];
+      seshInterval = poolResult.interval;
+      if (poolResult.status !== NUMBER_POOL_SUCCESS) {
+        dbg("pool: returning cached unsuccessful pool result: " + JSON.stringify(poolResult));
+        if (callback) {
+          callback(poolResult);
+        }
+        return poolResult;
+      }
+      if (poolResult.number) {
+        seshNumber = poolResult.number;
+        dbg("pool: found session number " + seshNumber);
+      }
+    }
+    var resp = {};
+    try {
+      resp = yield getPoolNumber({ poolId, apiUrl, number: seshNumber, context: {} });
+    } catch (e2) {
+      var msg2 = "pool: error getting number: " + JSON.stringify(e2);
+      rbWarning(msg2);
+      console.warn(msg2);
+      var errorRes = { status: NUMBER_POOL_ERROR, msg: e2.message, interval: seshInterval };
+      if (callback) {
+        callback(errorRes);
+      }
+      return errorRes;
+    }
+    if (resp.status === NUMBER_POOL_SUCCESS && resp.number) {
+      if (overlayElements) {
+        overlayPhoneNumber({ elems: overlayElements, number: resp.number });
+      }
+      if (renew) {
+        dbg("pool: setting up renewal");
+        resp.interval = setInterval(function() {
+          try {
+            initTrackingPool({ poolId, overlayElements, apiUrl, urlParam, renew: false });
+          } catch (e2) {
+            var msg3 = "pool: error on interval call: " + JSON.stringify(e2);
+            rbWarning(msg3);
+            console.warn(msg3);
+          }
+        }, renewalInterval);
+      }
+    } else {
+      if (overlayElements) {
+        revertOverlayNumbers({ elems: overlayElements });
+      }
+      if (seshInterval) {
+        clearInterval(seshInterval);
+      }
+      resp.interval = null;
+    }
+    if (seshData) {
+      if (seshData.poolNumbers[poolId]) {
+        Object.assign(seshData.poolNumbers[poolId], resp);
+      } else {
+        seshData.poolNumbers[poolId] = resp;
+      }
+      if (renew) {
+        seshData.t = Date.now();
+      }
+    } else {
+      var poolNumbers = {};
+      poolNumbers[poolId] = resp;
+      seshData = {
+        poolEnabled: true,
+        poolNumbers,
+        t: Date.now()
+      };
+    }
+    x(NUMBER_POOL_KEY, seshData, l$2);
+    dbg("pool: saved session data " + JSON.stringify(seshData));
+    if (callback) {
+      callback(resp);
+    }
+    return resp;
+  });
+}
+function zar({ apiUrl }) {
+  return {
+    name: "zar",
+    config: {
+      apiUrl
+    },
+    initialize: function({ config: config2 }) {
+    },
+    loaded: function() {
+      return true;
+    },
+    pageStart: function({ payload, config: config2, instance }) {
+      payload.properties.zar = getStorage();
+      if ("hash" in payload.properties) {
+        delete payload.properties["hash"];
+      }
+      if ("path" in payload.properties) {
+        delete payload.properties["path"];
+      }
+      if ("search" in payload.properties) {
+        delete payload.properties["search"];
+      }
+      return payload;
+    },
+    trackStart: function({ payload, config: config2, instance }) {
+      payload.properties.zar = getStorage();
+      payload.properties.url = window.location.href;
+      return payload;
+    },
+    page: function(_0) {
+      return __async(this, arguments, function* ({ payload, options, instance, config: config2 }) {
+        dbg("page", payload, options, config2);
+        var result = yield httpPost({ url: `${config2.apiUrl}/page`, data: payload });
+        if (result.sid) {
+          updateID(SID_KEY, result.sid);
+        }
+        if (result.cid) {
+          updateID(CID_KEY, result.cid);
+          instance.setAnonymousId(result.cid);
+        }
+      });
+    },
+    track: function({ payload, options, instance, config: config2 }) {
+      dbg("track", payload);
+      httpPost({ url: `${config2.apiUrl}/track`, data: payload, beacon: true });
+    },
+    reset: function({ instance }) {
+      removeIds();
+    },
+    bootstrap: function({ payload, config: config2, instance }) {
+      var result = initIds();
+      instance.setAnonymousId(result.cid);
+    },
+    methods: {
+      apiUrl() {
+        return apiUrl;
+      },
+      initIds() {
+        var result = initIds();
+        this.instance.setAnonymousId(result.cid);
+        return result;
+      },
+      getIds() {
+        return getIds();
+      },
+      getStorage() {
+        return getStorage();
+      },
+      getCID() {
+        return getID(CID_KEY);
+      },
+      getSID() {
+        return getID(SID_KEY);
+      },
+      getVID() {
+        return getID(VID_KEY);
+      },
+      hasAdBlock() {
+        return hasAdBlock();
+      },
+      initTrackingPool({ poolId, overlayElements, urlParam = POOL_DEFAULT_URL_FLAG, renew = true, renewalInterval = NUMBER_POOL_RENEWAL_TIME_MS, callback = null }) {
+        return initTrackingPool({
+          poolId,
+          overlayElements,
+          apiUrl: this.instance.plugins.zar.apiUrl(),
+          urlParam,
+          renew,
+          renewalInterval,
+          callback
+        });
+      },
+      extractPhoneNumbers({ elems }) {
+        var res = [];
+        for (var i = 0; i < elems.length; i++) {
+          var elemRes = extractPhoneNumber({ elem: elems[i] });
+          res.push(elemRes);
+        }
+        return res;
+      },
+      overlayPhoneNumber({ overlayElements, number }) {
+        overlayPhoneNumber({ elems: overlayElements, number });
+      },
+      revertOverlayNumbers({ overlayElements }) {
+        revertOverlayNumbers({ elems: overlayElements });
+      },
+      removePoolSession({ overlayElements }) {
+        removePoolSession({ overlayElements });
+      },
+      getPoolStats({ key = null, with_contexts = false }) {
+        return getPoolStats({ apiUrl: this.instance.plugins.zar.apiUrl(), key, with_contexts });
+      }
+    }
+  };
+}
+function init({ app, gtmConfig = null, ga4Config = null, apiUrl = null }) {
+  if (!apiUrl) {
+    apiUrl = getDefaultApiUrl();
+  }
+  var plugins = [zar({ apiUrl })];
+  if (ga4Config) {
+    plugins.push(googleAnalytics4(ga4Config));
+  }
+  if (gtmConfig) {
+    plugins.push(index(gtmConfig));
+  }
+  return analyticsLib({ app, plugins });
+}
+export { analyticsLib as Analytics, init, zar };
+//# sourceMappingURL=zar.es.js.map