{"version":3,"file":"spenttime.js","mappings":"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","sources":["webpack://@sklik/component-spenttime/./node_modules/lodash.clonedeep/index.js","webpack://@sklik/component-spenttime/webpack/bootstrap","webpack://@sklik/component-spenttime/webpack/runtime/compat get default export","webpack://@sklik/component-spenttime/webpack/runtime/define property getters","webpack://@sklik/component-spenttime/webpack/runtime/global","webpack://@sklik/component-spenttime/webpack/runtime/hasOwnProperty shorthand","webpack://@sklik/component-spenttime/webpack/runtime/node module decorator","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/log.js","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/constants.js","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/window.js","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/url.js","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/getShouldLog.js","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/index.js","webpack://@sklik/component-spenttime/./src/modules/debug.ts","webpack://@sklik/component-spenttime/./src/constants/index.ts","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/permanent.js","webpack://@sklik/component-spenttime/./node_modules/@iva/debugger/dist/esm/status.js","webpack://@sklik/component-spenttime/./src/utils/addCustomEvent.ts","webpack://@sklik/component-spenttime/./src/modules/dot.ts","webpack://@sklik/component-spenttime/./src/modules/hit.ts","webpack://@sklik/component-spenttime/./src/modules/config/checks.ts","webpack://@sklik/component-spenttime/./src/utils/getElement.ts","webpack://@sklik/component-spenttime/./src/modules/config/config.ts","webpack://@sklik/component-spenttime/./src/utils/getDeviceType.ts","webpack://@sklik/component-spenttime/./src/classes/spenttime.class.ts","webpack://@sklik/component-spenttime/./src/utils/jsonParse.ts","webpack://@sklik/component-spenttime/./src/classes/stateSwitch.class.ts","webpack://@sklik/component-spenttime/./node_modules/throttle-debounce/esm/index.js","webpack://@sklik/component-spenttime/./src/modules/events/userActivityEvents.ts","webpack://@sklik/component-spenttime/./src/modules/events/userLoginEvents.ts","webpack://@sklik/component-spenttime/./src/modules/events/pageVisibilityEvents.ts","webpack://@sklik/component-spenttime/./src/modules/events/containerVisibilityEvents.ts","webpack://@sklik/component-spenttime/./src/modules/events/itemsVisibilityEvents.ts","webpack://@sklik/component-spenttime/./src/modules/events/containerMutationEvents.ts","webpack://@sklik/component-spenttime/./src/modules/events/index.ts","webpack://@sklik/component-spenttime/./src/modules/stateSwitch.ts","webpack://@sklik/component-spenttime/./src/modules/spenttime/measurement.ts","webpack://@sklik/component-spenttime/./src/index.ts"],"sourcesContent":["/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/**\n * Adds the key-value `pair` to `map`.\n *\n * @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n */\nfunction addMapEntry(map, pair) {\n  // Don't return `map.set` because it's not chainable in IE 11.\n  map.set(pair[0], pair[1]);\n  return map;\n}\n\n/**\n * Adds `value` to `set`.\n *\n * @private\n * @param {Object} set The set to modify.\n * @param {*} value The value to add.\n * @returns {Object} Returns `set`.\n */\nfunction addSetEntry(set, value) {\n  // Don't return `set.add` because it's not chainable in IE 11.\n  set.add(value);\n  return set;\n}\n\n/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  if (initAccum && length) {\n    accumulator = array[++index];\n  }\n  while (++index < length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n  return result;\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  return this.has(key) && delete this.__data__[key];\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  return getMapData(this, key)['delete'](key);\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  getMapData(this, key).set(key, value);\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  this.__data__ = new ListCache(entries);\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  return this.__data__['delete'](key);\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var cache = this.__data__;\n  if (cache instanceof ListCache) {\n    var pairs = cache.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      return this;\n    }\n    cache = this.__data__ = new MapCache(pairs);\n  }\n  cache.set(key, value);\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n  var result;\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      if (isHostObject(value)) {\n        return object ? value : {};\n      }\n      result = initCloneObject(isFunc ? {} : value);\n      if (!isDeep) {\n        return copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, baseClone, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (!isArr) {\n    var props = isFull ? getAllKeys(value) : keys(value);\n  }\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n  });\n  return result;\n}\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nfunction baseCreate(proto) {\n  return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  return objectToString.call(value);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var result = new buffer.constructor(buffer.length);\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/**\n * Creates a clone of `map`.\n *\n * @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n */\nfunction cloneMap(map, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n  return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\n/**\n * Creates a clone of `set`.\n *\n * @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n */\nfunction cloneSet(set, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n  return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    assignValue(object, key, newValue === undefined ? source[key] : newValue);\n  }\n  return object;\n}\n\n/**\n * Copies own symbol properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * Creates an array of the own enumerable symbol properties of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = objectToString.call(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : undefined;\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return cloneMap(object, isDeep, cloneFunc);\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return cloneSet(object, isDeep, cloneFunc);\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, true, true);\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = cloneDeep;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","__webpack_require__.nmd = function(module) {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import cloneDeep from 'lodash.clonedeep';\n/**\n * Logs message into console if proper UTM set to truthy value.\n * @param {object} - Configuration with log details.\n * @param {('log'|'warn'|'error'|'info'|'table')} [type = 'log'] - Type of console, if not specified defaults to \"log\".\n * @param {string | number} [subName] - additional service name subtype, can be used to log error code number\n * @param {unknown[]} [messages] - Data to be displayed as in console.\n */\nconst log = (config, type = 'log', subName, ...messages) => {\n    const { name, fColor, bColor } = config;\n    const style = `display: inline-block; color: ${fColor}; background: ${bColor}; padding: 1px 4px; border-radius: 3px;`;\n    const badge = `%c${name}${subName ? ' ' + subName : ''}`;\n    const messagesCopy = (messages !== null && messages !== void 0 ? messages : []).map((v) => cloneDeep(v));\n    if (type === 'table' && messagesCopy.length === 1) {\n        // print data in table, badge in the separate log\n        console.log(badge, style);\n        console.table(messagesCopy[0]);\n    }\n    else if (type === 'table' && messagesCopy.length === 2) {\n        // print data in table, badge and message in the separate log\n        console.log(badge, style, messagesCopy[0]);\n        console.table(messagesCopy[1]);\n    }\n    else {\n        // print any messages with a badge\n        console[type](badge, style, ...messagesCopy);\n    }\n};\nexport { log };\n","const ENABLER = 'sznivadbg';\nconst PERMANENT_ENABLER = 'sznivadbgsave';\nconst EVENT_PREFIX = 'iva_dbg_event_';\nconst DEFAULTS = {\n    FCOLOR: 'white',\n    BCOLOR: 'black',\n};\nexport { ENABLER, EVENT_PREFIX, DEFAULTS, PERMANENT_ENABLER };\n","import { getDebuggerRule } from './getShouldLog';\nimport { EVENT_PREFIX } from './constants';\nimport { log } from './log';\nimport { getInternalConfig } from './index';\nconst isTopLevel = (win = window) => (win.top === win.self || !!win.Cypress) && !win.frameElement;\n/**\n * Gets debugger window object from window.sznIVA.debugger, or returns undefined if it doesn't exist.\n * @returns\n */\nconst getGlobalDebuggerObject = () => { var _a; return (_a = window.sznIVA) === null || _a === void 0 ? void 0 : _a.debugger; };\n/**\n * Creates or updates debugger window object in window.sznIVA.debugger.\n * @param windowObject Object with properties to update.\n */\nconst upsertGlobalDebuggerObject = (windowObject) => {\n    window.sznIVA = window.sznIVA || {};\n    window.sznIVA.debugger = Object.assign(Object.assign({}, window.sznIVA.debugger), windowObject);\n};\n/**\n * Returns top frame debugger rule saved in the window object.\n */\nconst getTopFrameRule = () => { var _a; return (_a = getGlobalDebuggerObject()) === null || _a === void 0 ? void 0 : _a.topFrameRule; };\n/**\n * Handles message event from iframes requesting debugger rule.\n */\nconst handlerFromChildMessage = (event) => {\n    var _a;\n    if (event.source && event.data.type === `${EVENT_PREFIX}request_debug_settings`) {\n        const rule = getDebuggerRule();\n        event.source.postMessage({\n            type: `${EVENT_PREFIX}debug_settings`,\n            rule,\n        }, '*');\n        if (!((_a = getGlobalDebuggerObject()) === null || _a === void 0 ? void 0 : _a.iframeBridgeNotified)) {\n            if (rule) {\n                log(getInternalConfig(), undefined, undefined, `Top frame sends a debugger rule \"${rule}\" to iframes.`);\n            }\n            upsertGlobalDebuggerObject({ iframeBridgeNotified: true });\n        }\n    }\n};\n/**\n * Handles message event from top window containing debugger rule.\n */\nconst handlerFromTopMessage = (event) => {\n    if (event.data.type === `${EVENT_PREFIX}debug_settings`) {\n        upsertGlobalDebuggerObject({ topFrameRule: event.data.rule });\n    }\n};\n/**\n * Init mechanism of getting current debugging rule from top window.\n */\nconst initIframeBridge = () => {\n    if (isTopLevel()) {\n        window.addEventListener('message', (event) => handlerFromChildMessage(event));\n    }\n    else {\n        window.addEventListener('message', (event) => handlerFromTopMessage(event));\n        window.top.postMessage({ type: `${EVENT_PREFIX}request_debug_settings` }, document.referrer || '*');\n    }\n};\nexport { getInternalConfig, getTopFrameRule, getGlobalDebuggerObject, initIframeBridge, isTopLevel, upsertGlobalDebuggerObject, };\n","const getParamValue = (param) => {\n    const queryString = window.location.search || '';\n    const paramRegex = new RegExp(`${param}=([^&]*)`);\n    const matches = queryString.match(paramRegex) || [];\n    return matches.length > 1 ? matches[1] : null;\n};\nexport { getParamValue };\n","import { getGlobalDebuggerObject, getTopFrameRule, isTopLevel, upsertGlobalDebuggerObject } from './window';\nimport { ENABLER } from './constants';\nimport { getParamValue } from './url';\nimport { log } from './log';\nimport { getInternalConfig } from './index';\nconst getDebuggerRule = () => {\n    var _a;\n    const paramValue = getParamValue(ENABLER);\n    if (paramValue) {\n        return paramValue;\n    }\n    const topFrameRule = getTopFrameRule();\n    if (topFrameRule) {\n        return topFrameRule;\n    }\n    try {\n        const localStorageRule = ((_a = window.localStorage) === null || _a === void 0 ? void 0 : _a.getItem(ENABLER)) || '';\n        if (localStorageRule) {\n            return localStorageRule;\n        }\n    }\n    catch (error) {\n        log(getInternalConfig(), 'warn', undefined, JSON.stringify(error));\n    }\n    return '';\n};\n/**\n * Finds component name in provided string and decides whether to log based on it.\n * @param {String | null} paramValue Value of debug UTM\n * @param {*} name Name of current library\n * @return {Boolean} Should log or not\n */\nconst findNameInValue = (paramValue, name) => {\n    // empty string, or any falsey\n    if (!paramValue) {\n        return false;\n    }\n    // if paramValue === \"1\" always log\n    if (paramValue === '1') {\n        return true;\n    }\n    // if paramValue contains \"!\" allowed libraries are defined by exclusion\n    if (~paramValue.indexOf('!')) {\n        if (~paramValue.toLowerCase().indexOf(`!${name.toLowerCase()}`)) {\n            return false;\n        }\n        return true;\n    }\n    // if paramValue isn't \"1\" and contains name - should log\n    if (~paramValue.toLowerCase().indexOf(name.toLowerCase())) {\n        return true;\n    }\n    // did not fit any category - should NOT log\n    return false;\n};\n/**\n * Decides whether current library should be logging.\n * @param {*} name Name of current library\n * @return {Boolean} Should log or not\n */\nconst getShouldLog = (name) => {\n    var _a;\n    const rule = getDebuggerRule();\n    if (!((_a = getGlobalDebuggerObject()) === null || _a === void 0 ? void 0 : _a.welcomeNotified) && rule && isTopLevel()) {\n        upsertGlobalDebuggerObject({ welcomeNotified: true });\n        log(getInternalConfig(), 'log', undefined, '===============================================\\n' +\n            ` | 🕷 DEBUGGER is set to \"${rule}\".\\n` +\n            ` | Use \"1\" to let any component log or use component name[s] to filter them.\\n` +\n            ` | Using \\\"!component\\\" lets log all components except those listed.\\n` +\n            ` | Save the rule to local storage using GET parameter \"?sznivadbgsave=${rule}\"\\n` +\n            ` | and remove it by \"?sznivadbgsave=\".\\n` +\n            ` \\`=======================================================`);\n    }\n    return findNameInValue(rule, name);\n};\nexport { findNameInValue, getShouldLog, getDebuggerRule };\n","var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { log } from './log';\nimport { status } from './status';\nimport { getShouldLog } from './getShouldLog';\nimport { DEFAULTS } from './constants';\nimport { initIframeBridge } from './window';\nimport { permanentEnabler } from './permanent';\n/**\n * Returns debugger Config for the debugger itself.\n * @returns Debugger Config\n */\nconst getInternalConfig = () => ({\n    name: 'debugger',\n    fColor: '#AAA',\n    bColor: '#777',\n});\ninitIframeBridge();\n/**\n * Returns debug function based on config (name and colors)\n */\nconst debugFactory = (config) => {\n    permanentEnabler();\n    config = Object.assign({ fColor: DEFAULTS.FCOLOR, bColor: DEFAULTS.BCOLOR }, config);\n    if (!(config && config.name && config.fColor && config.bColor)) {\n        // in order not to break whomever is importing\n        // return a function that can still be called\n        return () => false;\n    }\n    const debug = (...args) => {\n        const types = ['log', 'warn', 'error', 'info', 'table'];\n        const argsCount = args.length;\n        const shouldLog = getShouldLog(config.name);\n        if (!shouldLog || argsCount === 0) {\n            // nothing to log, just return shouldLog\n            return shouldLog;\n        }\n        // debug({type: 'error', subName: '7845', message: 'Oh no', data: {...}, ...});\n        // or debug({state: '...', ...})\n        if (argsCount === 1 && typeof args[0] === 'object' && !Array.isArray(args[0]) && args[0] !== null) {\n            const _a = args[0], { state, type, subName, message } = _a, data = __rest(_a, [\"state\", \"type\", \"subName\", \"message\"]);\n            if (shouldLog) {\n                const logArgs = [];\n                if (message !== undefined) {\n                    logArgs.push(message);\n                }\n                if (Object.values(data).length === 1) {\n                    logArgs.push(data[Object.keys(data)[0]]);\n                }\n                else if (Object.values(data).length) {\n                    logArgs.push(data);\n                }\n                log(config, type, subName, ...logArgs);\n            }\n            if (state) {\n                status(config, state, data);\n            }\n            return shouldLog;\n        }\n        // debug('Look what happens.');\n        // debug(['someData', '...'}); anything else then object\n        if (shouldLog && argsCount === 1) {\n            log(config, 'log', undefined, args[0]);\n            return shouldLog;\n        }\n        // debug('error', 'Oh no, there is an error.');   or other types, like warn, info, table...\n        // debug('error', {someData: '...'});\n        if (shouldLog && argsCount === 2 && ~types.indexOf(args[0])) {\n            log(config, args[0], undefined, args[1]);\n            return shouldLog;\n        }\n        // debug('Look at this data', data, [moreData, ...]);\n        if (shouldLog && argsCount > 1 && !~types.indexOf(args[0])) {\n            log(config, 'log', undefined, ...args);\n            return shouldLog;\n        }\n        // debug('error', 'Oh no, there is an error, look at this data', data, [moreData, ...]);\n        // debug('table', 'Look at this data', data);\n        if (shouldLog && argsCount > 2 && ~types.indexOf(args[0])) {\n            log(config, args[0], undefined, ...args.slice(1));\n            return shouldLog;\n        }\n        // Some other args combination we forgot to cover? This shouldn't happen.\n        log(getInternalConfig(), 'warn', undefined, 'Debugger received unknown argument combination. args:', args);\n        return shouldLog;\n    };\n    return debug;\n};\nexport { debugFactory, getInternalConfig };\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { debugFactory } from '@iva/debugger';\nexport var DEBUG_CONFIG = {\n    name: 'component-spenttime',\n    bColor: '#35b5a2',\n    fColor: '#fff',\n};\n// states for the debugger\nexport var DEBUG_STATES = {\n    START: 'start',\n    DONE: 'done',\n    ERROR: 'error',\n};\n// Use the parameter ?sznivadbg=1 or ?sznivadbg=component-spenttime for debugging\nvar debug = debugFactory(DEBUG_CONFIG);\nexport var debugObject = function (obj) {\n    var str = JSON.stringify(obj);\n    str.replace(/\\}/g, '\\n}\\n');\n    str.replace(/\\{/g, '\\n}\\n');\n    debug(str);\n};\nexport var spenttimeDebug = function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var dateOptions = {\n        hour: '2-digit',\n        minute: '2-digit',\n        second: '2-digit',\n    };\n    var time = new Intl.DateTimeFormat('cz-CS', dateOptions).format(new Date()) + ' ';\n    if (args.length === 1 && typeof args[0] === 'string') {\n        debug(time + args[0]);\n        return;\n    }\n    if (args.length === 1 && typeof args[0] === 'object') {\n        var obj = args[0];\n        var message = obj.message;\n        debug(__assign(__assign({}, args[0]), { message: time + message }));\n        return;\n    }\n    debug(args);\n};\n","// Action value in hit\nexport var HIT_ACTION_NAME = 'component-spenttime';\n// The time (ms) we wait for the DOT to load\nexport var DOT_WAITING_TIME = 10000;\n// Delaytime of user activity events\nexport var THROTTLE_DELAY = 1000; // 1s\n// Device type\n// eslint-disable-next-line no-shadow\nexport var DEVICE_TYPE;\n(function (DEVICE_TYPE) {\n    DEVICE_TYPE[\"DESKTOP\"] = \"desktop\";\n    DEVICE_TYPE[\"MOBILE\"] = \"mobile\";\n})(DEVICE_TYPE || (DEVICE_TYPE = {}));\nexport var ITEM_MONITORED_ATTRIBUTE = 'data-analytics-spent-time-item-monitored';\nexport var DEFAULT_CONFIG = {\n    container: {\n        // Intersection threshold of target element\n        intersectionThreshold: 0.05, // 5%\n    },\n    mobile: {\n        measuring: true,\n        // User inactivity time, after which we pause the spentime calculation (the user fell asleep)\n        fallAsleepTime: 15000, // (milliseconds) 15 seconds\n        // User inactivity time, after which we stop counting the time spent (the user has left)\n        forcedDepartureTime: 30 * 60 * 1000, // (ms) 30 minut\n    },\n    desktop: {\n        measuring: true,\n        // User inactivity time, after which we pause the spentime calculation (the user fell asleep)\n        fallAsleepTime: 45000, // (milliseconds) 45 seconds\n        // User inactivity time, after which we stop counting the time spent (the user has left)\n        forcedDepartureTime: 30 * 60 * 1000, // (ms) 30 minut\n    },\n};\nexport var DEFAULT_ITEMS_CONFIG = {\n    numberOfItemsInHit: 20,\n    attributeWithDopDetails: null,\n    mobile: {\n        // The delay time on desktop devices\n        measurementStartDelay: 500, // (ms) 0.5s\n        // Intersection threshold of target element in target area\n        intersectionThreshold: 0.75, // 75%\n        // the screen area where the user reads articles\n        targetAreaHeight: 1.0, // 100%\n        targetAreaWidth: 1.0, // 100%\n    },\n    desktop: {\n        // The delay time on desktop devices\n        measurementStartDelay: 1000, // (ms) 1s\n        // Intersection threshold of target element in target area\n        intersectionThreshold: 0.75, // 75%\n        // the screen area where the user reads articles\n        targetAreaHeight: 1.0, // 100%\n        targetAreaWidth: 1.0, // 100%\n    },\n};\n// eslint-disable-next-line no-shadow\nexport var EVENT;\n(function (EVENT) {\n    EVENT[\"measurementWillNotBePerformed\"] = \"szn:spenttime:measurementWillNotBePerformed\";\n    EVENT[\"waitingForDot\"] = \"szn:spenttime:waitingForDot\";\n    EVENT[\"stateInited\"] = \"szn:spenttime:stateInited\";\n    EVENT[\"stateRun\"] = \"szn:spenttime:stateRun\";\n    EVENT[\"statePaused\"] = \"szn:spenttime:statePaused\";\n    EVENT[\"stateDone\"] = \"szn:spenttime:stateDone\";\n})(EVENT || (EVENT = {}));\n// Measurement spenttime states\n// eslint-disable-next-line no-shadow\nexport var SPENTTIME_STATES;\n(function (SPENTTIME_STATES) {\n    SPENTTIME_STATES[\"inited\"] = \"inited\";\n    SPENTTIME_STATES[\"running\"] = \"running\";\n    SPENTTIME_STATES[\"paused\"] = \"paused\";\n    SPENTTIME_STATES[\"done\"] = \"done\";\n})(SPENTTIME_STATES || (SPENTTIME_STATES = {}));\n","import { getInternalConfig } from './window';\nimport { log } from './log';\nimport { ENABLER, PERMANENT_ENABLER } from './constants';\nimport { getParamValue } from './url';\n/**\n * Checking of save command in GET params and saving the value to local storage.\n */\nconst permanentEnabler = () => {\n    var _a, _b, _c;\n    const paramValue = getParamValue(PERMANENT_ENABLER);\n    // nothing in URL\n    if (paramValue === null) {\n        return;\n    }\n    const lastValue = (_a = window.localStorage) === null || _a === void 0 ? void 0 : _a.getItem(ENABLER);\n    if (\n    // rule in URL is the same as the saved one (preventing console bloating)\n    paramValue == lastValue ||\n        // rule was already deleted\n        (lastValue === null && paramValue === '')) {\n        // do nothing\n        return;\n    }\n    if (paramValue === '') {\n        // blank string to remove the saved rule\n        (_b = window.localStorage) === null || _b === void 0 ? void 0 : _b.removeItem(ENABLER);\n        log(getInternalConfig(), undefined, undefined, 'Rule was removed from the local storage.');\n    }\n    else {\n        // a string to save to the local storage\n        (_c = window.localStorage) === null || _c === void 0 ? void 0 : _c.setItem(ENABLER, paramValue !== null && paramValue !== void 0 ? paramValue : '');\n        log(getInternalConfig(), undefined, undefined, `Rule \"${paramValue}\" was saved to the local storage.`);\n    }\n};\nexport { permanentEnabler };\n","import { EVENT_PREFIX } from './constants';\n/**\n * Saves current progress into window object and emits CustomEvent\n * @param {Object} config Object holding necessary constants\n * @param {('start'|'done'|'error')} state Event describing current state\n * @param {Object} data Data to be saved to window and emitted with event\n */\nconst status = (config, state, data) => {\n    const { name } = config;\n    const EVENT_TYPE = `${EVENT_PREFIX}${name}`;\n    const detail = Object.assign({ state }, data);\n    // Add to window\n    window.sznIVA = window.sznIVA || {};\n    window.sznIVA[name] = window.sznIVA[name] || {};\n    // Overwrite data, but do not remove any properties\n    Object.assign(window.sznIVA[name], detail);\n    // Emit CustomEvent\n    const event = new CustomEvent(EVENT_TYPE, { detail });\n    window.dispatchEvent(event);\n};\nexport { status };\n","export var addEventForCypress = function (eventName, id) {\n    if (id === void 0) { id = ''; }\n    var detail = id ? { detail: { id: id } } : null;\n    if (window.Cypress) {\n        window.dispatchEvent(new CustomEvent(eventName, detail));\n    }\n};\n","import { DOT_WAITING_TIME, EVENT } from '../constants';\nimport { DEBUG_STATES, spenttimeDebug as debug } from './debug';\nimport { addEventForCypress } from '../utils/addCustomEvent';\nimport { completeMeasurement } from './spenttime/measurement';\nvar dotConfigured = false;\n/**\n * Checks that the DOT is loaded and DOT was configured\n * @returns boolean status\n */\nexport var isDotConfigured = function () {\n    var _a, _b;\n    if (dotConfigured) {\n        return true;\n    }\n    if ((_b = (_a = window.DOT) === null || _a === void 0 ? void 0 : _a.isConfigured) === null || _b === void 0 ? void 0 : _b.call(_a)) {\n        debug('There is DOT');\n        dotConfigured = true;\n        return true;\n    }\n    else {\n        return false;\n    }\n};\n/**\n * Сhecks that the DOT is loaded and starts the func(funParameters)\n */\nexport var waitingForDOT = function () {\n    // waiting for DOT for DOT_WAITING_TIME ms\n    addEventForCypress(EVENT.waitingForDot);\n    window.setTimeout(function () {\n        if (isDotConfigured()) {\n            dotConfigured = true;\n        }\n        else {\n            debug({\n                type: 'error',\n                message: \"Error: There is no DOT or DOT is not configured. Measuring the spenttime is not possible\",\n                state: DEBUG_STATES.ERROR,\n            });\n            completeMeasurement();\n            addEventForCypress(EVENT.measurementWillNotBePerformed);\n        }\n    }, DOT_WAITING_TIME);\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { spenttimeDebug as debug } from './debug';\nimport { HIT_ACTION_NAME } from '../constants/index';\nimport { isDotConfigured } from './dot';\n/**\n * Object with common data to send in hit\n */\nvar commonHitData = {\n    action: HIT_ACTION_NAME,\n};\nexport var getHitData = function (data) {\n    return __assign(__assign({}, commonHitData), data);\n};\n/**\n * Saves common data for hit\n * @param data Object with data to hit\n */\nexport var saveHitData = function (data) {\n    commonHitData = __assign(__assign({}, commonHitData), data);\n};\n/**\n * Sends hit with data to the server\n * @param data Object with data to hit\n */\nexport var sendHit = function (data) {\n    var finalHitData = getHitData(data);\n    if (isDotConfigured()) {\n        window.DOT.hit('event', { d: __assign({}, finalHitData) });\n        debug(__assign({ message: '[ HIT ] Hit was sent:' }, finalHitData));\n    }\n};\n","import { getElement } from '../../utils/getElement';\n/**\n * Searches and returns for a container element\n * @param incomingElement Id (string) or selector (string) or HTMLElement\n * @returns HTMLElement or null (if the element is not found)\n */\nexport var getContainerElement = function (incomingElement) {\n    var element = getElement(incomingElement);\n    if (!element) {\n        return null;\n    }\n    return element;\n};\n/**\n * Сhecks the times (fallAsleepTime and forcedDepartureTime) depending on the type of device\n * @param deviceConfig Configuration with times\n * @returns Configuration with times is correct (true) or not (false)\n */\nexport var isUserActivityTimeCorrect = function (deviceConfig) {\n    return (deviceConfig.fallAsleepTime &&\n        deviceConfig.fallAsleepTime > 0 &&\n        deviceConfig.forcedDepartureTime &&\n        deviceConfig.forcedDepartureTime > 0);\n};\n/**\n * Сhecks value of percent\n * @param num Value\n * @returns Value is correct (true) or not (false)\n */\nexport var isPercent = function (num) { return num >= 0 && num <= 1; };\n/**\n * Сhecks delay\n * @param delay Value\n * @returns Value is correct (true) or not (false)\n */\nexport var isDelayCorrect = function (delay) { return delay >= 0; };\n/**\n * Checks number of items in hit\n * @param num Value\n * @returns Value is correct (true) or not (false)\n */\nexport var isNumberOfItemsInHitCorrect = function (num) { return num >= 1; };\n/**\n * Checks selector validity\n * @param selector Selector\n * @returns Value is correct (true) or not (false)\n */\nexport var isSelectorValid = function (selector) {\n    try {\n        document.createDocumentFragment().querySelector(selector);\n    }\n    catch (_a) {\n        return false;\n    }\n    return true;\n};\n/**\n * Checks string for an empty value\n * @param str String\n * @returns Value is not empty (true) or not (false)\n */\nexport var isNotEmptyString = function (str) { return str.trim() !== ''; };\n","/**\n * Gets an element by id or selector and checks its existence on the page\n * @param elementId The value by which we will try to find the element\n * @returns HTML element or null (if the element was not found on the page)\n */\nexport var getElement = function (elementId) {\n    if (typeof elementId === 'object' && elementId.nodeType && document.body.contains(elementId)) {\n        // elementId is HTMLElement\n        return elementId;\n    }\n    if (!elementId || typeof elementId !== 'string') {\n        // not an element, not a string -> nothing to return\n        return null;\n    }\n    // search by id\n    var elementById = document.getElementById(elementId);\n    if (elementById) {\n        return elementById;\n    }\n    // search by selector\n    try {\n        return document.querySelector(elementId);\n    }\n    catch (_a) {\n        return null;\n    }\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { DEBUG_STATES, spenttimeDebug as debug } from '../debug';\nimport { getDeviceType } from '../../utils/getDeviceType';\nimport { DEFAULT_CONFIG, DEFAULT_ITEMS_CONFIG } from '../../constants';\nimport { getContainerElement, isUserActivityTimeCorrect, isPercent, isDelayCorrect, isNumberOfItemsInHitCorrect, isSelectorValid, isNotEmptyString, } from './checks';\n/**\n * Сhecks the incoming parameters of ITEM config and if everything is fine, returns the verified ITEM configuration or null\n * @param incomingItemsConfig Object with incoming item configuration\n * @param deviceType Device type\n * @returns Object of verified item configuration\n */\nvar getVerifiedItemsConfig = function (incomingItemsConfig, deviceType) {\n    if (!incomingItemsConfig ||\n        !isSelectorValid(incomingItemsConfig.selector) ||\n        !isNotEmptyString(incomingItemsConfig.attributeWithDopId)) {\n        debug({\n            type: 'warn',\n            message: '[ITEMS CONF] Warning: Required parameters for measuring the spent time on items ' +\n                'are missing or incorrect. The items measurement will not be performed.',\n        });\n        return null;\n    }\n    var attributeWithDopDetails = incomingItemsConfig.attributeWithDopDetails\n        ? incomingItemsConfig.attributeWithDopDetails\n        : DEFAULT_ITEMS_CONFIG.attributeWithDopDetails;\n    var numberOfItemsInHit = isNumberOfItemsInHitCorrect(incomingItemsConfig.numberOfItemsInHit)\n        ? incomingItemsConfig.numberOfItemsInHit\n        : DEFAULT_ITEMS_CONFIG.numberOfItemsInHit;\n    var deviceItemsConfig = __assign(__assign({}, DEFAULT_ITEMS_CONFIG[deviceType]), incomingItemsConfig[deviceType]);\n    if (!isDelayCorrect(deviceItemsConfig.measurementStartDelay)) {\n        debug({\n            type: 'warn',\n            message: '[ITEMS CONF] Warning: items.measurementStartDelay is not correct. The items measurement will not be performed.',\n        });\n        return null;\n    }\n    if (!isPercent(deviceItemsConfig.intersectionThreshold)) {\n        debug({\n            type: 'warn',\n            message: '[ITEMS CONF] Warning: items.intersectionThreshold is not correct. The items measurement will not be performed.',\n        });\n        return null;\n    }\n    if (!isPercent(deviceItemsConfig.targetAreaHeight) || !isPercent(deviceItemsConfig.targetAreaWidth)) {\n        debug({\n            type: 'warn',\n            message: '[ITEMS CONF] Warning: target area size for items is not correct. The items measurement will not be performed.',\n        });\n        return null;\n    }\n    return {\n        selector: incomingItemsConfig.selector,\n        attributeWithDopId: incomingItemsConfig.attributeWithDopId,\n        attributeWithDopDetails: attributeWithDopDetails,\n        numberOfItemsInHit: numberOfItemsInHit,\n        measurementStartDelay: deviceItemsConfig.measurementStartDelay,\n        intersectionThreshold: deviceItemsConfig.intersectionThreshold,\n        targetAreaHeight: deviceItemsConfig.targetAreaHeight,\n        targetAreaWidth: deviceItemsConfig.targetAreaWidth,\n    };\n};\n/**\n * Сhecks the incoming parameters of config and if everything is fine, returns the verified configuration or null\n * @param incomingElement HTMLElement or element Id or selector\n * @param incomingConfig  Object with incoming configuration\n * @returns Object of verified configuration\n */\nexport var getVerifiedConfig = function (incomingElement, incomingConfig) {\n    var _a, _b;\n    if (incomingConfig === void 0) { incomingConfig = {}; }\n    // Сhecking that the element exists\n    var container = getContainerElement(incomingElement);\n    if (!container) {\n        debug({\n            type: 'error',\n            message: \"[CONF] Error: html element by \\\"\".concat(incomingElement, \"\\\" not found.\"),\n            state: DEBUG_STATES.ERROR,\n        });\n        return null;\n    }\n    // Сhecking the time configuration for different devices\n    var deviceType = getDeviceType();\n    var deviceConfig = __assign(__assign({}, DEFAULT_CONFIG[deviceType]), incomingConfig[deviceType]);\n    deviceConfig.measuring = deviceConfig.measuring && isUserActivityTimeCorrect(deviceConfig);\n    if (!deviceConfig.measuring) {\n        debug(__assign({ type: 'warn', message: \"[CONF] Warning: The configuration for \".concat(deviceType, \" devices is not correct or measurement is disabled for this type of device.\") }, deviceConfig));\n        return null;\n    }\n    // Checking the intersection threshold for container element\n    var intersectionThreshold = ((_a = incomingConfig.container) === null || _a === void 0 ? void 0 : _a.intersectionThreshold) || ((_b = incomingConfig.container) === null || _b === void 0 ? void 0 : _b.intersectionThreshold) === 0\n        ? incomingConfig.container.intersectionThreshold\n        : DEFAULT_CONFIG.container.intersectionThreshold;\n    if (!isPercent(intersectionThreshold)) {\n        debug({\n            type: 'error',\n            message: \"[CONF] Error: container.intersectionThreshold is not correct.\",\n            state: DEBUG_STATES.ERROR,\n        });\n        return null;\n    }\n    // final configuration (without items configuration)\n    var config = {\n        fallAsleepTime: deviceConfig.fallAsleepTime,\n        forcedDepartureTime: deviceConfig.forcedDepartureTime,\n        device: deviceType,\n        container: {\n            intersectionThreshold: intersectionThreshold,\n            element: container,\n        },\n    };\n    // Cheking items configuration\n    var itemsConfig = getVerifiedItemsConfig(incomingConfig.items, deviceType);\n    if (itemsConfig) {\n        config.items = itemsConfig;\n    }\n    debug(__assign({ message: 'Configuration:' }, config));\n    return config;\n};\n","import { DEVICE_TYPE } from '../constants';\nexport var getDeviceType = function () {\n    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\n        ? DEVICE_TYPE.MOBILE\n        : DEVICE_TYPE.DESKTOP;\n};\n","import { spenttimeDebug as debug } from '../modules/debug';\nimport { SPENTTIME_STATES, EVENT } from '../constants';\nimport { addEventForCypress } from '../utils/addCustomEvent';\n/**\n * Сounting the spent time\n */\nvar SpenttimeHandler = /** @class */ (function () {\n    /**\n     * Constructor\n     */\n    function SpenttimeHandler(delay, id /*id only for logging and tests*/) {\n        if (delay === void 0) { delay = 0; }\n        if (id === void 0) { id = 'container'; }\n        /**\n         * Start time of the spenttime account (timestamp)\n         */\n        this.startTime = null;\n        /**\n         * Timestamp of spenttime (ms)\n         */\n        this.spenttime = 0;\n        /**\n         * Spenttime change indicator\n         */\n        this._wasChange = false;\n        this.delay = delay;\n        this.init(id);\n    }\n    Object.defineProperty(SpenttimeHandler.prototype, \"state\", {\n        get: function () {\n            return this._state;\n        },\n        set: function (value) {\n            this._state = value;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    // used in the cypress\n    SpenttimeHandler.prototype.getState = function () {\n        return this._state;\n    };\n    Object.defineProperty(SpenttimeHandler.prototype, \"wasChange\", {\n        get: function () {\n            return this._wasChange;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Returns the final amount of spenttime\n     * @returns Spenttime (ms)\n     */\n    SpenttimeHandler.prototype.getSpenttime = function () {\n        if (this.startTime) {\n            var spenttimeWithDelay = this.spenttime + new Date().getTime() - this.startTime - this.delay;\n            var finalSpenttime = spenttimeWithDelay <= 0 ? 0 : spenttimeWithDelay;\n            return finalSpenttime <= 0 ? 0 : finalSpenttime;\n        }\n        return this.spenttime;\n    };\n    SpenttimeHandler.prototype.getSpenttimeInSeconds = function () {\n        var finalSpenttime = this.getSpenttime();\n        // milliseconds => seconds with two decimal places\n        return finalSpenttime ? parseInt((finalSpenttime / 10).toString(), 10) / 100 : 0;\n    };\n    /**\n     * Initialization\n     */\n    SpenttimeHandler.prototype.init = function (id /*id only for logging and tests*/) {\n        if (id === void 0) { id = 'container'; }\n        debug(\"INITED \\\"\".concat(id, \"\\\"\"));\n        this.startTime = null;\n        this.spenttime = 0;\n        this._wasChange = false;\n        this.state = SPENTTIME_STATES.inited;\n        addEventForCypress(EVENT.stateInited, id);\n    };\n    /**\n     * Reset\n     * used after sending data to the server\n     */\n    SpenttimeHandler.prototype.reset = function (id /*id only for logging and tests*/) {\n        if (id === void 0) { id = 'container'; }\n        if (this.state === SPENTTIME_STATES.done) {\n            return;\n        }\n        if (this.state === SPENTTIME_STATES.running) {\n            this.init(id);\n            this.run(id);\n        }\n        else {\n            this.init(id);\n        }\n    };\n    /**\n     * Starting the measurement of spenttime\n     */\n    SpenttimeHandler.prototype.run = function (id /*id only for logging and tests*/) {\n        if (id === void 0) { id = 'container'; }\n        if (this.state === SPENTTIME_STATES.running || this.state === SPENTTIME_STATES.done) {\n            return;\n        }\n        debug(\"RUN    \\\"\".concat(id, \"\\\"\"));\n        this.state = SPENTTIME_STATES.running;\n        this._wasChange = true;\n        this.startTime = new Date().getTime();\n        addEventForCypress(EVENT.stateRun, id);\n    };\n    /**\n     * Pausing the measurement of spenttime\n     */\n    SpenttimeHandler.prototype.pause = function (id /*id only for logging and tests*/) {\n        if (id === void 0) { id = 'container'; }\n        if (this.state !== SPENTTIME_STATES.running) {\n            return;\n        }\n        debug(\"PAUSE  \\\"\".concat(id, \"\\\"\"));\n        this.state = SPENTTIME_STATES.paused;\n        this.spenttime = this.getSpenttime();\n        this.startTime = null;\n        addEventForCypress(EVENT.statePaused, id);\n    };\n    /**\n     * Completing the measurement of spenttime\n     * Sending the result (time of spenttime) to the server (hit)\n     */\n    SpenttimeHandler.prototype.end = function () {\n        if (this.state === SPENTTIME_STATES.done) {\n            return;\n        }\n        debug('DONE');\n        this.state = SPENTTIME_STATES.done;\n        addEventForCypress(EVENT.stateDone);\n    };\n    return SpenttimeHandler;\n}());\nexport default SpenttimeHandler;\n","/**\n * checks that the string contains json\n * @param str String\n * @returns json - value is json or null\n */\nexport var jsonParse = function (str) {\n    try {\n        return JSON.parse(str);\n    }\n    catch (e) {\n        return null;\n    }\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { spenttimeDebug as debug } from '../modules/debug';\nimport SpenttimeHandler from './spenttime.class';\nimport { SPENTTIME_STATES } from '../constants';\nimport { sendStatistics } from '../modules/spenttime/measurement';\nimport { jsonParse } from '../utils/jsonParse';\n/**\n * Aggregator\n * All events call the methods of this class, which sets the current state\n * Based on the status, the measurement of the time spent is started, stopped, or data is sent to the server\n */\nvar StateSwitch = /** @class */ (function () {\n    /**\n     * Constructor\n     */\n    function StateSwitch(verifiedConfig) {\n        this._config = verifiedConfig;\n        this.containerIsVisible = false;\n        this.pageIsVisible = true;\n        this.userIsSleeping = false;\n        this.containerSpenttime = new SpenttimeHandler();\n        this.itemsState = {};\n    }\n    Object.defineProperty(StateSwitch.prototype, \"config\", {\n        get: function () {\n            return this._config;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    StateSwitch.prototype.getStatistics = function (reset) {\n        if (reset === void 0) { reset = false; }\n        // container\n        var data = {\n            time: this.containerSpenttime.getSpenttimeInSeconds(),\n        };\n        if (reset) {\n            this.containerSpenttime.reset();\n        }\n        // items\n        if (this.config.items) {\n            data.items = [];\n            for (var id in this.itemsState) {\n                if (this.itemsState[id].spenttime.wasChange) {\n                    var finalSpenttime = this.itemsState[id].spenttime.getSpenttimeInSeconds();\n                    if (finalSpenttime > 0) {\n                        var itemStatistic = __assign(__assign({}, this.itemsState[id].hitData), { id: id, time: finalSpenttime });\n                        data.items.push(itemStatistic);\n                    }\n                    else {\n                        if (this.itemsState[id].spenttime.getState() !== SPENTTIME_STATES.running && reset) {\n                            Reflect.deleteProperty(this.itemsState, id);\n                        }\n                    }\n                    if (this.itemsState[id] && reset) {\n                        this.itemsState[id].spenttime.reset(id);\n                    }\n                }\n            }\n        }\n        return data;\n    };\n    /**\n     * Starts or pauses the measurement of the spent time on the CONTAINER\n     */\n    StateSwitch.prototype.updateContainerSpenttimeAction = function () {\n        if (this.containerIsVisible && this.pageIsVisible && !this.userIsSleeping) {\n            this.containerSpenttime.run();\n        }\n        else {\n            this.containerSpenttime.pause();\n        }\n    };\n    StateSwitch.prototype.getState = function () {\n        return {\n            containerIsVisible: this.containerIsVisible,\n            pageIsVisible: this.pageIsVisible,\n            userIsSleeping: this.userIsSleeping,\n        };\n    };\n    /**\n     * Entry point for setting the new stat\n     * @param commonState object\n     */\n    StateSwitch.prototype.setState = function (commonState) {\n        var isChange = false;\n        // State update\n        if ('userIsSleeping' in commonState && this.userIsSleeping !== commonState.userIsSleeping) {\n            this.userIsSleeping = commonState.userIsSleeping;\n            isChange = true;\n        }\n        if ('containerIsVisible' in commonState && this.containerIsVisible !== commonState.containerIsVisible) {\n            this.containerIsVisible = commonState.containerIsVisible;\n            isChange = true;\n        }\n        if ('pageIsVisible' in commonState && this.pageIsVisible !== commonState.pageIsVisible) {\n            this.pageIsVisible = commonState.pageIsVisible;\n            isChange = true;\n        }\n        if (isChange) {\n            this.updateContainerSpenttimeAction();\n            if ('userIsSleeping' in commonState || 'pageIsVisible' in commonState) {\n                this.updateAllItemsSpenttimeAction();\n            }\n        }\n    };\n    /**\n     * Starts or pauses the measurement of the spent time on the ITEM\n     * @param id Item id\n     */\n    StateSwitch.prototype.updateItemSpenttimeAction = function (id) {\n        if (this.itemsState[id].isVisible && this.pageIsVisible && !this.userIsSleeping) {\n            this.itemsState[id].spenttime.run(id);\n            this.sendStatisticsIfEnoughItems();\n        }\n        else {\n            this.itemsState[id].spenttime.pause(id);\n        }\n    };\n    /**\n     * Starts or pauses the measurement of the spent time on the ALL ITEMS\n     */\n    StateSwitch.prototype.updateAllItemsSpenttimeAction = function () {\n        for (var id in this.itemsState) {\n            this.updateItemSpenttimeAction(id);\n        }\n    };\n    /**\n     * This method will be called from events when the item changes visibility\n     * @param id Item id\n     * @param itemIsVisible The item is visible (true) or not (false)\n     */\n    StateSwitch.prototype.setItemState = function (id, itemIsVisible, itemElement) {\n        if (itemElement === void 0) { itemElement = null; }\n        if (!this.config.items) {\n            return;\n        }\n        // new item\n        if (!(id in this.itemsState)) {\n            if (!itemIsVisible) {\n                return;\n            }\n            this.itemsState[id] = {\n                spenttime: new SpenttimeHandler(this.config.items.measurementStartDelay, id),\n                isVisible: itemIsVisible,\n                hitData: itemElement ? jsonParse(itemElement.getAttribute(this.config.items.attributeWithDopDetails)) : {},\n            };\n            this.updateItemSpenttimeAction(id);\n            return;\n        }\n        // existing item\n        if (this.itemsState[id].isVisible !== itemIsVisible) {\n            this.itemsState[id].isVisible = itemIsVisible;\n            this.updateItemSpenttimeAction(id);\n        }\n    };\n    /**\n     * Counts over how many items there was a measurement (number)\n     * and sends hit if number >= config.items.numberOfItemsInHit\n     */\n    StateSwitch.prototype.sendStatisticsIfEnoughItems = function () {\n        var number = 0;\n        for (var id in this.itemsState) {\n            if (this.itemsState[id].spenttime.wasChange && this.itemsState[id].spenttime.getSpenttimeInSeconds() > 0) {\n                number++;\n            }\n        }\n        debug(\"Current processed number of items: \".concat(number));\n        if (number >= this.config.items.numberOfItemsInHit) {\n            sendStatistics();\n        }\n    };\n    return StateSwitch;\n}());\nexport default StateSwitch;\n","/* eslint-disable no-undefined,no-param-reassign,no-shadow */\n\n/**\n * Throttle execution of a function. Especially useful for rate limiting\n * execution of handlers on events like resize and scroll.\n *\n * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)\n *                                            are most useful.\n * @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,\n *                                            as-is, to `callback` when the throttled-function is executed.\n * @param {object} [options] -              An object to configure options.\n * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds\n *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed\n *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for\n *                                            `delay` milliseconds, the internal counter is reset).\n * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback\n *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that\n *                                            callback will never executed if both noLeading = true and noTrailing = true.\n * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is\n *                                            false (at end), schedule `callback` to execute after `delay` ms.\n *\n * @returns {Function} A new, throttled, function.\n */\nfunction throttle (delay, callback, options) {\n  var _ref = options || {},\n      _ref$noTrailing = _ref.noTrailing,\n      noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,\n      _ref$noLeading = _ref.noLeading,\n      noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,\n      _ref$debounceMode = _ref.debounceMode,\n      debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;\n  /*\n   * After wrapper has stopped being called, this timeout ensures that\n   * `callback` is executed at the proper times in `throttle` and `end`\n   * debounce modes.\n   */\n\n\n  var timeoutID;\n  var cancelled = false; // Keep track of the last time `callback` was executed.\n\n  var lastExec = 0; // Function to clear existing timeout\n\n  function clearExistingTimeout() {\n    if (timeoutID) {\n      clearTimeout(timeoutID);\n    }\n  } // Function to cancel next exec\n\n\n  function cancel(options) {\n    var _ref2 = options || {},\n        _ref2$upcomingOnly = _ref2.upcomingOnly,\n        upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;\n\n    clearExistingTimeout();\n    cancelled = !upcomingOnly;\n  }\n  /*\n   * The `wrapper` function encapsulates all of the throttling / debouncing\n   * functionality and when executed will limit the rate at which `callback`\n   * is executed.\n   */\n\n\n  function wrapper() {\n    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {\n      arguments_[_key] = arguments[_key];\n    }\n\n    var self = this;\n    var elapsed = Date.now() - lastExec;\n\n    if (cancelled) {\n      return;\n    } // Execute `callback` and update the `lastExec` timestamp.\n\n\n    function exec() {\n      lastExec = Date.now();\n      callback.apply(self, arguments_);\n    }\n    /*\n     * If `debounceMode` is true (at begin) this is used to clear the flag\n     * to allow future `callback` executions.\n     */\n\n\n    function clear() {\n      timeoutID = undefined;\n    }\n\n    if (!noLeading && debounceMode && !timeoutID) {\n      /*\n       * Since `wrapper` is being called for the first time and\n       * `debounceMode` is true (at begin), execute `callback`\n       * and noLeading != true.\n       */\n      exec();\n    }\n\n    clearExistingTimeout();\n\n    if (debounceMode === undefined && elapsed > delay) {\n      if (noLeading) {\n        /*\n         * In throttle mode with noLeading, if `delay` time has\n         * been exceeded, update `lastExec` and schedule `callback`\n         * to execute after `delay` ms.\n         */\n        lastExec = Date.now();\n\n        if (!noTrailing) {\n          timeoutID = setTimeout(debounceMode ? clear : exec, delay);\n        }\n      } else {\n        /*\n         * In throttle mode without noLeading, if `delay` time has been exceeded, execute\n         * `callback`.\n         */\n        exec();\n      }\n    } else if (noTrailing !== true) {\n      /*\n       * In trailing throttle mode, since `delay` time has not been\n       * exceeded, schedule `callback` to execute `delay` ms after most\n       * recent execution.\n       *\n       * If `debounceMode` is true (at begin), schedule `clear` to execute\n       * after `delay` ms.\n       *\n       * If `debounceMode` is false (at end), schedule `callback` to\n       * execute after `delay` ms.\n       */\n      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);\n    }\n  }\n\n  wrapper.cancel = cancel; // Return the wrapper function.\n\n  return wrapper;\n}\n\n/* eslint-disable no-undefined */\n/**\n * Debounce execution of a function. Debouncing, unlike throttling,\n * guarantees that a function is only executed a single time, either at the\n * very beginning of a series of calls, or at the very end.\n *\n * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param {Function} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                        to `callback` when the debounced-function is executed.\n * @param {object} [options] -           An object to configure options.\n * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds\n *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.\n *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).\n *\n * @returns {Function} A new, debounced function.\n */\n\nfunction debounce (delay, callback, options) {\n  var _ref = options || {},\n      _ref$atBegin = _ref.atBegin,\n      atBegin = _ref$atBegin === void 0 ? false : _ref$atBegin;\n\n  return throttle(delay, callback, {\n    debounceMode: atBegin !== false\n  });\n}\n\nexport { debounce, throttle };\n//# sourceMappingURL=index.js.map\n","import { stateSwitch } from '../stateSwitch';\nimport { sendStatistics, completeMeasurement } from '../spenttime/measurement';\nimport { spenttimeDebug as debug } from '../debug';\nimport { throttle } from 'throttle-debounce';\nimport { THROTTLE_DELAY } from '../../constants';\n/**\n * Timer identifier of the countdown, that the user will soon fall asleep\n * (absent for some time and does not show activity)\n */\nvar timerIdUserFallsAsleep = null;\n/**\n * Timer identifier of the countdown, that the user will leave soon\n * (absent for a long time and does not show activity)\n */\nvar timerIdUserLeaves = null;\n/**\n * Starts the timer of user leaves\n * Аfter the time has expired, we believe that the user has left.\n */\nvar controlOfLeaving = function () {\n    timerIdUserLeaves = window.setTimeout(function () {\n        debug('[event] User leaves. Measurement will be completed');\n        sendStatistics();\n        completeMeasurement();\n    }, stateSwitch.config.forcedDepartureTime);\n};\n/**\n * Starts the timer of user's sleep\n * Аfter the time has expired, we believe that the user has fallen asleep.\n */\nvar controlOfFallingAsleep = function () {\n    timerIdUserFallsAsleep = window.setTimeout(function () {\n        debug('[event] User fells asleep');\n        stateSwitch.setState({ userIsSleeping: true });\n        sendStatistics();\n        controlOfLeaving();\n    }, stateSwitch.config.fallAsleepTime);\n};\n/**\n * Clear timer \"User falls asleep\" and timer \"User leaves\"\n */\nexport var clearTimers = function () {\n    if (timerIdUserFallsAsleep) {\n        clearTimeout(timerIdUserFallsAsleep);\n        timerIdUserFallsAsleep = null;\n    }\n    if (timerIdUserLeaves) {\n        clearTimeout(timerIdUserLeaves);\n        timerIdUserLeaves = null;\n    }\n};\n/**\n * Restart timers\n */\nexport var restartTimers = function () {\n    clearTimers();\n    controlOfFallingAsleep();\n};\n/**\n * Throttle of activity handler\n */\nvar activity = throttle(THROTTLE_DELAY, function () {\n    debug('[event] User is doing something (activity)');\n    stateSwitch.setState({ userIsSleeping: false, pageIsVisible: true });\n    restartTimers();\n});\n/**\n * unload event handler\n * Can set the state 'userLeaves'\n */\nvar unloadHandler = function () {\n    sendStatistics();\n    completeMeasurement();\n};\n/**\n * beforeunload event handler\n * Can set the state 'userLeaves'\n */\nvar beforeunloadHandler = function () {\n    sendStatistics();\n    completeMeasurement();\n};\n/**\n * activity ('mouseup', 'keyup', 'scroll', 'mousemove', 'touchend', 'touchmove', 'focus') event handler\n * Can set the state 'userIsSleeping'\n */\nvar activityHandler = function () {\n    activity();\n};\nexport var addUserActivityListeners = function () {\n    restartTimers();\n    window.addEventListener('unload', unloadHandler);\n    window.addEventListener('beforeunload', beforeunloadHandler);\n    window.addEventListener('focus', activityHandler);\n    // Catching user activity\n    window.addEventListener('mouseup', activityHandler);\n    window.addEventListener('mousemove', activityHandler);\n    window.addEventListener('keyup', activityHandler);\n    window.addEventListener('scroll', activityHandler);\n    window.addEventListener('touchend', activityHandler);\n    window.addEventListener('touchmove', activityHandler);\n    debug('[event] User activity event listeners have been added');\n};\nexport var removeUserActivityListeners = function () {\n    window.removeEventListener('unload', unloadHandler);\n    window.removeEventListener('beforeunload', beforeunloadHandler);\n    window.removeEventListener('focus', activityHandler);\n    window.removeEventListener('mouseup', activityHandler);\n    window.removeEventListener('mousemove', activityHandler);\n    window.removeEventListener('keyup', activityHandler);\n    window.removeEventListener('scroll', activityHandler);\n    window.removeEventListener('touchend', activityHandler);\n    window.removeEventListener('touchmove', activityHandler);\n    clearTimers();\n    debug('[event] User activity event listeners have been removed');\n};\n","import { sendStatistics } from '../spenttime/measurement';\nimport { clearTimers } from './userActivityEvents';\nimport { spenttimeDebug as debug } from '../debug';\nexport var loginHandler = function (e) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n    var changes = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.changes;\n    var isLoginChanged = changes.some(function (val) { return val === 'login'; });\n    if (!isLoginChanged) {\n        return;\n    }\n    var newUid = (_e = (_d = (_c = (_b = e.detail) === null || _b === void 0 ? void 0 : _b.newIdentities) === null || _c === void 0 ? void 0 : _c.login) === null || _d === void 0 ? void 0 : _d.value) === null || _e === void 0 ? void 0 : _e.uid;\n    var oldUid = (_j = (_h = (_g = (_f = e.detail) === null || _f === void 0 ? void 0 : _f.oldIdentities) === null || _g === void 0 ? void 0 : _g.login) === null || _h === void 0 ? void 0 : _h.value) === null || _j === void 0 ? void 0 : _j.uid;\n    debug(\"IS: New UID: \".concat(newUid, \", Old UID: \").concat(oldUid, \" \"));\n    if (newUid !== oldUid) {\n        debug('[event] User has been logged in a different account');\n        clearTimers();\n        sendStatistics();\n    }\n};\nexport var addUserLoginListener = function () {\n    debug('[event] User Login event listeners have been added');\n    window.addEventListener('szn:identities:beforeupdate', loginHandler);\n};\nexport var removeUserLoginListener = function () {\n    debug('[event] User Login event listeners have been removed');\n    window.removeEventListener('szn:identities:beforeupdate', loginHandler);\n};\n","import { stateSwitch } from '../stateSwitch';\nimport { spenttimeDebug as debug } from '../debug';\nimport { restartTimers } from './userActivityEvents';\n/**\n * visibilitychange event handler\n * Can set the state 'pageIsVisible' and 'userIsSleeping'\n */\nvar visibilitychangeHandler = function () {\n    debug(\"[event] Visibilitychange. User \".concat(document.hidden ? 'does not see' : 'sees', \" the page\"));\n    if (document.hidden) {\n        stateSwitch.setState({ pageIsVisible: false });\n    }\n    else {\n        stateSwitch.setState({ pageIsVisible: true, userIsSleeping: false });\n        restartTimers();\n    }\n};\n/**\n * blur event handler\n * Can set the state 'pageIsVisible'\n */\nvar blurHandler = function () {\n    debug('[event] Blur');\n    stateSwitch.setState({ pageIsVisible: false });\n};\nexport var addPageVisibilityListeners = function () {\n    window.addEventListener('visibilitychange', visibilitychangeHandler);\n    window.addEventListener('blur', blurHandler);\n    debug('[event] Page visibility event listeners have been added');\n};\nexport var removePageVisibilityListeners = function () {\n    window.removeEventListener('visibilitychange', visibilitychangeHandler);\n    window.removeEventListener('blur', blurHandler);\n    debug('[event] Page visibility event listeners have been removed');\n};\n","import { stateSwitch } from '../stateSwitch';\nimport { spenttimeDebug as debug } from '../debug';\nimport { restartTimers } from './userActivityEvents';\nvar containerIntersectionObserver = null;\n/**\n * The handler that is executed when the visibility of the container changes\n * Can set the state 'containerIsVisible'\n * @param entries Interface of the Intersection Observer\n */\nvar containerVisibilityHandler = function (entries) {\n    if (!Array.isArray(entries) || entries.length === 0) {\n        return;\n    }\n    var isIntersecting = entries[0].isIntersecting; // only container element\n    debug(\"Element is \".concat(isIntersecting ? '' : 'not ', \"visible \\\"container\\\"\"));\n    stateSwitch.setState({\n        containerIsVisible: isIntersecting,\n        userIsSleeping: false,\n        pageIsVisible: true,\n    });\n    if (isIntersecting) {\n        restartTimers();\n    }\n};\n/**\n * Adds container visibilitychange event handler\n */\nexport var addContainerVisibilityEventListener = function () {\n    containerIntersectionObserver = new IntersectionObserver(containerVisibilityHandler, {\n        threshold: [stateSwitch.config.container.intersectionThreshold],\n    });\n    debug({\n        message: \"[conta]: threshold = [\".concat(stateSwitch.config.container.intersectionThreshold, \"]\"),\n    });\n    containerIntersectionObserver.observe(stateSwitch.config.container.element);\n    debug('[event] Container visibility event listener have been added');\n};\n/**\n * Removes container visibilitychange event listener\n */\nexport var removeContainerVisibilityEventListener = function () {\n    containerIntersectionObserver.unobserve(stateSwitch.config.container.element);\n    containerIntersectionObserver = null;\n    debug('[event] Container visibility event listener have been disabled');\n};\n","import { spenttimeDebug as debug } from '../debug';\nimport { ITEM_MONITORED_ATTRIBUTE } from '../../constants';\nimport { stateSwitch } from '../stateSwitch';\nvar itemsIntersectionObserver = null;\n/**\n * The handler that is executed when the visibility of the items changes\n * Can set the state item 'isVisible'\n * @param entries Interface of the Intersection Observer\n */\nvar itemVisibilityHandler = function (entries) {\n    entries.forEach(function (_a) {\n        var element = _a.target, isIntersecting = _a.isIntersecting;\n        var id = element.getAttribute(stateSwitch.config.items.attributeWithDopId);\n        debug({ message: \"Element is \".concat(isIntersecting ? '' : 'not ', \"visible \\\"\").concat(id, \"\\\"\") });\n        stateSwitch.setItemState(id, isIntersecting, element);\n    });\n};\n/**\n * Create intersection observer for items\n */\nexport var createItemsIntersectionObserver = function () {\n    if (!stateSwitch.config.items) {\n        return;\n    }\n    var getMargin = function (areaSize) { return Math.round(100 - areaSize * 100); };\n    var rMargin = getMargin(stateSwitch.config.items.targetAreaWidth);\n    var bMargin = getMargin(stateSwitch.config.items.targetAreaHeight);\n    var formatMargin = function (margin) { return (margin > 0 ? \"-\".concat(margin, \"%\") : '0%'); };\n    var rootMargin = \"0% \".concat(formatMargin(rMargin), \" \").concat(formatMargin(bMargin), \" 0%\"); //top, right, bottom, left\n    itemsIntersectionObserver = new IntersectionObserver(itemVisibilityHandler, {\n        rootMargin: rootMargin,\n        threshold: [stateSwitch.config.items.intersectionThreshold],\n    });\n    debug({\n        message: \"[items]: rootMargin = \\\"\".concat(rootMargin, \"\\\", threshold = [\").concat(stateSwitch.config.items.intersectionThreshold, \"]\"),\n    });\n};\n/**\n * Adds items visibilitychange event handler\n */\nexport var addItemsVisibilityEventListeners = function () {\n    if (!(itemsIntersectionObserver && stateSwitch.config.items)) {\n        return;\n    }\n    //[data-analytics-spent-time-item]:not([data-analytics-spent-time-item-monitored])\n    var selectorWithoutMonitoredItems = stateSwitch.config.items.selector + \":not([\".concat(ITEM_MONITORED_ATTRIBUTE, \"])\");\n    var items = document.querySelectorAll(selectorWithoutMonitoredItems);\n    if (items.length === 0) {\n        return;\n    }\n    debug(\"[items] Number of tracked items: \".concat(items.length, \".\"));\n    items.forEach(function (element) {\n        if (element.hasAttribute(stateSwitch.config.items.attributeWithDopId)) {\n            itemsIntersectionObserver.observe(element);\n            element.setAttribute(ITEM_MONITORED_ATTRIBUTE, 'true');\n        }\n    });\n    debug('[event] Items visibility event listeners have been added');\n};\n/**\n * Removes items visibilitychange event listener\n */\nexport var removeItemsVisibilityEventListeners = function () {\n    var selectorMonitoredItems = stateSwitch.config.items.selector + \"[\".concat(ITEM_MONITORED_ATTRIBUTE, \"]\");\n    var items = document.querySelectorAll(selectorMonitoredItems);\n    items.forEach(function (element) {\n        itemsIntersectionObserver.unobserve(element);\n        element.removeAttribute(ITEM_MONITORED_ATTRIBUTE);\n    });\n    itemsIntersectionObserver = null;\n    debug('[event] Items visibility event listeners have been disabled');\n};\n","import { stateSwitch } from '../stateSwitch';\nimport { addItemsVisibilityEventListeners } from './itemsVisibilityEvents';\nimport { spenttimeDebug as debug } from '../debug';\nvar containerMutationObserver = null;\n/**\n * The handler that is executed when the container has been changed\n */\nvar containerMutationHandler = function () {\n    addItemsVisibilityEventListeners();\n};\n/**\n * Adds container mutation event handler\n */\nexport var addContainerMutationEventListener = function () {\n    if (!('MutationObserver' in window)) {\n        return;\n    }\n    // Create an observer instance\n    containerMutationObserver = new MutationObserver(containerMutationHandler);\n    // Options for the observer (which mutations to observe)\n    var config = { childList: true, subtree: true };\n    // Start observing the target node for configured mutations\n    containerMutationObserver.observe(stateSwitch.config.container.element, config);\n    debug('[event] Container mutation event listener have been added');\n};\n/**\n * Removes container mutation event listener\n */\nexport var removeContainerMutationEventListener = function () {\n    if (!('MutationObserver' in window)) {\n        return;\n    }\n    // stop observing\n    containerMutationObserver.disconnect();\n    containerMutationObserver = null;\n    debug('[event] Container mutation event listener have been disabled');\n};\n","import { stateSwitch } from '../stateSwitch';\nimport { addUserActivityListeners, removeUserActivityListeners } from './userActivityEvents';\nimport { addUserLoginListener, removeUserLoginListener } from './userLoginEvents';\nimport { addPageVisibilityListeners, removePageVisibilityListeners } from './pageVisibilityEvents';\nimport { addContainerVisibilityEventListener, removeContainerVisibilityEventListener, } from './containerVisibilityEvents';\nimport { createItemsIntersectionObserver, addItemsVisibilityEventListeners, removeItemsVisibilityEventListeners, } from './itemsVisibilityEvents';\nimport { addContainerMutationEventListener, removeContainerMutationEventListener } from './containerMutationEvents';\n/**\n * Adds all event listeners\n */\nexport var addAllListeners = function () {\n    addUserActivityListeners();\n    addUserLoginListener();\n    addPageVisibilityListeners();\n    addContainerVisibilityEventListener();\n    if (stateSwitch.config.items) {\n        createItemsIntersectionObserver();\n        addItemsVisibilityEventListeners();\n        addContainerMutationEventListener();\n    }\n};\n/**\n * Removes all dependent event listeners\n */\nexport var removeAllListeners = function () {\n    if (stateSwitch.config.items) {\n        removeContainerMutationEventListener();\n        removeItemsVisibilityEventListeners();\n    }\n    removeContainerVisibilityEventListener();\n    removePageVisibilityListeners();\n    removeUserLoginListener();\n    removeUserActivityListeners();\n};\n","import StateSwitch from '../classes/stateSwitch.class';\nimport { addAllListeners, removeAllListeners } from '../modules/events';\n// GLOBAL\nexport var stateSwitch = null;\n/**\n * Сreates a global object stateSwitch and\n * After сreates and configures all dependent event listeners\n */\nexport var createStateSwitch = function (verifiedConfig) {\n    stateSwitch = new StateSwitch(verifiedConfig);\n    window.sznIVA.spenttime.conf = function () { return stateSwitch.config; };\n    addAllListeners();\n};\n/**\n * Remove all dependent event listeners and a global object stateSwitch\n */\nexport var removeStateSwitch = function () {\n    removeAllListeners();\n    window.sznIVA.spenttime.conf = function () { return null; };\n    stateSwitch = null;\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { DEBUG_STATES, spenttimeDebug as debug } from '../debug';\nimport { saveHitData } from '../hit';\nimport { isDotConfigured, waitingForDOT } from '../dot';\nimport { getVerifiedConfig } from '../config/config';\nimport { stateSwitch, createStateSwitch, removeStateSwitch } from '../stateSwitch';\nimport { addEventForCypress } from '../../utils/addCustomEvent';\nimport { EVENT } from '../../constants';\nimport { sendHit } from '../../modules/hit';\n/**\n * Cleaning after measurement\n */\nexport var completeMeasurement = function () {\n    addEventForCypress(EVENT.stateDone);\n    removeStateSwitch();\n    debug({\n        message: \"The public \\\"spenttime.startMeasurement\\\" method has been completed\",\n        state: DEBUG_STATES.DONE,\n    });\n};\n/**\n * Sends the current collected data\n */\nexport var sendStatistics = function () {\n    var statistics = stateSwitch.getStatistics(true);\n    if (statistics.time === 0 && (stateSwitch.config.items ? statistics.items.length === 0 : true)) {\n        return;\n    }\n    sendHit(statistics);\n};\n/**\n * The main method that starts all processes for measuring the spenttime by the user on the target element\n * @param element HTMLElement or element Id or selector\n * @param hitData Data to be sent to the server in hit\n * @param configuration Object with incoming configuration\n */\nexport var startMeasurement = function (element, hitData, configuration) {\n    // if the measurement was previously started, then we finish it correctly\n    if (stateSwitch) {\n        debug({ message: 'Correct completion of the previous measurement of spenttime' });\n        sendStatistics();\n        completeMeasurement();\n    }\n    debug({\n        message: 'The public \"spenttime.startMeasurement\" method was started',\n        state: DEBUG_STATES.START,\n    });\n    debug(__assign({ message: 'Incoming parameters:' }, { element: element, hitData: hitData, configuration: configuration }));\n    if (!('IntersectionObserver' in window)) {\n        debug({\n            message: \"It is not possible to make a measurement on this device\",\n            state: DEBUG_STATES.DONE,\n        });\n        addEventForCypress(EVENT.measurementWillNotBePerformed);\n        return;\n    }\n    saveHitData(hitData);\n    var verifiedConfig = getVerifiedConfig(element, __assign({}, configuration));\n    if (!verifiedConfig) {\n        debug({\n            message: \"[CONF] Measuring the spent time is not possible. The public \\\"startMeasurement\\\" function has been completed\",\n            state: DEBUG_STATES.DONE,\n        });\n        addEventForCypress(EVENT.measurementWillNotBePerformed);\n        return;\n    }\n    // passing the subsequent handler and its input parameters\n    if (!isDotConfigured()) {\n        waitingForDOT();\n    }\n    createStateSwitch(verifiedConfig);\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport './types/globals';\nimport { spenttimeDebug as debug } from './modules/debug';\nimport { startMeasurement } from './modules/spenttime/measurement';\n/**\n * Expose to global object\n */\nvar output = {\n    startMeasurement: startMeasurement,\n    conf: function () { return null; },\n};\n/**\n * The main method. Initializing\n */\nvar initComponentSpenttime = function () {\n    window.sznIVA = __assign(__assign({}, (window.sznIVA || {})), { spenttime: output });\n    debug('window.sznIVA.spenttime added to the window-object');\n};\ninitComponentSpenttime();\nexport default output;\n"],"names":["HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","boolTag","dateTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","g","Object","freeSelf","self","root","Function","freeExports","exports","nodeType","freeModule","module","moduleExports","addMapEntry","map","pair","set","addSetEntry","value","add","arrayReduce","array","iteratee","accumulator","initAccum","index","length","isHostObject","result","toString","e","mapToArray","Array","size","forEach","key","overArg","func","transform","arg","setToArray","uid","arrayProto","prototype","funcProto","objectProto","coreJsData","maskSrcKey","exec","keys","IE_PROTO","funcToString","hasOwnProperty","objectToString","reIsNative","RegExp","call","replace","Buffer","undefined","Symbol","Uint8Array","getPrototype","getPrototypeOf","objectCreate","create","propertyIsEnumerable","splice","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","DataView","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","Hash","entries","this","clear","entry","ListCache","MapCache","Stack","__data__","arrayLikeKeys","inherited","isArray","isObjectLike","isArrayLike","isArrayLikeObject","isArguments","n","baseTimes","String","skipIndexes","isIndex","push","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","constructor","input","initCloneArray","source","copyArray","tag","getTag","isFunc","buffer","slice","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","Ctor","cloneArrayBuffer","dataView","byteOffset","byteLength","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","symbol","initCloneByTag","stacked","get","props","keysFunc","symbolsFunc","values","offset","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","baseIsNative","isFunction","test","arrayBuffer","newValue","getMapData","type","data","getValue","has","pop","cache","pairs","LARGE_ARRAY_SIZE","other","ArrayBuffer","resolve","ctorString","isLength","baseKeys","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","d","a","definition","o","defineProperty","enumerable","globalThis","window","obj","prop","nmd","paths","children","log","config","arguments","subName","name","fColor","bColor","style","badge","_len","messages","_key","messagesCopy","v","cloneDeep","console","table","ENABLER","EVENT_PREFIX","DEFAULTS","isTopLevel","win","top","Cypress","frameElement","getGlobalDebuggerObject","_a","sznIVA","debugger","upsertGlobalDebuggerObject","windowObject","assign","getParamValue","param","queryString","location","search","paramRegex","matches","match","getDebuggerRule","paramValue","topFrameRule","getTopFrameRule","localStorageRule","localStorage","getItem","error","getInternalConfig","JSON","stringify","__rest","s","t","p","indexOf","i","addEventListener","event","rule","postMessage","iframeBridgeNotified","handlerFromChildMessage","handlerFromTopMessage","document","referrer","DEVICE_TYPE","__assign","apply","DEBUG_STATES","debug","permanentEnabler","_b","_c","lastValue","removeItem","setItem","types","args","argsCount","shouldLog","welcomeNotified","findNameInValue","toLowerCase","getShouldLog","state","message","logArgs","status","EVENT_TYPE","detail","CustomEvent","dispatchEvent","debugFactory","spenttimeDebug","_i","time","Intl","DateTimeFormat","hour","minute","second","format","Date","EVENT","SPENTTIME_STATES","ITEM_MONITORED_ATTRIBUTE","DEFAULT_CONFIG","container","intersectionThreshold","mobile","measuring","fallAsleepTime","forcedDepartureTime","desktop","DEFAULT_ITEMS_CONFIG","numberOfItemsInHit","attributeWithDopDetails","measurementStartDelay","targetAreaHeight","targetAreaWidth","addEventForCypress","eventName","dotConfigured","isDotConfigured","DOT","isConfigured","commonHitData","action","sendHit","finalHitData","getHitData","hit","getContainerElement","incomingElement","element","elementId","body","contains","elementById","getElementById","querySelector","getElement","isPercent","num","getVerifiedItemsConfig","incomingItemsConfig","deviceType","selector","createDocumentFragment","isSelectorValid","attributeWithDopId","trim","deviceItemsConfig","getVerifiedConfig","incomingConfig","concat","navigator","userAgent","MOBILE","DESKTOP","deviceConfig","isUserActivityTimeCorrect","device","itemsConfig","items","SpenttimeHandler","delay","startTime","spenttime","_wasChange","init","_state","configurable","getState","getSpenttime","spenttimeWithDelay","getTime","finalSpenttime","getSpenttimeInSeconds","parseInt","inited","stateInited","reset","done","running","run","stateRun","pause","paused","statePaused","end","stateDone","jsonParse","str","parse","StateSwitch","verifiedConfig","_config","containerIsVisible","pageIsVisible","userIsSleeping","containerSpenttime","itemsState","getStatistics","wasChange","itemStatistic","hitData","Reflect","deleteProperty","updateContainerSpenttimeAction","setState","commonState","isChange","updateAllItemsSpenttimeAction","updateItemSpenttimeAction","isVisible","sendStatisticsIfEnoughItems","setItemState","itemIsVisible","itemElement","getAttribute","number","sendStatistics","throttle","callback","options","timeoutID","_ref","_ref$noTrailing","noTrailing","_ref$noLeading","noLeading","_ref$debounceMode","debounceMode","cancelled","lastExec","clearExistingTimeout","clearTimeout","wrapper","arguments_","elapsed","now","setTimeout","cancel","_ref2$upcomingOnly","upcomingOnly","timerIdUserFallsAsleep","timerIdUserLeaves","controlOfFallingAsleep","stateSwitch","completeMeasurement","clearTimers","restartTimers","activity","unloadHandler","beforeunloadHandler","activityHandler","loginHandler","_d","_e","_f","_g","_h","_j","changes","some","val","newUid","newIdentities","login","oldUid","oldIdentities","visibilitychangeHandler","hidden","blurHandler","containerIntersectionObserver","containerVisibilityHandler","isIntersecting","itemsIntersectionObserver","itemVisibilityHandler","target","addItemsVisibilityEventListeners","selectorWithoutMonitoredItems","querySelectorAll","hasAttribute","observe","setAttribute","containerMutationObserver","containerMutationHandler","addAllListeners","IntersectionObserver","threshold","getMargin","areaSize","Math","round","rMargin","bMargin","formatMargin","margin","rootMargin","createItemsIntersectionObserver","MutationObserver","childList","subtree","removeAllListeners","selectorMonitoredItems","disconnect","unobserve","removeAttribute","removeEventListener","conf","statistics","output","startMeasurement","configuration","measurementWillNotBePerformed","waitingForDot","createStateSwitch"],"sourceRoot":""}