{"version":3,"file":"js/759-629d939c38e2ce5352c8.js","mappings":"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","sources":["webpack://hover-mainsite/./node_modules/seamless-immutable/src/seamless-immutable.js"],"sourcesContent":["(function() {\n  \"use strict\";\n\n  // https://github.com/facebook/react/blob/v15.0.1/src/isomorphic/classic/element/ReactElement.js#L21\n  var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol.for && Symbol.for('react.element');\n  var REACT_ELEMENT_TYPE_FALLBACK = 0xeac7;\n\n  function addPropertyTo(target, methodName, value) {\n    Object.defineProperty(target, methodName, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: value\n    });\n  }\n\n  function banProperty(target, methodName) {\n    addPropertyTo(target, methodName, function() {\n      throw new ImmutableError(\"The \" + methodName +\n        \" method cannot be invoked on an Immutable data structure.\");\n    });\n  }\n\n  var immutabilityTag = \"__immutable_invariants_hold\";\n\n  function addImmutabilityTag(target) {\n    addPropertyTo(target, immutabilityTag, true);\n  }\n\n  function isImmutable(target) {\n    if (typeof target === \"object\") {\n      return target === null || Boolean(\n        Object.getOwnPropertyDescriptor(target, immutabilityTag)\n      );\n    } else {\n      // In JavaScript, only objects are even potentially mutable.\n      // strings, numbers, null, and undefined are all naturally immutable.\n      return true;\n    }\n  }\n\n  function isEqual(a, b) {\n    // Avoid false positives due to (NaN !== NaN) evaluating to true\n    return (a === b || (a !== a && b !== b));\n  }\n\n  function isMergableObject(target) {\n    return target !== null && typeof target === \"object\" && !(Array.isArray(target)) && !(target instanceof Date);\n  }\n\n  var mutatingObjectMethods = [\n    \"setPrototypeOf\"\n  ];\n\n  var nonMutatingObjectMethods = [\n    \"keys\"\n  ];\n\n  var mutatingArrayMethods = mutatingObjectMethods.concat([\n    \"push\", \"pop\", \"sort\", \"splice\", \"shift\", \"unshift\", \"reverse\"\n  ]);\n\n  var nonMutatingArrayMethods = nonMutatingObjectMethods.concat([\n    \"map\", \"filter\", \"slice\", \"concat\", \"reduce\", \"reduceRight\"\n  ]);\n\n  var mutatingDateMethods = mutatingObjectMethods.concat([\n    \"setDate\", \"setFullYear\", \"setHours\", \"setMilliseconds\", \"setMinutes\", \"setMonth\", \"setSeconds\",\n    \"setTime\", \"setUTCDate\", \"setUTCFullYear\", \"setUTCHours\", \"setUTCMilliseconds\", \"setUTCMinutes\",\n    \"setUTCMonth\", \"setUTCSeconds\", \"setYear\"\n  ]);\n\n  function ImmutableError(message) {\n    var err       = new Error(message);\n    // TODO: Consider `Object.setPrototypeOf(err, ImmutableError);`\n    err.__proto__ = ImmutableError;\n\n    return err;\n  }\n  ImmutableError.prototype = Error.prototype;\n\n  function makeImmutable(obj, bannedMethods) {\n    // Tag it so we can quickly tell it's immutable later.\n    addImmutabilityTag(obj);\n\n    if (process.env.NODE_ENV !== \"production\") {\n      // Make all mutating methods throw exceptions.\n      for (var index in bannedMethods) {\n        if (bannedMethods.hasOwnProperty(index)) {\n          banProperty(obj, bannedMethods[index]);\n        }\n      }\n\n      // Freeze it and return it.\n      Object.freeze(obj);\n    }\n\n    return obj;\n  }\n\n  function makeMethodReturnImmutable(obj, methodName) {\n    var currentMethod = obj[methodName];\n\n    addPropertyTo(obj, methodName, function() {\n      return Immutable(currentMethod.apply(obj, arguments));\n    });\n  }\n\n  function arraySet(idx, value, config) {\n    var deep          = config && config.deep;\n\n    if (idx in this) {\n      if (deep && this[idx] !== value && isMergableObject(value) && isMergableObject(this[idx])) {\n        value = this[idx].merge(value, {deep: true, mode: 'replace'});\n      }\n      if (isEqual(this[idx], value)) {\n        return this;\n      }\n    }\n\n    var mutable = asMutableArray.call(this);\n    mutable[idx] = Immutable(value);\n    return makeImmutableArray(mutable);\n  }\n\n  var immutableEmptyArray = Immutable([]);\n\n  function arraySetIn(pth, value, config) {\n    var head = pth[0];\n\n    if (pth.length === 1) {\n      return arraySet.call(this, head, value, config);\n    } else {\n      var tail = pth.slice(1);\n      var thisHead = this[head];\n      var newValue;\n\n      if (typeof(thisHead) === \"object\" && thisHead !== null && typeof(thisHead.setIn) === \"function\") {\n        // Might (validly) be object or array\n        newValue = thisHead.setIn(tail, value);\n      } else {\n        var nextHead = tail[0];\n        // If the next path part is a number, then we are setting into an array, else an object.\n        if (nextHead !== '' && isFinite(nextHead)) {\n          newValue = arraySetIn.call(immutableEmptyArray, tail, value);\n        } else {\n          newValue = objectSetIn.call(immutableEmptyObject, tail, value);\n        }\n      }\n\n      if (head in this && thisHead === newValue) {\n        return this;\n      }\n\n      var mutable = asMutableArray.call(this);\n      mutable[head] = newValue;\n      return makeImmutableArray(mutable);\n    }\n  }\n\n  function makeImmutableArray(array) {\n    // Don't change their implementations, but wrap these functions to make sure\n    // they always return an immutable value.\n    for (var index in nonMutatingArrayMethods) {\n      if (nonMutatingArrayMethods.hasOwnProperty(index)) {\n        var methodName = nonMutatingArrayMethods[index];\n        makeMethodReturnImmutable(array, methodName);\n      }\n    }\n\n    addPropertyTo(array, \"flatMap\",  flatMap);\n    addPropertyTo(array, \"asObject\", asObject);\n    addPropertyTo(array, \"asMutable\", asMutableArray);\n    addPropertyTo(array, \"set\", arraySet);\n    addPropertyTo(array, \"setIn\", arraySetIn);\n    addPropertyTo(array, \"update\", update);\n    addPropertyTo(array, \"updateIn\", updateIn);\n\n    for(var i = 0, length = array.length; i < length; i++) {\n      array[i] = Immutable(array[i]);\n    }\n\n    return makeImmutable(array, mutatingArrayMethods);\n  }\n\n  function makeImmutableDate(date) {\n    addPropertyTo(date, \"asMutable\", asMutableDate);\n\n    return makeImmutable(date, mutatingDateMethods);\n  }\n\n  function asMutableDate() {\n    return new Date(this.getTime());\n  }\n\n  /**\n   * Effectively performs a map() over the elements in the array, using the\n   * provided iterator, except that whenever the iterator returns an array, that\n   * array's elements are added to the final result instead of the array itself.\n   *\n   * @param {function} iterator - The iterator function that will be invoked on each element in the array. It will receive three arguments: the current value, the current index, and the current object.\n   */\n  function flatMap(iterator) {\n    // Calling .flatMap() with no arguments is a no-op. Don't bother cloning.\n    if (arguments.length === 0) {\n      return this;\n    }\n\n    var result = [],\n        length = this.length,\n        index;\n\n    for (index = 0; index < length; index++) {\n      var iteratorResult = iterator(this[index], index, this);\n\n      if (Array.isArray(iteratorResult)) {\n        // Concatenate Array results into the return value we're building up.\n        result.push.apply(result, iteratorResult);\n      } else {\n        // Handle non-Array results the same way map() does.\n        result.push(iteratorResult);\n      }\n    }\n\n    return makeImmutableArray(result);\n  }\n\n  /**\n   * Returns an Immutable copy of the object without the given keys included.\n   *\n   * @param {array} keysToRemove - A list of strings representing the keys to exclude in the return value. Instead of providing a single array, this method can also be called by passing multiple strings as separate arguments.\n   */\n  function without(remove) {\n    // Calling .without() with no arguments is a no-op. Don't bother cloning.\n    if (typeof remove === \"undefined\" && arguments.length === 0) {\n      return this;\n    }\n\n    if (typeof remove !== \"function\") {\n      // If we weren't given an array, use the arguments list.\n      var keysToRemoveArray = (Array.isArray(remove)) ?\n         remove.slice() : Array.prototype.slice.call(arguments);\n\n      // Convert numeric keys to strings since that's how they'll\n      // come from the enumeration of the object.\n      keysToRemoveArray.forEach(function(el, idx, arr) {\n        if(typeof(el) === \"number\") {\n          arr[idx] = el.toString();\n        }\n      });\n\n      remove = function(val, key) {\n        return keysToRemoveArray.indexOf(key) !== -1;\n      };\n    }\n\n    var result = this.instantiateEmptyObject();\n\n    for (var key in this) {\n      if (this.hasOwnProperty(key) && remove(this[key], key) === false) {\n        result[key] = this[key];\n      }\n    }\n\n    return makeImmutableObject(result,\n      {instantiateEmptyObject: this.instantiateEmptyObject});\n  }\n\n  function asMutableArray(opts) {\n    var result = [], i, length;\n\n    if(opts && opts.deep) {\n      for(i = 0, length = this.length; i < length; i++) {\n        result.push(asDeepMutable(this[i]));\n      }\n    } else {\n      for(i = 0, length = this.length; i < length; i++) {\n        result.push(this[i]);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Effectively performs a [map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) over the elements in the array, expecting that the iterator function\n   * will return an array of two elements - the first representing a key, the other\n   * a value. Then returns an Immutable Object constructed of those keys and values.\n   *\n   * @param {function} iterator - A function which should return an array of two elements - the first representing the desired key, the other the desired value.\n   */\n  function asObject(iterator) {\n    // If no iterator was provided, assume the identity function\n    // (suggesting this array is already a list of key/value pairs.)\n    if (typeof iterator !== \"function\") {\n      iterator = function(value) { return value; };\n    }\n\n    var result = {},\n        length = this.length,\n        index;\n\n    for (index = 0; index < length; index++) {\n      var pair  = iterator(this[index], index, this),\n          key   = pair[0],\n          value = pair[1];\n\n      result[key] = value;\n    }\n\n    return makeImmutableObject(result);\n  }\n\n  function asDeepMutable(obj) {\n    if (\n      (!obj) ||\n      (typeof obj !== 'object') ||\n      (!Object.getOwnPropertyDescriptor(obj, immutabilityTag)) ||\n      (obj instanceof Date)\n    ) { return obj; }\n    return obj.asMutable({deep: true});\n  }\n\n  function quickCopy(src, dest) {\n    for (var key in src) {\n      if (Object.getOwnPropertyDescriptor(src, key)) {\n        dest[key] = src[key];\n      }\n    }\n\n    return dest;\n  }\n\n  /**\n   * Returns an Immutable Object containing the properties and values of both\n   * this object and the provided object, prioritizing the provided object's\n   * values whenever the same key is present in both objects.\n   *\n   * @param {object} other - The other object to merge. Multiple objects can be passed as an array. In such a case, the later an object appears in that list, the higher its priority.\n   * @param {object} config - Optional config object that contains settings. Supported settings are: {deep: true} for deep merge and {merger: mergerFunc} where mergerFunc is a function\n   *                          that takes a property from both objects. If anything is returned it overrides the normal merge behaviour.\n   */\n  function merge(other, config) {\n    // Calling .merge() with no arguments is a no-op. Don't bother cloning.\n    if (arguments.length === 0) {\n      return this;\n    }\n\n    if (other === null || (typeof other !== \"object\")) {\n      throw new TypeError(\"Immutable#merge can only be invoked with objects or arrays, not \" + JSON.stringify(other));\n    }\n\n    var receivedArray = (Array.isArray(other)),\n        deep          = config && config.deep,\n        mode          = config && config.mode || 'merge',\n        merger        = config && config.merger,\n        result;\n\n    // Use the given key to extract a value from the given object, then place\n    // that value in the result object under the same key. If that resulted\n    // in a change from this object's value at that key, set anyChanges = true.\n    function addToResult(currentObj, otherObj, key) {\n      var immutableValue = Immutable(otherObj[key]);\n      var mergerResult = merger && merger(currentObj[key], immutableValue, config);\n      var currentValue = currentObj[key];\n\n      if ((result !== undefined) ||\n        (mergerResult !== undefined) ||\n        (!currentObj.hasOwnProperty(key)) ||\n        !isEqual(immutableValue, currentValue)) {\n\n        var newValue;\n\n        if (mergerResult) {\n          newValue = mergerResult;\n        } else if (deep && isMergableObject(currentValue) && isMergableObject(immutableValue)) {\n          newValue = currentValue.merge(immutableValue, config);\n        } else {\n          newValue = immutableValue;\n        }\n\n        if (!isEqual(currentValue, newValue) || !currentObj.hasOwnProperty(key)) {\n          if (result === undefined) {\n            // Make a shallow clone of the current object.\n            result = quickCopy(currentObj, currentObj.instantiateEmptyObject());\n          }\n\n          result[key] = newValue;\n        }\n      }\n    }\n\n    function clearDroppedKeys(currentObj, otherObj) {\n      for (var key in currentObj) {\n        if (!otherObj.hasOwnProperty(key)) {\n          if (result === undefined) {\n            // Make a shallow clone of the current object.\n            result = quickCopy(currentObj, currentObj.instantiateEmptyObject());\n          }\n          delete result[key];\n        }\n      }\n    }\n\n    var key;\n\n    // Achieve prioritization by overriding previous values that get in the way.\n    if (!receivedArray) {\n      // The most common use case: just merge one object into the existing one.\n      for (key in other) {\n        if (Object.getOwnPropertyDescriptor(other, key)) {\n          addToResult(this, other, key);\n        }\n      }\n      if (mode === 'replace') {\n        clearDroppedKeys(this, other);\n      }\n    } else {\n      // We also accept an Array\n      for (var index = 0, length = other.length; index < length; index++) {\n        var otherFromArray = other[index];\n\n        for (key in otherFromArray) {\n          if (otherFromArray.hasOwnProperty(key)) {\n            addToResult(result !== undefined ? result : this, otherFromArray, key);\n          }\n        }\n      }\n    }\n\n    if (result === undefined) {\n      return this;\n    } else {\n      return makeImmutableObject(result,\n        {instantiateEmptyObject: this.instantiateEmptyObject});\n    }\n  }\n\n  function objectReplace(value, config) {\n    var deep          = config && config.deep;\n\n    // Calling .replace() with no arguments is a no-op. Don't bother cloning.\n    if (arguments.length === 0) {\n      return this;\n    }\n\n    if (value === null || typeof value !== \"object\") {\n      throw new TypeError(\"Immutable#replace can only be invoked with objects or arrays, not \" + JSON.stringify(value));\n    }\n\n    return this.merge(value, {deep: deep, mode: 'replace'});\n  }\n\n  var immutableEmptyObject = Immutable({});\n\n  function objectSetIn(path, value, config) {\n    var head = path[0];\n    if (path.length === 1) {\n      return objectSet.call(this, head, value, config);\n    }\n\n    var tail = path.slice(1);\n    var newValue;\n    var thisHead = this[head];\n\n    if (this.hasOwnProperty(head) && typeof(thisHead) === \"object\" && thisHead !== null && typeof(thisHead.setIn) === \"function\") {\n      // Might (validly) be object or array\n      newValue = thisHead.setIn(tail, value);\n    } else {\n      newValue = objectSetIn.call(immutableEmptyObject, tail, value);\n    }\n\n    if (this.hasOwnProperty(head) && thisHead === newValue) {\n      return this;\n    }\n\n    var mutable = quickCopy(this, this.instantiateEmptyObject());\n    mutable[head] = newValue;\n    return makeImmutableObject(mutable, this);\n  }\n\n  function objectSet(property, value, config) {\n    var deep          = config && config.deep;\n\n    if (this.hasOwnProperty(property)) {\n      if (deep && this[property] !== value && isMergableObject(value) && isMergableObject(this[property])) {\n        value = this[property].merge(value, {deep: true, mode: 'replace'});\n      }\n      if (isEqual(this[property], value)) {\n        return this;\n      }\n    }\n\n    var mutable = quickCopy(this, this.instantiateEmptyObject());\n    mutable[property] = Immutable(value);\n    return makeImmutableObject(mutable, this);\n  }\n\n  function update(property, updater) {\n    var restArgs = Array.prototype.slice.call(arguments, 2);\n    var initialVal = this[property];\n    return this.set(property, updater.apply(initialVal, [initialVal].concat(restArgs)));\n  }\n\n  function getInPath(obj, path) {\n    /*jshint eqnull:true */\n    for (var i = 0, l = path.length; obj != null && i < l; i++) {\n      obj = obj[path[i]];\n    }\n\n    return (i && i == l) ? obj : undefined;\n  }\n\n  function updateIn(path, updater) {\n    var restArgs = Array.prototype.slice.call(arguments, 2);\n    var initialVal = getInPath(this, path);\n\n    return this.setIn(path, updater.apply(initialVal, [initialVal].concat(restArgs)));\n  }\n\n  function asMutableObject(opts) {\n    var result = this.instantiateEmptyObject(), key;\n\n    if(opts && opts.deep) {\n      for (key in this) {\n        if (this.hasOwnProperty(key)) {\n          result[key] = asDeepMutable(this[key]);\n        }\n      }\n    } else {\n      for (key in this) {\n        if (this.hasOwnProperty(key)) {\n          result[key] = this[key];\n        }\n      }\n    }\n\n    return result;\n  }\n\n  // Creates plain object to be used for cloning\n  function instantiatePlainObject() {\n    return {};\n  }\n\n  // Finalizes an object with immutable methods, freezes it, and returns it.\n  function makeImmutableObject(obj, options) {\n    var instantiateEmptyObject =\n      (options && options.instantiateEmptyObject) ?\n        options.instantiateEmptyObject : instantiatePlainObject;\n\n    addPropertyTo(obj, \"merge\", merge);\n    addPropertyTo(obj, \"replace\", objectReplace);\n    addPropertyTo(obj, \"without\", without);\n    addPropertyTo(obj, \"asMutable\", asMutableObject);\n    addPropertyTo(obj, \"instantiateEmptyObject\", instantiateEmptyObject);\n    addPropertyTo(obj, \"set\", objectSet);\n    addPropertyTo(obj, \"setIn\", objectSetIn);\n    addPropertyTo(obj, \"update\", update);\n    addPropertyTo(obj, \"updateIn\", updateIn);\n\n    return makeImmutable(obj, mutatingObjectMethods);\n  }\n\n  // Returns true if object is a valid react element\n  // https://github.com/facebook/react/blob/v15.0.1/src/isomorphic/classic/element/ReactElement.js#L326\n  function isReactElement(obj) {\n    return typeof obj === 'object' &&\n           obj !== null &&\n           (obj.$$typeof === REACT_ELEMENT_TYPE_FALLBACK || obj.$$typeof === REACT_ELEMENT_TYPE);\n  }\n\n  function Immutable(obj, options, stackRemaining) {\n    if (isImmutable(obj) || isReactElement(obj)) {\n      return obj;\n    } else if (Array.isArray(obj)) {\n      return makeImmutableArray(obj.slice());\n    } else if (obj instanceof Date) {\n      return makeImmutableDate(new Date(obj.getTime()));\n    } else {\n      // Don't freeze the object we were given; make a clone and use that.\n      var prototype = options && options.prototype;\n      var instantiateEmptyObject =\n        (!prototype || prototype === Object.prototype) ?\n          instantiatePlainObject : (function() { return Object.create(prototype); });\n      var clone = instantiateEmptyObject();\n\n      if (process.env.NODE_ENV !== \"production\") {\n        /*jshint eqnull:true */\n        if (stackRemaining == null) {\n          stackRemaining = 64;\n        }\n        if (stackRemaining <= 0) {\n          throw new ImmutableError(\"Attempt to construct Immutable from a deeply nested object was detected.\" +\n            \" Have you tried to wrap an object with circular references (e.g. React element)?\" +\n            \" See https://github.com/rtfeldman/seamless-immutable/wiki/Deeply-nested-object-was-detected for details.\");\n        }\n        stackRemaining -= 1;\n      }\n\n      for (var key in obj) {\n        if (Object.getOwnPropertyDescriptor(obj, key)) {\n          clone[key] = Immutable(obj[key], undefined, stackRemaining);\n        }\n      }\n\n      return makeImmutableObject(clone,\n        {instantiateEmptyObject: instantiateEmptyObject});\n    }\n  }\n\n  // Wrapper to allow the use of object methods as static methods of Immutable.\n  function toStatic(fn) {\n    function staticWrapper() {\n      var args = [].slice.call(arguments);\n      var self = args.shift();\n      return fn.apply(self, args);\n    }\n\n    return staticWrapper;\n  }\n\n  // Wrapper to allow the use of object methods as static methods of Immutable.\n  // with the additional condition of choosing which function to call depending\n  // if argument is an array or an object.\n  function toStaticObjectOrArray(fnObject, fnArray) {\n    function staticWrapper() {\n      var args = [].slice.call(arguments);\n      var self = args.shift();\n      if (Array.isArray(self)) {\n          return fnArray.apply(self, args);\n      } else {\n          return fnObject.apply(self, args);\n      }\n    }\n\n    return staticWrapper;\n  }\n\n  // Export the library\n  Immutable.from           = Immutable;\n  Immutable.isImmutable    = isImmutable;\n  Immutable.ImmutableError = ImmutableError;\n  Immutable.merge          = toStatic(merge);\n  Immutable.replace        = toStatic(objectReplace);\n  Immutable.without        = toStatic(without);\n  Immutable.asMutable      = toStaticObjectOrArray(asMutableObject, asMutableArray);\n  Immutable.set            = toStaticObjectOrArray(objectSet, arraySet);\n  Immutable.setIn          = toStaticObjectOrArray(objectSetIn, arraySetIn);\n  Immutable.update         = toStatic(update);\n  Immutable.updateIn       = toStatic(updateIn);\n  Immutable.flatMap        = toStatic(flatMap);\n  Immutable.asObject       = toStatic(asObject);\n\n  Object.freeze(Immutable);\n\n  /* istanbul ignore if */\n  if (typeof module === \"object\") {\n    module.exports = Immutable;\n  } else if (typeof exports === \"object\") {\n    exports.Immutable = Immutable;\n  } else if (typeof window === \"object\") {\n    window.Immutable = Immutable;\n  } else if (typeof global === \"object\") {\n    global.Immutable = Immutable;\n  }\n})();\n"],"names":["REACT_ELEMENT_TYPE","Symbol","for","REACT_ELEMENT_TYPE_FALLBACK","addPropertyTo","target","methodName","value","Object","defineProperty","enumerable","configurable","writable","immutabilityTag","isImmutable","Boolean","getOwnPropertyDescriptor","isEqual","a","b","isMergableObject","Array","isArray","Date","mutatingObjectMethods","nonMutatingArrayMethods","concat","ImmutableError","message","err","Error","__proto__","makeImmutable","obj","bannedMethods","makeMethodReturnImmutable","currentMethod","Immutable","apply","arguments","arraySet","idx","config","deep","this","merge","mode","mutable","asMutableArray","call","makeImmutableArray","prototype","immutableEmptyArray","arraySetIn","pth","head","length","newValue","tail","slice","thisHead","setIn","nextHead","isFinite","objectSetIn","immutableEmptyObject","array","index","hasOwnProperty","flatMap","asObject","update","updateIn","i","asMutableDate","getTime","iterator","result","iteratorResult","push","without","remove","keysToRemoveArray","forEach","el","arr","toString","val","key","indexOf","instantiateEmptyObject","makeImmutableObject","opts","asDeepMutable","pair","asMutable","quickCopy","src","dest","other","TypeError","JSON","stringify","receivedArray","merger","addToResult","currentObj","otherObj","immutableValue","mergerResult","currentValue","undefined","otherFromArray","clearDroppedKeys","objectReplace","path","objectSet","property","updater","restArgs","initialVal","set","l","getInPath","asMutableObject","instantiatePlainObject","options","stackRemaining","$$typeof","isReactElement","date","create","clone","toStatic","fn","args","self","shift","toStaticObjectOrArray","fnObject","fnArray","from","replace","freeze","module","exports"],"sourceRoot":""}