apxor-qe 1.1.9-qa → 1.1.10-qa.0

package/dist/apxor.qe.js.bak

@@ -0,0 +1,1403 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('apxor')) :
+  typeof define === 'function' && define.amd ? define(['apxor'], factory) :
+  (global = global || self, global['apxor-qe'] = factory(global.Apxor));
+}(this, function (Apxor) { 'use strict';
+
+  Apxor = Apxor && Apxor.hasOwnProperty('default') ? Apxor['default'] : Apxor;
+
+  function ownKeys(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(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+    return target;
+  }
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  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, _toPropertyKey(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 _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+  }
+  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(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+  function _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 _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+
+  /**
+   *
+   * @param term
+   * @returns {boolean}
+   */
+  var isNull = function isNull(term) {
+    return term === null;
+  };
+
+  /**
+   *
+   * @param term
+   * @returns {boolean}
+   */
+  var isDefined = function isDefined(term) {
+    return typeof term !== "undefined" && !isNull(term);
+  };
+  var isFunction = function isFunction(fn) {
+    return typeof fn === "function";
+  };
+  var b64_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  function b64_decode(data) {
+    var o1,
+      o2,
+      o3,
+      h1,
+      h2,
+      h3,
+      h4,
+      bits,
+      i = 0,
+      result = [];
+    if (!data) {
+      return data;
+    }
+    data += "";
+    do {
+      h1 = b64_table.indexOf(data.charAt(i++));
+      h2 = b64_table.indexOf(data.charAt(i++));
+      h3 = b64_table.indexOf(data.charAt(i++));
+      h4 = b64_table.indexOf(data.charAt(i++));
+      bits = h1 << 18 | h2 << 12 | h3 << 6 | h4;
+      o1 = bits >> 16 & 0xff;
+      o2 = bits >> 8 & 0xff;
+      o3 = bits & 0xff;
+      result.push(o1);
+      if (h3 !== 64) {
+        result.push(o2);
+        if (h4 !== 64) {
+          result.push(o3);
+        }
+      }
+    } while (i < data.length);
+    return result;
+  }
+  function keyCharAt(key, i) {
+    return key.charCodeAt(Math.floor(i % key.length));
+  }
+  function xor_decrypt(key, data) {
+    return Array.from(data).map(function (c, i) {
+      return String.fromCharCode(c ^ keyCharAt(key, i));
+    }).join("");
+  }
+  var decode = function decode(key, data) {
+    data = b64_decode(data);
+    return xor_decrypt(key, data);
+  };
+  var generateKey = function generateKey(key) {
+    switch (key) {
+      case "app_event":
+        return "AE";
+      case "client_event":
+        return "CE";
+      case "activity_time":
+        return "AE";
+      case "activity_event":
+        return "AE";
+    }
+    return "Unknown";
+  };
+  var toUpperCase = function toUpperCase(key) {
+    return key.toUpperCase();
+  };
+  var compare = function compare(actual, expected, operator) {
+    switch (operator) {
+      case "EQ":
+        return actual === expected;
+      case "GT":
+        return actual > expected;
+      case "GTE":
+        return actual >= expected;
+      case "LT":
+        return actual < expected;
+      case "LTE":
+        return actual <= expected;
+      case "NEQ":
+        return actual !== expected;
+      case "R":
+        var regex = regExpFromString(expected);
+        return regex.test(actual);
+      default:
+        return false;
+    }
+  };
+  var regExpFromString = function regExpFromString(input) {
+    var flags = input.replace(/.*\/([gimuy]*)$/, "$1");
+    if (flags === input) flags = "";
+    var pattern = flags ? input.replace(new RegExp("^/(.*?)/" + flags + "$"), "$1") : input;
+    return new RegExp(pattern, flags);
+  };
+
+  /**
+   * @function getDateInDDMMYYYY
+   * @description Returns the current date in DD/MM/YYYY Format
+   * @returns {string}
+   */
+  var getDateInDDMMYYYY = function getDateInDDMMYYYY() {
+    var currentDate = new Date();
+    var dateDDMMYYYY = currentDate.getDate() + "/" + currentDate.getMonth() + "/" + currentDate.getFullYear();
+    return dateDDMMYYYY;
+  };
+
+  var Logger = window.ApxorLogger;
+  var Audience = /*#__PURE__*/_createClass(function Audience() {
+    var _this = this;
+    _classCallCheck(this, Audience);
+    _defineProperty(this, "jyXB", "ALL");
+    _defineProperty(this, "lZth", []);
+    _defineProperty(this, "iosT", []);
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.jyXB = config.audience.audience_type;
+        _this.lZth = config.audience.attributes.user;
+        _this.iosT = config.audience.attributes.session;
+        if (!Array.isArray(_this.lZth) || !Array.isArray(_this.iosT)) {
+          Logger.error("No attributes");
+          return false;
+        }
+      } catch (error) {
+        Logger.error(error);
+        return false;
+      }
+      return true;
+    });
+    _defineProperty(this, "validate", function (user, session) {
+      var status = true;
+      if (_this.jyXB === "FTU") {
+        status = Apxor.getController().getSessionInfo().is_first_session;
+      }
+      return status && _this.OYnt(user, _this.lZth) && _this.OYnt(session, _this.iosT);
+    });
+    _defineProperty(this, "OYnt", function (attributes, expected) {
+      var length = expected.length;
+      var status = true;
+      try {
+        var _loop = function _loop() {
+          var item = expected[index];
+          if (!attributes[item.name] || status === false) {
+            return {
+              v: false
+            };
+          }
+          var operator = item.operator;
+          var type = item.type;
+          var values = item.value.map(function (value) {
+            if (type === "s") {
+              return value;
+            } else if (type === "l") {
+              return parseInt(value);
+            } else if (type === "f") {
+              return parseFloat(value);
+            }
+          });
+          var loggedValues = [];
+          if (Array.isArray(attributes[item.name])) {
+            loggedValues = attributes[item.name];
+          } else {
+            loggedValues = [attributes[item.name]];
+          }
+          var match = loggedValues.some(function (loggedValue) {
+            return values.some(function (configValue) {
+              return compare(loggedValue, configValue, operator);
+            });
+          });
+          status = status && match;
+        };
+        for (var index = 0; index < length; index++) {
+          var _ret = _loop();
+          if (_typeof(_ret) === "object") return _ret.v;
+        }
+      } catch (error) {
+        Logger.error(error);
+        status = false;
+      }
+      return status;
+    });
+  });
+
+  var Logger$1 = window.ApxorLogger;
+  var Frequency = /*#__PURE__*/_createClass(function Frequency() {
+    var _this = this;
+    _classCallCheck(this, Frequency);
+    _defineProperty(this, "KkoD", 0);
+    _defineProperty(this, "mBSu", 0);
+    _defineProperty(this, "hDCI", "SESSION");
+    _defineProperty(this, "moQB", 0);
+    _defineProperty(this, "PQZP", 0);
+    _defineProperty(this, "xmdK", 0);
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.KkoD = config.frequency.count;
+        _this.xmdK = _this.KkoD;
+        _this.mBSu = config.frequency.time_interval;
+        _this.hDCI = config.frequency.validity;
+        _this.PQZP = config.frequency.ses_lmt;
+        _this._dayCount = config.frequency.day_lmt;
+        // let data = Apxor.getController().getFromStorage(QE_STATE);
+        // let qe_state = JSON.parse(decode(Apxor.getSiteId(), data));
+        var qe_state = CE.getInstance().getQeState();
+        if (!isDefined(qe_state) || !isDefined(qe_state[config._id])) return true;
+        if (_this.hDCI === "SESSION") {
+          _this.KkoD = parseInt(_this.KkoD) - parseInt(qe_state[config._id]["SESSION"]);
+          if (_this.KkoD <= 0) {
+            console.warn("Max count limit reached for session:" + config._id);
+            return false;
+          }
+        } else if (_this.hDCI === "OVERALL") {
+          _this.KkoD = parseInt(_this.KkoD) - parseInt(qe_state[config._id]["OVERALL"]);
+          if (_this.KkoD <= 0) {
+            console.warn("Max count limit reached for overall:" + config._id);
+            return false;
+          }
+        } else {
+          Logger$1.info("Invalid config.");
+          return false;
+        }
+      } catch (error) {
+        Logger$1.error(error);
+        return false;
+      }
+      return true;
+    });
+    _defineProperty(this, "lSfk", function () {
+      _this.KkoD = _this.KkoD - 1;
+    });
+    _defineProperty(this, "getFrequencyCount", function () {
+      return _this.KkoD;
+    });
+    _defineProperty(this, "REfq", function () {
+      if (_this.hDCI === "SESSION") {
+        _this.KkoD = _this.xmdK;
+        Logger$1.info("Campaign Limit reset");
+      }
+    });
+    /**
+     * @function JglD
+     * @description Validates if the campaign count is with in the limits set in the config.
+     * @param {string} Config id
+     * @returns {boolean} true - If the Campaign limits are not reached
+     *                    false - Otherwise
+     */
+    _defineProperty(this, "JglD", function (id) {
+      try {
+        if (_this.KkoD <= 0) {
+          return false;
+        }
+
+        // let data = Apxor.getController().getFromStorage(QE_STATE);
+        // let qe_state = JSON.parse(decode(Apxor.getSiteId(), data));
+        var qe_state = CE.getInstance().getQeState();
+        //If the frequency counts are not stored no validity checks are needed.
+        if (!isDefined(qe_state) || !isDefined(qe_state[id])) return true;
+
+        //If the config has a session count limit set
+        if (_this.PQZP !== 0) {
+          var sessionCountInConfig = parseInt(_this.PQZP);
+          var thisSessionCount = parseInt(qe_state[id]["SESSION"]);
+          if (sessionCountInConfig - thisSessionCount <= 0) {
+            return false;
+          }
+        }
+
+        //If the config has a day count limit set
+        if (_this._dayCount !== 0) {
+          var _qe_state$id;
+          var date = getDateInDDMMYYYY();
+          var dayCountInConfig = parseInt(_this._dayCount);
+          var thisDayCount = parseInt(((_qe_state$id = qe_state[id]) === null || _qe_state$id === void 0 ? void 0 : _qe_state$id.DATES[date]) || 0);
+          if (dayCountInConfig - thisDayCount <= 0) {
+            return false;
+          }
+        }
+      } catch (e) {
+        Logger$1.error("Error validating the frequency:" + e);
+      }
+      return true;
+    });
+  });
+
+  var Meta = /*#__PURE__*/_createClass(function Meta() {
+    var _this = this;
+    _classCallCheck(this, Meta);
+    _defineProperty(this, "yaFV", "");
+    _defineProperty(this, "jyXB", "");
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        var _config$meta;
+        _this.yaFV = config.meta.name;
+        _this.jyXB = config.meta.type;
+        _this._only_context = config.meta.only_context;
+        _this._attr = ((_config$meta = config.meta) === null || _config$meta === void 0 ? void 0 : _config$meta.attr) || {};
+      } catch (error) {
+        window.ApxorLogger.error(error);
+        return false;
+      }
+      return true;
+    });
+  });
+
+  var Logger$2 = window.ApxorLogger;
+  var Validity = /*#__PURE__*/_createClass(function Validity() {
+    var _this = this;
+    _classCallCheck(this, Validity);
+    _defineProperty(this, "LKPg", -1);
+    _defineProperty(this, "rbaj", -1);
+    _defineProperty(this, "aRKQ", -1);
+    _defineProperty(this, "kDES", -1);
+    _defineProperty(this, "EGEc", false);
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        if (isNaN(Date.parse(config.validity.start_date)) || isNaN(Date.parse(config.validity.end_date))) {
+          Logger$2.error("Not valid dates");
+          return false;
+        }
+        _this.LKPg = Date.parse(config.validity.start_date);
+        _this.rbaj = Date.parse(config.validity.end_date);
+        if (isDefined(config.time_limits_in_day)) {
+          _this.EGEc = config.time_limits_in_day;
+          if (_this.EGEc && isDefined(config.time_limits)) {
+            var currentDate = new Date().toISOString().split("T")[0];
+            _this.aRKQ = Date.parse(currentDate + "T" + config.time_limits.start_time + ".000Z");
+            _this.kDES = Date.parse(currentDate + "T" + config.time_limits.end_time + ".000Z");
+
+            // If invalid format is passed, return false
+            if (isNaN(_this.aRKQ) || isNaN(_this.kDES)) {
+              Logger$2.error("Not valid times");
+              return false;
+            }
+          }
+        }
+      } catch (error) {
+        Logger$2.error(error);
+        return false;
+      }
+      return true;
+    });
+    _defineProperty(this, "validate", function () {
+      var currentTime = Date.now();
+      if (currentTime > _this.LKPg && currentTime < _this.rbaj) {
+        return !_this.EGEc || currentTime >= _this.aRKQ && currentTime <= _this.kDES;
+      }
+      return false;
+    });
+  });
+
+  var Details = /*#__PURE__*/_createClass(function Details() {
+    var _this = this;
+    _classCallCheck(this, Details);
+    _defineProperty(this, "yaFV", "");
+    _defineProperty(this, "GizD", {});
+    _defineProperty(this, "parse", function () {
+      var details = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.yaFV = details.name;
+        _this.GizD = details.additional_info;
+      } catch (error) {
+        return false;
+      }
+      return true;
+    });
+  });
+
+  var Timebounds = /*#__PURE__*/_createClass(function Timebounds() {
+    var _this = this;
+    _classCallCheck(this, Timebounds);
+    _defineProperty(this, "rrCh", 0);
+    _defineProperty(this, "gDCR", 0);
+    _defineProperty(this, "parse", function () {
+      var timeBounds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.rrCh = Number(timeBounds.lower);
+        _this.gDCR = Number(timeBounds.upper);
+        if (isNaN(_this.rrCh) || isNaN(_this.gDCR)) {
+          return false;
+        }
+      } catch (error) {
+        return false;
+      }
+      return true;
+    });
+  });
+
+  var PreCondition = /*#__PURE__*/_createClass(function PreCondition() {
+    var _this = this;
+    _classCallCheck(this, PreCondition);
+    _defineProperty(this, "kVxJ", 0);
+    _defineProperty(this, "cWDi", "");
+    _defineProperty(this, "uiSd", "");
+    _defineProperty(this, "ebLm", new Details());
+    _defineProperty(this, "aAiV", new Timebounds());
+    _defineProperty(this, "parse", function () {
+      var precondition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.cWDi = precondition.event_type;
+        _this.uiSd = precondition.activity;
+        return _this.ebLm.parse(precondition.details) && _this.aAiV.parse(precondition.time_bounds);
+      } catch (error) {
+        return false;
+      }
+    });
+  });
+
+  var Logger$3 = window.ApxorLogger;
+  var Condition = /*#__PURE__*/_createClass(function Condition() {
+    var _this = this;
+    _classCallCheck(this, Condition);
+    _defineProperty(this, "kVxJ", 0);
+    _defineProperty(this, "svLj", -1);
+    _defineProperty(this, "KkoD", 0);
+    _defineProperty(this, "ZVZY", "");
+    _defineProperty(this, "uiSd", "");
+    _defineProperty(this, "cWDi", "");
+    _defineProperty(this, "aAiV", new Timebounds());
+    _defineProperty(this, "ebLm", new Details());
+    _defineProperty(this, "MgEa", new PreCondition());
+    _defineProperty(this, "bRor", "AND");
+    _defineProperty(this, "EpOC", false);
+    _defineProperty(this, "jyXB", void 0);
+    _defineProperty(this, "parse", function () {
+      var condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.svLj = condition.sequence;
+        _this.KkoD = condition.count_config.count;
+        _this.ZVZY = condition.count_config.operator;
+        _this.uiSd = condition.activity;
+        _this.cWDi = condition.event_type;
+        _this.bRor = condition.combine_operator;
+        _this.jyXB = condition.type;
+        return _this.ebLm.parse(condition.details) && _this.MgEa.parse(condition.trigger) && _this.aAiV.parse(condition.time_bounds);
+      } catch (error) {
+        Logger$3.error(error);
+        return false;
+      }
+    });
+  });
+
+  /* eslint-disable no-unused-vars */
+  var Logger$4 = window.ApxorLogger;
+  var ConditionValidator = /*#__PURE__*/function () {
+    function ConditionValidator() {
+      var _this = this;
+      _classCallCheck(this, ConditionValidator);
+      _defineProperty(this, "yqph", 0);
+      _defineProperty(this, "zNLA", "");
+      _defineProperty(this, "wMtN", new Condition());
+      _defineProperty(this, "NKqT", false);
+      _defineProperty(this, "mJlk", false);
+      _defineProperty(this, "RfKK", 0);
+      _defineProperty(this, "bRor", "AND");
+      _defineProperty(this, "GQSy", -1);
+      _defineProperty(this, "gIUZ", []);
+      _defineProperty(this, "aOME", {});
+      _defineProperty(this, "iqOO", false);
+      /**
+       * If respectSequence is true, don't auto-gINm to events except for the condition whose index is 0
+       *
+       * @param condition
+       * @param type
+       * @param id
+       * @param index
+       * @param respectSequence
+       * @returns {boolean}
+       */
+      _defineProperty(this, "initialize", function () {
+        var condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+        var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+        var respectSequence = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+        var noKpiArray = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+        _this.zNLA = id;
+        _this.RfKK = index;
+        _this.gIUZ = noKpiArray;
+        var result = _this.wMtN.parse(condition);
+        if (result) {
+          _this.bRor = _this.wMtN.bRor;
+
+          // FIXME: Why this code is written? Don't see any usecase
+          if (_this.wMtN.EpOC) {
+            var eventName = _this.wMtN.ebLm.yaFV;
+            if (eventName === "APX_PAGE_OPENED") {
+              eventName = _this.wMtN.ebLm.GizD["navigation_id"];
+              eventName = isDefined(eventName) ? eventName : _this.wMtN.ebLm.yaFV;
+            }
+            _this.GQSy = Apxor.getController().getEventCount(eventName);
+            var count = _this.wMtN.KkoD;
+            var operator = _this.wMtN.ZVZY;
+            _this.mJlk = _this.pqqV(_this.GQSy - 1, count, operator, false);
+            _this.NKqT = _this.mJlk;
+            // If the condition is already satisfied and if it is page view, no need to gINm
+            // This only applies for NAVIGATION_EVENTS
+            if (_this.mJlk && _this.wMtN.ebLm.yaFV === "APX_PAGE_OPENED") {
+              return true;
+            }
+          }
+          if (!respectSequence || index === 0) {
+            _this.gINm();
+          }
+          return true;
+        }
+        return false;
+      });
+      _defineProperty(this, "gINm", function () {
+        var condition = _this.wMtN;
+        var precondition = condition.MgEa;
+        var ceInstance = CE.getInstance();
+        if (precondition.cWDi === "app_start") {
+          _this.NKqT = true;
+          ceInstance.registerForEvent(generateKey(condition.cWDi) + "___" + condition.ebLm.yaFV, _this.SnBK);
+        } else {
+          ceInstance.registerForEvent(generateKey(condition.cWDi) + "___" + precondition.ebLm.yaFV, _this.SnBK);
+        }
+      });
+      _defineProperty(this, "gjCB", function (type, name, time, additionalInfo) {
+        var _this$wMtN, _this$wMtN$_det, _this$wMtN$_det2;
+        var eventTime = Date.now();
+        var time_differnce = (eventTime - _this.aOME[name]) / 1000;
+        var time_fromConfig = ((_this$wMtN = _this.wMtN) === null || _this$wMtN === void 0 ? void 0 : (_this$wMtN$_det = _this$wMtN.ebLm) === null || _this$wMtN$_det === void 0 ? void 0 : (_this$wMtN$_det2 = _this$wMtN$_det.GizD) === null || _this$wMtN$_det2 === void 0 ? void 0 : _this$wMtN$_det2.time) / 1000;
+        if (time_fromConfig > time_differnce) {
+          _this._displayCampaign(time);
+        }
+      });
+      _defineProperty(this, "MhsE", function (type, name, time, additionalInfo) {
+        var _this$_condition2, _this$_condition2$_pr, _this$_condition3, _this$_condition3$_de, _this$_condition3$_de2;
+        _this.iqOO = true;
+        var currentTime = Date.now();
+        var eventName = (_this$_condition2 = _this.wMtN) === null || _this$_condition2 === void 0 ? void 0 : (_this$_condition2$_pr = _this$_condition2.MgEa) === null || _this$_condition2$_pr === void 0 ? void 0 : _this$_condition2$_pr.ebLm.yaFV;
+        var eventTime = _this.aOME[eventName];
+        var time_differnce = (currentTime - eventTime) / 1000;
+        var time_fromConfig = (_this$_condition3 = _this.wMtN) === null || _this$_condition3 === void 0 ? void 0 : (_this$_condition3$_de = _this$_condition3.ebLm) === null || _this$_condition3$_de === void 0 ? void 0 : (_this$_condition3$_de2 = _this$_condition3$_de.GizD) === null || _this$_condition3$_de2 === void 0 ? void 0 : _this$_condition3$_de2.time;
+        time_fromConfig = time_fromConfig / 1000;
+        if (time_fromConfig > time_differnce) {
+          _this._displayCampaign(time);
+        }
+        //unregister the event
+      });
+      _defineProperty(this, "SnBK", function (type, name, time, additionalInfo) {
+        var ceInstance = CE.getInstance();
+        if (!_this.NKqT) {
+          // Validate Precondition
+          _this.NKqT = _this.mTyq(type, name, time, additionalInfo);
+          if (_this.NKqT) {
+            var condition = _this.wMtN;
+            var precondition = condition.MgEa;
+            precondition.kVxJ = time;
+            //events will be registred by its type activity event_type: "activity_time"
+            if ((condition === null || condition === void 0 ? void 0 : condition.cWDi) === "activity_time") {
+              var wMtN$ebLm, wMtN$ebLm$_, wMtN$_details2, wMtN$_details2$, wMtN$_details3, wMtN$_details3$;
+              var event_time = condition === null || condition === void 0 ? void 0 : (wMtN$ebLm = condition.ebLm) === null || wMtN$ebLm === void 0 ? void 0 : (wMtN$ebLm$_ = wMtN$ebLm.GizD) === null || wMtN$ebLm$_ === void 0 ? void 0 : wMtN$ebLm$_.time;
+              if ((condition === null || condition === void 0 ? void 0 : (wMtN$_details2 = condition.ebLm) === null || wMtN$_details2 === void 0 ? void 0 : (wMtN$_details2$ = wMtN$_details2.GizD) === null || wMtN$_details2$ === void 0 ? void 0 : wMtN$_details2$.nkpi.length) > 0) {
+                setTimeout(function () {
+                  if (!_this.iqOO) {
+                    _this.mJlk = true;
+                    if (_this.mJlk) {
+                      _this.yqph += 1;
+                      _this.mJlk = _this.pqqV(_this.yqph, _this.wMtN.KkoD, _this.wMtN.ZVZY);
+                      if (_this.mJlk) {
+                        _this.wMtN.kVxJ = time;
+                        ceInstance.validate(_this.zNLA, _this.RfKK);
+                      }
+                    }
+                  }
+                  condition.ebLm.GizD.nkpi.map(function (nokpi) {
+                    ceInstance.unregisterFromEvent(toUpperCase(condition.ebLm.GizD.et) + "___" + nokpi, _this);
+                  });
+                }, event_time);
+                condition.ebLm.GizD.nkpi.map(function (nokpi) {
+                  ceInstance.registerForEvent(toUpperCase(condition.ebLm.GizD.et) + "___" + nokpi, _this.MhsE);
+                });
+              }
+              //it is for unregistering the events did case after completing the time imit
+              if ((condition === null || condition === void 0 ? void 0 : (wMtN$_details3 = condition.ebLm) === null || wMtN$_details3 === void 0 ? void 0 : (wMtN$_details3$ = wMtN$_details3.GizD) === null || wMtN$_details3$ === void 0 ? void 0 : wMtN$_details3$.kpi.length) > 0) {
+                setTimeout(function () {
+                  condition.ebLm.GizD.kpi.map(function (kpi) {
+                    ceInstance.unregisterFromEvent(toUpperCase(condition.ebLm.GizD.et) + "___" + kpi, _this);
+                  });
+                }, event_time);
+                condition.ebLm.GizD.kpi.map(function (kpi) {
+                  if (kpi === condition.MgEa.ebLm.yaFV) {
+                    //unregister the previous event
+                    ceInstance.unregisterFromEvent(generateKey(precondition.cWDi) + "___" + precondition.ebLm.yaFV, _this);
+                    ceInstance.registerForEvent(toUpperCase(condition.ebLm.GizD.et) + "___" + kpi, _this.gjCB);
+                  } else {
+                    ceInstance.registerForEvent(toUpperCase(condition.ebLm.GizD.et) + "___" + kpi, _this.MhsE);
+                  }
+                });
+              }
+            } else {
+              ceInstance.unregisterFromEvent(generateKey(precondition.cWDi) + "___" + precondition.ebLm.yaFV, _this);
+              ceInstance.registerForEvent(generateKey(condition.cWDi) + "___" + condition.ebLm.yaFV, _this);
+            }
+            _this.aOME[name] = Date.now();
+          }
+          return;
+        }
+
+        // Validate Condition
+        var validationStatus = generateKey(_this.wMtN.cWDi) === type && _this.dLxA(time - _this.wMtN.MgEa.kVxJ, _this.wMtN.aAiV) && _this.wMtN.ebLm.yaFV === name && _this.eFNk(_this.wMtN.ebLm.GizD, additionalInfo);
+        if (validationStatus) {
+          _this.yqph += 1;
+          _this.mJlk = _this.pqqV(_this.yqph, _this.wMtN.KkoD, _this.wMtN.ZVZY);
+          if (_this.mJlk) {
+            _this.wMtN.kVxJ = time;
+            ceInstance.validate(_this.zNLA, _this.RfKK);
+          }
+        }
+      });
+      _defineProperty(this, "mTyq", function (type, name, time, additionalInfo) {
+        var precondition = _this.wMtN.MgEa;
+        return generateKey(precondition.cWDi) === type && precondition.ebLm.yaFV === name && _this.dLxA(time, precondition.aAiV) && _this.eFNk(precondition.ebLm.GizD, additionalInfo);
+      });
+      _defineProperty(this, "dLxA", function (time, timeBounds) {
+        var currentTime = Math.ceil(time);
+        return currentTime > timeBounds.rrCh && currentTime < timeBounds.gDCR;
+      });
+      _defineProperty(this, "pqqV", function (current, required, operator) {
+        var checkOld = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+        if (checkOld && _this.wMtN.EpOC) {
+          current = current + _this.GQSy;
+        }
+        switch (operator) {
+          case "EQ":
+            return current === required;
+          case "GT":
+            return current > required;
+          case "GTE":
+            return current >= required;
+          case "LT":
+            return current < required;
+          case "LTE":
+            return current <= required;
+          default:
+            return false;
+        }
+      });
+      _defineProperty(this, "eFNk", function (expected, received) {
+        var status = true;
+        try {
+          var _loop = function _loop() {
+            if (!received[item] || status === false) {
+              return {
+                v: false
+              };
+            }
+            if (_typeof(expected[item]) === "object") {
+              var operator = expected[item].op;
+              var type = expected[item].t;
+              var expectedValue;
+              if (type === "s") {
+                expectedValue = expected[item].val;
+              } else if (type === "l" || type === "f") {
+                expectedValue = parseFloat(expected[item].val);
+              }
+              var loggedValues = [];
+              if (Array.isArray(received[item])) {
+                loggedValues = received[item];
+              } else {
+                loggedValues = [received[item]];
+              }
+              var match = loggedValues.some(function (loggedValue) {
+                return compare(loggedValue, expectedValue, operator);
+              });
+              status = status && match;
+            } else {
+              status = status && compare(received[item], expected[item], "EQ");
+            }
+          };
+          for (var item in expected) {
+            var _ret = _loop();
+            if (_typeof(_ret) === "object") return _ret.v;
+          }
+        } catch (error) {
+          Logger$4.error(error);
+          status = false;
+        }
+        return status;
+      });
+    }
+    _createClass(ConditionValidator, [{
+      key: "_displayCampaign",
+      value: function _displayCampaign(time) {
+        var ceInstance = CE.getInstance();
+        this.mJlk = true;
+        if (this.mJlk) {
+          this.yqph += 1;
+          this.mJlk = this.pqqV(this.yqph, this.wMtN.KkoD, this.wMtN.ZVZY);
+          if (this.mJlk) {
+            this.wMtN.kVxJ = time;
+            ceInstance.validate(this.zNLA, this.RfKK);
+          }
+        }
+      }
+    }]);
+    return ConditionValidator;
+  }();
+
+  var QE_STATE = "qe_state";
+  var APX_RETAINED_SESSIONS = "apx_retained_session";
+  var APX_RETAINED_DAYS = "apx_retained_days";
+  var APX_CONTEXT_EVALUATED = "apx_context_evaluated";
+
+  var Logger$5 = window.ApxorLogger;
+  var OverallConfig = /*#__PURE__*/_createClass(function OverallConfig() {
+    var _this = this;
+    _classCallCheck(this, OverallConfig);
+    _defineProperty(this, "JHaZ", []);
+    _defineProperty(this, "_ret_day", {});
+    _defineProperty(this, "Gbfo", {});
+    _defineProperty(this, "sYjx", false);
+    _defineProperty(this, "JxBs", false);
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        _this.JHaZ = config.overall_cfg.events;
+        _this._ret_day = config.overall_cfg.ret_day;
+        _this.Gbfo = config.overall_cfg.session;
+        _this.sYjx = config.overall_cfg.toggleRetDay;
+        _this.JHaZ = config.overall_cfg.events;
+        _this.JxBs = config.overall_cfg.toggleSession;
+      } catch (error) {
+        Logger$5.error(error);
+        return false;
+      }
+      return true;
+    });
+    _defineProperty(this, "validate", function () {
+      var retainedDays = parseInt(Apxor.getController().getFromStorage(APX_RETAINED_DAYS));
+      var retainedSession = parseInt(Apxor.getController().getFromStorage(APX_RETAINED_SESSIONS));
+      if (_this.sYjx && !isNaN(retainedDays) && !(retainedDays >= _this._ret_day.from && retainedDays <= _this._ret_day.to)) {
+        return false;
+      }
+      if (_this.JxBs && !isNaN(retainedSession) && !(retainedSession >= _this.Gbfo.from && retainedSession <= _this.Gbfo.to)) {
+        return false;
+      }
+      try {
+        // particular event not happened in Life time
+        var data = Apxor.getController().getFromStorage("_apx_lt_count");
+        var siteid = Apxor.getSiteId();
+        var LtCountObjDecoded = JSON.parse(decode(siteid, data));
+        for (var i = 0; i < _this.JHaZ.length; i++) {
+          var evName = _this.JHaZ[i].name.replace("'", "").replace("’", "");
+          if (LtCountObjDecoded[evName]) {
+            return false;
+          }
+        }
+      } catch (e) {
+        Logger$5.error("Failed to validate the lt count:" + e);
+      }
+      return true;
+    });
+  });
+
+  var Logger$6 = window.ApxorLogger;
+  var ConfigItem = /*#__PURE__*/_createClass(function ConfigItem() {
+    var _this = this;
+    _classCallCheck(this, ConfigItem);
+    _defineProperty(this, "IuXx", []);
+    _defineProperty(this, "zNLA", "");
+    _defineProperty(this, "SOrm", new Meta());
+    _defineProperty(this, "aTkp", new Audience());
+    _defineProperty(this, "hDCI", new Validity());
+    _defineProperty(this, "UnuD", new Frequency());
+    _defineProperty(this, "IEfn", new OverallConfig());
+    _defineProperty(this, "PiMM", false);
+    _defineProperty(this, "JyrV", []);
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        // If ID is not present, throw it out
+        if (!isDefined(config._id)) {
+          Logger$6.error("No Id");
+          return false;
+        }
+
+        // If config is disabled, throw it out
+        if (!isDefined(config.enabled) || !config.enabled) {
+          Logger$6.error("Not enabled");
+          return false;
+        }
+
+        // If META, VALIDITY, FREQUENCY and AUDIENCE is not parsed properly, throw it out
+        if (!(_this.SOrm.parse(config) && _this.hDCI.parse(config) && _this.UnuD.parse(config) && _this.aTkp.parse(config) && _this.IEfn.parse(config))) {
+          return false;
+        }
+
+        // If there are no conditions, throw it out
+        if (!isDefined(config.conditions) || !Array.isArray(config.conditions)) {
+          Logger$6.error("No valid conditions", config.conditions);
+          return false;
+        }
+        _this.zNLA = config._id;
+        _this.PiMM = isDefined(config.sequence_enabled) ? config.sequence_enabled : false;
+        if (_this.PiMM) {
+          // iff respectSequence is true, Sort the Conditions by their sequence order
+          // We need to sort, if server sends them in orderless manner
+          config.conditions.sort(function (prev, current) {
+            return prev.sequence < current.sequence;
+          });
+        }
+
+        // Parse all conditions now
+        var conditions = config.conditions;
+        var length = conditions.length;
+        for (var index = 0; index < length; index++) {
+          _this.JyrV = [];
+          var condition = conditions[index];
+          if (condition.type === "didn't") {
+            var wMtN$details, wMtN$details$ad;
+            var obj = {
+              trigger_key: condition.trigger.details.name,
+              no_kpi_array: condition === null || condition === void 0 ? void 0 : (wMtN$details = condition.details) === null || wMtN$details === void 0 ? void 0 : (wMtN$details$ad = wMtN$details.additional_info) === null || wMtN$details$ad === void 0 ? void 0 : wMtN$details$ad.nkpi,
+              condition_id: condition === null || condition === void 0 ? void 0 : condition._id,
+              time_bounds: condition.time_bounds.upper
+            };
+            _this.JyrV = [].concat(_toConsumableArray(_this.JyrV), [obj]);
+            //this will be the key
+            //when event occur check this array and then then check the time
+            //check the time diffrence
+            //to delete the condion from the nkpi array if the time limit exceeded
+            //create an array of objects y=using all these;
+          }
+
+          var conditionValidator = new ConditionValidator();
+          if (conditionValidator.initialize(condition, _this.zNLA, index, _this.PiMM, _this.JyrV)) {
+            _this.IuXx.push(conditionValidator);
+          }
+        }
+        return _this.IuXx.length > 0;
+      } catch (error) {
+        Logger$6.error(error);
+        return false;
+      }
+    });
+    _defineProperty(this, "PffH", function (index) {
+      if (index < 0) {
+        return;
+      }
+      if (_this.PiMM) {
+        var conditionValidator = _this.IuXx[index];
+        if (isDefined(conditionValidator) && conditionValidator.mJlk) {
+          // Check if previous validator is satisfied
+          var prevValidator = _this.IuXx[index - 1];
+          if (isDefined(prevValidator) && !prevValidator.mJlk) {
+            // TODO: If current index is satisfied before previous one, do something
+            //  either unregister all conditions or remove this item from ConfigLookup
+            return;
+          }
+          var nextValidator = _this.IuXx[index + 1];
+          if (!isDefined(nextValidator)) {
+            // It means this is the last condition
+            // Validate all conditions
+            _this.nhnX();
+          } else {
+            nextValidator.gINm();
+          }
+        }
+      } else {
+        // Validate all conditions
+        _this.nhnX();
+      }
+    });
+    _defineProperty(this, "nhnX", function () {
+      // Check If Audience, Validity is satisfied or not
+      var userAttributes = Apxor.getController().getUserAttributes();
+      var sessionAttributes = Apxor.getController().getSessionAttributes();
+      if (!_this.hDCI.validate() || !_this.aTkp.validate(userAttributes, sessionAttributes) || !_this.IEfn.validate()) {
+        return;
+      }
+      var length = _this.IuXx.length;
+      var isSatisfied = length < 1;
+      var combineOperator = "";
+      for (var index = 0; index < length; index++) {
+        var validator = _this.IuXx[index];
+        var currentResult = validator.mJlk;
+        if (combineOperator.trim() === "") {
+          isSatisfied = currentResult;
+        } else {
+          switch (combineOperator) {
+            case "AND":
+              isSatisfied = isSatisfied && currentResult;
+              break;
+            case "OR":
+              isSatisfied = isSatisfied || currentResult;
+              break;
+          }
+        }
+        combineOperator = validator.bRor;
+      }
+      if (isSatisfied) {
+        console.debug("onCondition satisfied");
+        // Check if count reached it's maximum
+        if (!_this.UnuD.JglD(_this.zNLA)) {
+          console.warn("Maximum limit reached", _this.zNLA);
+          return;
+        }
+        console.log("Dispatching event", _this.SOrm.jyXB);
+        if (_this.SOrm._only_context === true) {
+          Apxor.logEvent(APX_CONTEXT_EVALUATED, _objectSpread2(_objectSpread2({}, _this.SOrm._attr), {}, {
+            message_name: _this.SOrm.yaFV,
+            id: _this.zNLA
+          }));
+        }
+        // Emit event
+        Apxor.getController().dispatchEvent(_this.SOrm.jyXB, {
+          name: _this.SOrm.jyXB,
+          additional_info: {
+            uuid: _this.zNLA,
+            name: _this.SOrm.yaFV
+          }
+        });
+      }
+    });
+    _defineProperty(this, "lSfk", function () {
+      _this.UnuD.lSfk();
+    });
+    _defineProperty(this, "getFrequencyCount", function () {
+      return _this.UnuD.getFrequencyCount();
+    });
+    _defineProperty(this, "cajt", function () {
+      return _this.UnuD.REfq();
+    });
+  });
+
+  var ConfigLookup = /*#__PURE__*/_createClass(function ConfigLookup() {
+    var _this = this;
+    _classCallCheck(this, ConfigLookup);
+    _defineProperty(this, "ZhRR", {});
+    _defineProperty(this, "parse", function () {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        configs: []
+      };
+      if (isDefined(config) && isDefined(config.configs)) {
+        var configs = config.configs;
+        if (!Array.isArray(configs)) {
+          return;
+        }
+
+        // Sorts the configs by the priority number
+        configs.sort(function (a, b) {
+          var _a$prio, _b$prio;
+          var priority1 = (_a$prio = a.prio) !== null && _a$prio !== void 0 ? _a$prio : -1;
+          var priority2 = (_b$prio = b.prio) !== null && _b$prio !== void 0 ? _b$prio : -1;
+          return priority1 - priority2;
+        });
+        for (var index = 0; index < configs.length; index++) {
+          var _config = configs[index];
+          var configId = _config._id;
+          var configItem = new ConfigItem();
+          if (configItem.parse(_config)) {
+            _this.ZhRR[configId] = configItem;
+          } else {
+            console.warn("Failed to parse cfg", configId);
+          }
+        }
+      }
+    });
+    _defineProperty(this, "validate", function (id, index) {
+      if (_this.ZhRR[id]) {
+        var configItem = _this.ZhRR[id];
+        configItem.PffH(index);
+      }
+    });
+    _defineProperty(this, "lSfk", function (id) {
+      var campiagnConfig = _this.ZhRR[id];
+      campiagnConfig.lSfk();
+    });
+    _defineProperty(this, "getFrequencyCount", function (id) {
+      var campiagnConfig = _this.ZhRR[id];
+      return campiagnConfig.getFrequencyCount();
+    });
+    _defineProperty(this, "resetFrequencyCounts", function () {
+      var configs = _this.ZhRR;
+      for (var configId in configs) {
+        configs[configId].cajt();
+      }
+    });
+    _defineProperty(this, "Suhh", function (campaignId) {
+      try {
+        if (_this.ZhRR) {
+          var configItem = _this.ZhRR[campaignId];
+          if (configItem && configItem.SOrm) {
+            return configItem.SOrm;
+          }
+        }
+      } catch (e) {
+        console.log("Error in getting the campaign meta ".concat(e));
+      }
+      return {};
+    });
+  });
+
+  var APP_EVENT = "APP_EVENT";
+  var CLIENT_EVENT = "CLIENT_EVENT";
+  var Logger$7 = window.ApxorLogger;
+  var EventsListener = /*#__PURE__*/_createClass(function EventsListener() {
+    var _this = this;
+    _classCallCheck(this, EventsListener);
+    _defineProperty(this, "ihqx", {});
+    _defineProperty(this, "sXGF", []);
+    _defineProperty(this, "mBTm", false);
+    _defineProperty(this, "initialize", function () {
+      var controller = Apxor.getController();
+      controller.registerForEvent(APP_EVENT, function (event) {
+        return _this.DHyY(event, "AE");
+      });
+      controller.registerForEvent(CLIENT_EVENT, function (event) {
+        return _this.DHyY(event, "CE");
+      });
+    });
+    _defineProperty(this, "sQAT", function () {
+      // Clear Buffer
+      for (var item in _this.sXGF) {
+        _this.QsuK(item.event, item.key, item.type);
+      }
+      _this.mBTm = true;
+    });
+    _defineProperty(this, "GvAJ", function (event, callback) {
+      if (!isFunction(callback)) {
+        return;
+      }
+      var listeners;
+      if (_this.ihqx[event]) {
+        listeners = _this.ihqx[event];
+      } else {
+        listeners = [];
+      }
+      listeners.push(callback);
+      _this.ihqx[event] = listeners;
+      Logger$7.debug("Listeners list: ", _this.ihqx);
+    });
+    _defineProperty(this, "unregisterFromEvent", function (event, callback) {
+      if (_this.ihqx[event]) {
+        var listeners = _this.ihqx[event];
+        var updatedListeners = [];
+        for (var index = 0; index < listeners.length; index++) {
+          var listener = listeners[index];
+          if (listener !== callback) {
+            updatedListeners.push(listener);
+          }
+        }
+        _this.ihqx[event] = updatedListeners;
+      }
+    });
+    _defineProperty(this, "DHyY", function (event) {
+      var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "AE";
+      var key = type + "___" + event.name;
+      _this.QsuK(event, key, type);
+    });
+    _defineProperty(this, "QsuK", function (event, key, type) {
+      if (!_this.mBTm) {
+        _this.sXGF.push({
+          event: event,
+          key: key,
+          type: type
+        });
+      } else {
+        Logger$7.debug("Notifying listeners for event: " + event + ", " + key, _this.ihqx);
+        if (_this.ihqx[key]) {
+          var listeners = _this.ihqx[key];
+          var time = Apxor.getController().getSDKRunningTimeInSec();
+          for (var index = 0; index < listeners.length; index++) {
+            var listener = listeners[index];
+            listener(type, event.name, time, event.additional_info);
+          }
+        }
+      }
+    });
+  });
+
+  var Logger$8 = window.ApxorLogger;
+  var CE = /*#__PURE__*/function () {
+    function CE() {
+      var _this = this;
+      _classCallCheck(this, CE);
+      _defineProperty(this, "ansf", false);
+      _defineProperty(this, "wpgz", null);
+      _defineProperty(this, "ngyZ", getDateInDDMMYYYY());
+      _defineProperty(this, "dymD", new EventsListener());
+      _defineProperty(this, "Hdaj", Apxor.getSiteId());
+      _defineProperty(this, "_qeState", {});
+      _defineProperty(this, "getQeState", function () {
+        try {
+          var data = Apxor.getController().getFromStorage(QE_STATE);
+          if (data) {
+            return JSON.parse(decode(_this.Hdaj, data));
+          } else {
+            _this._qeState = {};
+            return _this.setQeState();
+          }
+        } catch (e) {
+          _this._qeState = {};
+          return _this.setQeState();
+        }
+      });
+      _defineProperty(this, "setQeState", function () {
+        var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+        try {
+          Apxor.getController().persistToStorage(QE_STATE, _this._qeState, true);
+        } catch (e) {
+          if (id === "") {
+            _this._qeState = {};
+          } else {
+            _this._qeState[id] = {
+              SESSION: 0,
+              OVERALL: 0,
+              DATES: {}
+            };
+          }
+          Apxor.getController().persistToStorage(QE_STATE, _this._qeState, true);
+        }
+        return _this._qeState;
+      });
+      _defineProperty(this, "initialize", function () {
+        if (!_this.ansf) {
+          _this.ansf = true;
+          _this.wpgz = new ConfigLookup();
+          _this.dymD.initialize();
+          _this._qeState = _this.getQeState();
+          Logger$8.info("QE Initialized..");
+        }
+      });
+      /**
+       * Parses the given configuration
+       *
+       * @param config
+       */
+      _defineProperty(this, "parse", function (config) {
+        if (!_this.iQUj()) {
+          Logger$8.warn("Must call init first. Unable to proceed");
+          return;
+        }
+        _this.wpgz.parse(config);
+        _this.dymD.sQAT();
+      });
+      /**
+       * Validates all conditions for given config ID
+       *
+       * @param id
+       * @param index
+       */
+      _defineProperty(this, "validate", function (id, index) {
+        if (!_this.iQUj()) {
+          return;
+        }
+        _this.wpgz.validate(id, index);
+      });
+      _defineProperty(this, "updateCount", function (id) {
+        try {
+          if (!isDefined(_this._qeState[id])) {
+            _this.createObjConfig(id);
+          }
+          _this.incrementFrequencies(id);
+          _this.setQeState(id);
+          _this.wpgz.lSfk(id);
+        } catch (e) {
+          console.log("Could not update the count config:".concat(e));
+        }
+      });
+      _defineProperty(this, "resetFrequencyCounts", function () {
+        _this.wpgz.resetFrequencyCounts();
+      });
+      _defineProperty(this, "getFrequencyCount", function (id) {
+        return _this.wpgz.getFrequencyCount(id);
+      });
+      _defineProperty(this, "registerForEvent", function (event, callback) {
+        _this.dymD.GvAJ(event, callback);
+      });
+      _defineProperty(this, "unregisterFromEvent", function (event, callback) {
+        _this.dymD.unregisterFromEvent(event, callback);
+      });
+      /**
+       * Fetches the config from Server
+       *
+       * @param type
+       * @param validateUrl
+       * @param apiUrl
+       * @param callback
+       */
+      _defineProperty(this, "fetch", function (type, validateUrl, apiUrl, callback) {
+        Apxor.getController().fetchConfiguration(type, validateUrl, apiUrl, callback);
+      });
+      _defineProperty(this, "iQUj", function () {
+        return _this.ansf;
+      });
+      _defineProperty(this, "getCampaignMetaFromQueryEngine", function (campaignId) {
+        return _this.wpgz.Suhh(campaignId);
+      });
+      _defineProperty(this, "ngye", function () {
+        return _this.ngyZ;
+      });
+      if (!CE.instance) {
+        CE.instance = this;
+      }
+      return CE.instance;
+    }
+    _createClass(CE, [{
+      key: "createObjConfig",
+      value:
+      /**
+       * Fetches the count from ConfigLookup and updates it in state for the given ID
+       *
+       * @param id
+       */
+      function createObjConfig(id) {
+        try {
+          this._qeState = this.getQeState();
+          if (!isDefined(this._qeState[id])) {
+            this._qeState[id] = {
+              SESSION: 0,
+              OVERALL: 0,
+              DATES: {}
+            };
+            if (this.ngyZ) this._qeState[id].DATES[this.ngyZ] = 0;
+            this.setQeState(id);
+          }
+        } catch (e) {
+          Logger$8.error("Can not create the frequency count object:" + e);
+        }
+      }
+    }, {
+      key: "incrementFrequencies",
+      value: function incrementFrequencies(id) {
+        this._qeState = this.getQeState();
+        var configFrequency = this._qeState[id];
+        // Increment the SESSION count by 1
+        configFrequency.SESSION = configFrequency.SESSION + 1;
+        // Increment the OVERALL count by 1
+        configFrequency.OVERALL = configFrequency.OVERALL + 1;
+
+        // Increment the DATES count for this particular date by 1. If the date changes reset.
+        var currentDate = getDateInDDMMYYYY();
+        if (currentDate !== this.ngyZ || !(configFrequency.DATES && configFrequency.DATES[currentDate])) {
+          this.ngyZ = currentDate;
+          configFrequency.DATES = {};
+          configFrequency.DATES[this.ngyZ] = 0;
+        }
+        configFrequency.DATES[this.ngyZ] = configFrequency.DATES[this.ngyZ] + 1;
+      }
+    }], [{
+      key: "getInstance",
+      value: function getInstance() {
+        if (!CE.instance) {
+          CE.instance = new CE();
+        }
+        return CE.instance;
+      }
+    }]);
+    return CE;
+  }();
+  _defineProperty(CE, "instance", void 0);
+
+  // const ce = new CE();
+
+  /* eslint-disable no-empty */
+
+  window.ceVersion = 119;
+  try {
+    if (exports !== undefined || exports !== null) {
+      exports["default"] = CE;
+      module.exports = exports["default"];
+    }
+  } catch (e) {}
+
+  return CE;
+
+}));