{"version":3,"sources":["vendors/_modernizr.js","vendors/_browser.js","../../node_modules/svg4everybody/dist/svg4everybody.js","../../node_modules/window.requestanimationframe/requestanimationframe.js","../../node_modules/intersection-observer/intersection-observer.js","vendors.js","../../node_modules/countup.js/dist/countUp.js"],"names":["window","document","undefined","classes","tests","ModernizrProto","_version","_config","classPrefix","enableClasses","enableJSClass","usePrefixes","_q","on","test","cb","self","this","setTimeout","addTest","name","fn","options","push","addAsyncTest","Modernizr","is","obj","type","prototype","docElement","documentElement","isSVG","nodeName","toLowerCase","prefixes","split","createElement","createElementNS","call","apply","arguments","injectElementWithStyles","rule","callback","nodes","testnames","style","ret","node","docOverflow","body","mod","div","fake","parseInt","id","appendChild","styleSheet","cssText","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","_prefixes","testStyles","cssToDOM","replace","str","m1","m2","toUpperCase","bool","DocumentTouch","query","join","offsetTop","omPrefixes","cssomPrefixes","_cssomPrefixes","atRule","prop","length","cssrule","CSSRule","i","prefix","domPrefixes","fnBind","that","_domPrefixes","modElem","elem","mStyle","domToCSS","nativeTestProps","props","value","CSS","supports","conditionText","pseudo","result","getComputedStyle","console","getPropertyValue","error","currentStyle","computedStyle","testPropsAll","prefixed","skipValueTest","ucProp","charAt","slice","afterInit","propsLength","before","elems","shift","cleanElems","indexOf","e","testProps","item","testDOMProps","unshift","testAllProps","aliases","featureNames","feature","aliasIdx","nameIdx","featureNameSplit","featureIdx","hasOwnProperty","Boolean","testRunner","className","baseVal","reJS","RegExp","setClasses","$","ready","isCompatible","cssSupports","isIE11","MSInputMethodContext","documentMode","prepend","root","factory","define","amd","svg4everybody","module","exports","embed","parent","svg","target","fragment","createDocumentFragment","viewBox","hasAttribute","getAttribute","setAttribute","clone","cloneNode","childNodes","firstChild","loadreadystatechange","xhr","onreadystatechange","readyState","cachedDocument","_cachedDocument","implementation","createHTMLDocument","innerHTML","responseText","_cachedTarget","_embeds","splice","map","getElementById","getSVGAncestor","rawopts","polyfill","opts","Object","inIframe","top","navigator","userAgent","match","requests","requestAnimationFrame","uses","getElementsByTagName","numberOfSvgUseElementsToBypass","oninterval","index","use","src","attributeName","validate","srcSplit","url","XMLHttpRequest","open","send","animationStartTime","previousCallTime","msRequestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","Date","now","requestTime","timeout","Math","max","timeToCall","cancelAnimationFrame","mozCancelAnimationFrame","webkitCancelAnimationFrame","cancelRequestAnimationFrame","msCancelRequestAnimationFrame","mozCancelRequestAnimationFrame","webkitCancelRequestAnimationFrame","clearTimeout","find","each","link","href","hostname","location","download","rel","IntersectionObserverEntry","defineProperty","get","intersectionRatio","registry","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","_observationTargets","some","element","nodeType","Error","_registerInstance","entry","_monitorIntersections","_checkForIntersections","unobserve","filter","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","threshold","Array","isArray","sort","t","a","isNaN","_parseRootMargin","opt_rootMargin","margins","margin","parts","exec","parseFloat","unit","IntersectionObserver","_monitoringIntersections","_monitoringInterval","setInterval","addEvent","_domObserver","MutationObserver","attributes","childList","characterData","subtree","clearInterval","removeEvent","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","getEmptyRect","forEach","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","intersectionRect","_computeTargetAndRootIntersection","newEntry","time","performance","boundingClientRect","rootBounds","_hasCrossedThreshold","isIntersecting","_callback","display","rect1","rect2","bottom","left","right","width","height","getParentNode","atRoot","parentRect","parentComputedStyle","min","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","targetArea","intersectionArea","Number","toFixed","opt_options","timer","bind","rootMargin","event","opt_useCapture","addEventListener","attachEvent","removeEventListener","detatchEvent","el","err","child","host","require","CountUp","startVal","endVal","decimals","duration","version","useEasing","useGrouping","separator","decimal","easingFn","b","c","d","pow","formattingFn","num","x","x1","x2","x3","len","neg","abs","numerals","w","suffix","key","lastTime","vendors","ensureNumber","n","currTime","getTime","initialize","initialized","dec","countDown","frameVal","printValue","tagName","textContent","count","timestamp","startTime","progress","remaining","round","rAF","start","pauseResume","paused","reset","update","newEndVal"],"mappings":"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","file":"vendors.js","sourcesContent":["/*!\n * modernizr v3.6.0\n * Build https://modernizr.com/download?-objectfit-touchevents-setclasses-dontmin\n *\n * Copyright (c)\n *  Faruk Ates\n *  Paul Irish\n *  Alex Sexton\n *  Ryan Seddon\n *  Patrick Kettner\n *  Stu Cox\n *  Richard Herrera\n\n * MIT License\n */\n\n/*\n * Modernizr tests which native CSS3 and HTML5 features are available in the\n * current UA and makes the results available to you in two ways: as properties on\n * a global `Modernizr` object, and as classes on the `<html>` element. This\n * information allows you to progressively enhance your pages with a granular level\n * of control over the experience.\n*/\n\n;(function(window, document, undefined){\n  var classes = [];\n  \n\n  var tests = [];\n  \n\n  /**\n   *\n   * ModernizrProto is the constructor for Modernizr\n   *\n   * @class\n   * @access public\n   */\n\n  var ModernizrProto = {\n    // The current version, dummy\n    _version: '3.6.0',\n\n    // Any settings that don't work as separate modules\n    // can go in here as configuration.\n    _config: {\n      'classPrefix': '',\n      'enableClasses': true,\n      'enableJSClass': true,\n      'usePrefixes': true\n    },\n\n    // Queue of tests\n    _q: [],\n\n    // Stub these for people who are listening\n    on: function(test, cb) {\n      // I don't really think people should do this, but we can\n      // safe guard it a bit.\n      // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.\n      // This is in case people listen to synchronous tests. I would leave it out,\n      // but the code to *disallow* sync tests in the real version of this\n      // function is actually larger than this.\n      var self = this;\n      setTimeout(function() {\n        cb(self[test]);\n      }, 0);\n    },\n\n    addTest: function(name, fn, options) {\n      tests.push({name: name, fn: fn, options: options});\n    },\n\n    addAsyncTest: function(fn) {\n      tests.push({name: null, fn: fn});\n    }\n  };\n\n  \n\n  // Fake some of Object.create so we can force non test results to be non \"own\" properties.\n  var Modernizr = function() {};\n  Modernizr.prototype = ModernizrProto;\n\n  // Leak modernizr globally when you `require` it rather than force it here.\n  // Overwrite name so constructor name is nicer :D\n  Modernizr = new Modernizr();\n\n  \n\n  /**\n   * is returns a boolean if the typeof an obj is exactly type.\n   *\n   * @access private\n   * @function is\n   * @param {*} obj - A thing we want to check the type of\n   * @param {string} type - A string to compare the typeof against\n   * @returns {boolean}\n   */\n\n  function is(obj, type) {\n    return typeof obj === type;\n  }\n  ;\n\n  /**\n   * Run through all tests and detect their support in the current UA.\n   *\n   * @access private\n   */\n\n  function testRunner() {\n    var featureNames;\n    var feature;\n    var aliasIdx;\n    var result;\n    var nameIdx;\n    var featureName;\n    var featureNameSplit;\n\n    for (var featureIdx in tests) {\n      if (tests.hasOwnProperty(featureIdx)) {\n        featureNames = [];\n        feature = tests[featureIdx];\n        // run the test, throw the return value into the Modernizr,\n        // then based on that boolean, define an appropriate className\n        // and push it into an array of classes we'll join later.\n        //\n        // If there is no name, it's an 'async' test that is run,\n        // but not directly added to the object. That should\n        // be done with a post-run addTest call.\n        if (feature.name) {\n          featureNames.push(feature.name.toLowerCase());\n\n          if (feature.options && feature.options.aliases && feature.options.aliases.length) {\n            // Add all the aliases into the names list\n            for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) {\n              featureNames.push(feature.options.aliases[aliasIdx].toLowerCase());\n            }\n          }\n        }\n\n        // Run the test, or use the raw value if it's not a function\n        result = is(feature.fn, 'function') ? feature.fn() : feature.fn;\n\n\n        // Set each of the names on the Modernizr object\n        for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {\n          featureName = featureNames[nameIdx];\n          // Support dot properties as sub tests. We don't do checking to make sure\n          // that the implied parent tests have been added. You must call them in\n          // order (either in the test, or make the parent test a dependency).\n          //\n          // Cap it to TWO to make the logic simple and because who needs that kind of subtesting\n          // hashtag famous last words\n          featureNameSplit = featureName.split('.');\n\n          if (featureNameSplit.length === 1) {\n            Modernizr[featureNameSplit[0]] = result;\n          } else {\n            // cast to a Boolean, if not one already\n            if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n              Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n            }\n\n            Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;\n          }\n\n          classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));\n        }\n      }\n    }\n  }\n  ;\n\n  /**\n   * docElement is a convenience wrapper to grab the root element of the document\n   *\n   * @access private\n   * @returns {HTMLElement|SVGElement} The root element of the document\n   */\n\n  var docElement = document.documentElement;\n  \n\n  /**\n   * A convenience helper to check if the document we are running in is an SVG document\n   *\n   * @access private\n   * @returns {boolean}\n   */\n\n  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\n  \n\n  /**\n   * setClasses takes an array of class names and adds them to the root element\n   *\n   * @access private\n   * @function setClasses\n   * @param {string[]} classes - Array of class names\n   */\n\n  // Pass in an and array of class names, e.g.:\n  //  ['no-webp', 'borderradius', ...]\n  function setClasses(classes) {\n    var className = docElement.className;\n    var classPrefix = Modernizr._config.classPrefix || '';\n\n    if (isSVG) {\n      className = className.baseVal;\n    }\n\n    // Change `no-js` to `js` (independently of the `enableClasses` option)\n    // Handle classPrefix on this too\n    if (Modernizr._config.enableJSClass) {\n      var reJS = new RegExp('(^|\\\\s)' + classPrefix + 'no-js(\\\\s|$)');\n      className = className.replace(reJS, '$1' + classPrefix + 'js$2');\n    }\n\n    if (Modernizr._config.enableClasses) {\n      // Add the new classes\n      className += ' ' + classPrefix + classes.join(' ' + classPrefix);\n      if (isSVG) {\n        docElement.className.baseVal = className;\n      } else {\n        docElement.className = className;\n      }\n    }\n\n  }\n\n  ;\n\n  /**\n   * List of property values to set for css tests. See ticket #21\n   * http://git.io/vUGl4\n   *\n   * @memberof Modernizr\n   * @name Modernizr._prefixes\n   * @optionName Modernizr._prefixes\n   * @optionProp prefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._prefixes is the internal list of prefixes that we test against\n   * inside of things like [prefixed](#modernizr-prefixed) and [prefixedCSS](#-code-modernizr-prefixedcss). It is simply\n   * an array of kebab-case vendor prefixes you can use within your code.\n   *\n   * Some common use cases include\n   *\n   * Generating all possible prefixed version of a CSS property\n   * ```js\n   * var rule = Modernizr._prefixes.join('transform: rotate(20deg); ');\n   *\n   * rule === 'transform: rotate(20deg); webkit-transform: rotate(20deg); moz-transform: rotate(20deg); o-transform: rotate(20deg); ms-transform: rotate(20deg);'\n   * ```\n   *\n   * Generating all possible prefixed version of a CSS value\n   * ```js\n   * rule = 'display:' +  Modernizr._prefixes.join('flex; display:') + 'flex';\n   *\n   * rule === 'display:flex; display:-webkit-flex; display:-moz-flex; display:-o-flex; display:-ms-flex; display:flex'\n   * ```\n   */\n\n  // we use ['',''] rather than an empty array in order to allow a pattern of .`join()`ing prefixes to test\n  // values in feature detects to continue to work\n  var prefixes = (ModernizrProto._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : ['','']);\n\n  // expose these for the plugin API. Look in the source for how to join() them against your input\n  ModernizrProto._prefixes = prefixes;\n\n  \n\n  /**\n   * createElement is a convenience wrapper around document.createElement. Since we\n   * use createElement all over the place, this allows for (slightly) smaller code\n   * as well as abstracting away issues with creating elements in contexts other than\n   * HTML documents (e.g. SVG documents).\n   *\n   * @access private\n   * @function createElement\n   * @returns {HTMLElement|SVGElement} An HTML or SVG element\n   */\n\n  function createElement() {\n    if (typeof document.createElement !== 'function') {\n      // This is the case in IE7, where the type of createElement is \"object\".\n      // For this reason, we cannot call apply() as Object is not a Function.\n      return document.createElement(arguments[0]);\n    } else if (isSVG) {\n      return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]);\n    } else {\n      return document.createElement.apply(document, arguments);\n    }\n  }\n\n  ;\n\n  /**\n   * getBody returns the body of a document, or an element that can stand in for\n   * the body if a real body does not exist\n   *\n   * @access private\n   * @function getBody\n   * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an\n   * artificially created element that stands in for the body\n   */\n\n  function getBody() {\n    // After page load injecting a fake body doesn't work so check if body exists\n    var body = document.body;\n\n    if (!body) {\n      // Can't use the real body create a fake one.\n      body = createElement(isSVG ? 'svg' : 'body');\n      body.fake = true;\n    }\n\n    return body;\n  }\n\n  ;\n\n  /**\n   * injectElementWithStyles injects an element with style element and some CSS rules\n   *\n   * @access private\n   * @function injectElementWithStyles\n   * @param {string} rule - String representing a css rule\n   * @param {function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean}\n   */\n\n  function injectElementWithStyles(rule, callback, nodes, testnames) {\n    var mod = 'modernizr';\n    var style;\n    var ret;\n    var node;\n    var docOverflow;\n    var div = createElement('div');\n    var body = getBody();\n\n    if (parseInt(nodes, 10)) {\n      // In order not to give false positives we create a node for each test\n      // This also allows the method to scale for unspecified uses\n      while (nodes--) {\n        node = createElement('div');\n        node.id = testnames ? testnames[nodes] : mod + (nodes + 1);\n        div.appendChild(node);\n      }\n    }\n\n    style = createElement('style');\n    style.type = 'text/css';\n    style.id = 's' + mod;\n\n    // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.\n    // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270\n    (!body.fake ? div : body).appendChild(style);\n    body.appendChild(div);\n\n    if (style.styleSheet) {\n      style.styleSheet.cssText = rule;\n    } else {\n      style.appendChild(document.createTextNode(rule));\n    }\n    div.id = mod;\n\n    if (body.fake) {\n      //avoid crashing IE8, if background image is used\n      body.style.background = '';\n      //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible\n      body.style.overflow = 'hidden';\n      docOverflow = docElement.style.overflow;\n      docElement.style.overflow = 'hidden';\n      docElement.appendChild(body);\n    }\n\n    ret = callback(div, rule);\n    // If this is done after page load we don't want to remove the body so check if body exists\n    if (body.fake) {\n      body.parentNode.removeChild(body);\n      docElement.style.overflow = docOverflow;\n      // Trigger layout so kinetic scrolling isn't disabled in iOS6+\n      // eslint-disable-next-line\n      docElement.offsetHeight;\n    } else {\n      div.parentNode.removeChild(div);\n    }\n\n    return !!ret;\n\n  }\n\n  ;\n\n  /**\n   * testStyles injects an element with style element and some CSS rules\n   *\n   * @memberof Modernizr\n   * @name Modernizr.testStyles\n   * @optionName Modernizr.testStyles()\n   * @optionProp testStyles\n   * @access public\n   * @function testStyles\n   * @param {string} rule - String representing a css rule\n   * @param {function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean}\n   * @example\n   *\n   * `Modernizr.testStyles` takes a CSS rule and injects it onto the current page\n   * along with (possibly multiple) DOM elements. This lets you check for features\n   * that can not be detected by simply checking the [IDL](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Interface_development_guide/IDL_interface_rules).\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr { width: 9px; color: papayawhip; }', function(elem, rule) {\n   *   // elem is the first DOM node in the page (by default #modernizr)\n   *   // rule is the first argument you supplied - the CSS rule in string form\n   *\n   *   addTest('widthworks', elem.style.width === '9px')\n   * });\n   * ```\n   *\n   * If your test requires multiple nodes, you can include a third argument\n   * indicating how many additional div elements to include on the page. The\n   * additional nodes are injected as children of the `elem` that is returned as\n   * the first argument to the callback.\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr {width: 1px}; #modernizr2 {width: 2px}', function(elem) {\n   *   document.getElementById('modernizr').style.width === '1px'; // true\n   *   document.getElementById('modernizr2').style.width === '2px'; // true\n   *   elem.firstChild === document.getElementById('modernizr2'); // true\n   * }, 1);\n   * ```\n   *\n   * By default, all of the additional elements have an ID of `modernizr[n]`, where\n   * `n` is its index (e.g. the first additional, second overall is `#modernizr2`,\n   * the second additional is `#modernizr3`, etc.).\n   * If you want to have more meaningful IDs for your function, you can provide\n   * them as the fourth argument, as an array of strings\n   *\n   * ```js\n   * Modernizr.testStyles('#foo {width: 10px}; #bar {height: 20px}', function(elem) {\n   *   elem.firstChild === document.getElementById('foo'); // true\n   *   elem.lastChild === document.getElementById('bar'); // true\n   * }, 2, ['foo', 'bar']);\n   * ```\n   *\n   */\n\n  var testStyles = ModernizrProto.testStyles = injectElementWithStyles;\n  \n/*!\n{\n  \"name\": \"Touch Events\",\n  \"property\": \"touchevents\",\n  \"caniuse\" : \"touch\",\n  \"tags\": [\"media\", \"attribute\"],\n  \"notes\": [{\n    \"name\": \"Touch Events spec\",\n    \"href\": \"https://www.w3.org/TR/2013/WD-touch-events-20130124/\"\n  }],\n  \"warnings\": [\n    \"Indicates if the browser supports the Touch Events spec, and does not necessarily reflect a touchscreen device\"\n  ],\n  \"knownBugs\": [\n    \"False-positive on some configurations of Nokia N900\",\n    \"False-positive on some BlackBerry 6.0 builds – https://github.com/Modernizr/Modernizr/issues/372#issuecomment-3112695\"\n  ]\n}\n!*/\n/* DOC\nIndicates if the browser supports the W3C Touch Events API.\n\nThis *does not* necessarily reflect a touchscreen device:\n\n* Older touchscreen devices only emulate mouse events\n* Modern IE touch devices implement the Pointer Events API instead: use `Modernizr.pointerevents` to detect support for that\n* Some browsers & OS setups may enable touch APIs when no touchscreen is connected\n* Future browsers may implement other event models for touch interactions\n\nSee this article: [You Can't Detect A Touchscreen](http://www.stucox.com/blog/you-cant-detect-a-touchscreen/).\n\nIt's recommended to bind both mouse and touch/pointer events simultaneously – see [this HTML5 Rocks tutorial](http://www.html5rocks.com/en/mobile/touchandmouse/).\n\nThis test will also return `true` for Firefox 4 Multitouch support.\n*/\n\n  // Chrome (desktop) used to lie about its support on this, but that has since been rectified: http://crbug.com/36415\n  Modernizr.addTest('touchevents', function() {\n    var bool;\n    if (('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch) {\n      bool = true;\n    } else {\n      // include the 'heartz' as a way to have a non matching MQ to help terminate the join\n      // https://git.io/vznFH\n      var query = ['@media (', prefixes.join('touch-enabled),('), 'heartz', ')', '{#modernizr{top:9px;position:absolute}}'].join('');\n      testStyles(query, function(node) {\n        bool = node.offsetTop === 9;\n      });\n    }\n    return bool;\n  });\n\n\n  /**\n   * cssToDOM takes a kebab-case string and converts it to camelCase\n   * e.g. box-sizing -> boxSizing\n   *\n   * @access private\n   * @function cssToDOM\n   * @param {string} name - String name of kebab-case prop we want to convert\n   * @returns {string} The camelCase version of the supplied name\n   */\n\n  function cssToDOM(name) {\n    return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) {\n      return m1 + m2.toUpperCase();\n    }).replace(/^-/, '');\n  }\n  ;\n\n  /**\n   * If the browsers follow the spec, then they would expose vendor-specific styles as:\n   *   elem.style.WebkitBorderRadius\n   * instead of something like the following (which is technically incorrect):\n   *   elem.style.webkitBorderRadius\n\n   * WebKit ghosts their properties in lowercase but Opera & Moz do not.\n   * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+\n   *   erik.eae.net/archives/2008/03/10/21.48.10/\n\n   * More here: github.com/Modernizr/Modernizr/issues/issue/21\n   *\n   * @access private\n   * @returns {string} The string representing the vendor-specific style properties\n   */\n\n  var omPrefixes = 'Moz O ms Webkit';\n  \n\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\n  \n\n  /**\n   * atRule returns a given CSS property at-rule (eg @keyframes), possibly in\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @memberof Modernizr\n   * @name Modernizr.atRule\n   * @optionName Modernizr.atRule()\n   * @optionProp atRule\n   * @access public\n   * @function atRule\n   * @param {string} prop - String name of the @-rule to test for\n   * @returns {string|boolean} The string representing the (possibly prefixed)\n   * valid version of the @-rule, or `false` when it is unsupported.\n   * @example\n   * ```js\n   *  var keyframes = Modernizr.atRule('@keyframes');\n   *\n   *  if (keyframes) {\n   *    // keyframes are supported\n   *    // could be `@-webkit-keyframes` or `@keyframes`\n   *  } else {\n   *    // keyframes === `false`\n   *  }\n   * ```\n   *\n   */\n\n  var atRule = function(prop) {\n    var length = prefixes.length;\n    var cssrule = window.CSSRule;\n    var rule;\n\n    if (typeof cssrule === 'undefined') {\n      return undefined;\n    }\n\n    if (!prop) {\n      return false;\n    }\n\n    // remove literal @ from beginning of provided property\n    prop = prop.replace(/^@/, '');\n\n    // CSSRules use underscores instead of dashes\n    rule = prop.replace(/-/g, '_').toUpperCase() + '_RULE';\n\n    if (rule in cssrule) {\n      return '@' + prop;\n    }\n\n    for (var i = 0; i < length; i++) {\n      // prefixes gives us something like -o-, and we want O_\n      var prefix = prefixes[i];\n      var thisRule = prefix.toUpperCase() + '_' + rule;\n\n      if (thisRule in cssrule) {\n        return '@-' + prefix.toLowerCase() + '-' + prop;\n      }\n    }\n\n    return false;\n  };\n\n  ModernizrProto.atRule = atRule;\n\n  \n\n  /**\n   * List of JavaScript DOM values used for tests\n   *\n   * @memberof Modernizr\n   * @name Modernizr._domPrefixes\n   * @optionName Modernizr._domPrefixes\n   * @optionProp domPrefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather\n   * than kebab-case properties, all properties are their Capitalized variant\n   *\n   * ```js\n   * Modernizr._domPrefixes === [ \"Moz\", \"O\", \"ms\", \"Webkit\" ];\n   * ```\n   */\n\n  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\n  ModernizrProto._domPrefixes = domPrefixes;\n  \n\n\n  /**\n   * contains checks to see if a string contains another string\n   *\n   * @access private\n   * @function contains\n   * @param {string} str - The string we want to check for substrings\n   * @param {string} substr - The substring we want to search the first string for\n   * @returns {boolean}\n   */\n\n  function contains(str, substr) {\n    return !!~('' + str).indexOf(substr);\n  }\n\n  ;\n\n  /**\n   * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill.\n   *\n   * @access private\n   * @function fnBind\n   * @param {function} fn - a function you want to change `this` reference to\n   * @param {object} that - the `this` you want to call the function with\n   * @returns {function} The wrapped version of the supplied function\n   */\n\n  function fnBind(fn, that) {\n    return function() {\n      return fn.apply(that, arguments);\n    };\n  }\n\n  ;\n\n  /**\n   * testDOMProps is a generic DOM property test; if a browser supports\n   *   a certain property, it won't return undefined for it.\n   *\n   * @access private\n   * @function testDOMProps\n   * @param {array.<string>} props - An array of properties to test for\n   * @param {object} obj - An object or Element you want to use to test the parameters again\n   * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check\n   * @returns {false|*} returns false if the prop is unsupported, otherwise the value that is supported\n   */\n  function testDOMProps(props, obj, elem) {\n    var item;\n\n    for (var i in props) {\n      if (props[i] in obj) {\n\n        // return the property name as a string\n        if (elem === false) {\n          return props[i];\n        }\n\n        item = obj[props[i]];\n\n        // let's bind a function\n        if (is(item, 'function')) {\n          // bind to obj unless overriden\n          return fnBind(item, elem || obj);\n        }\n\n        // return the unbound function or obj or value\n        return item;\n      }\n    }\n    return false;\n  }\n\n  ;\n\n  /**\n   * Create our \"modernizr\" element that we do most feature tests on.\n   *\n   * @access private\n   */\n\n  var modElem = {\n    elem: createElement('modernizr')\n  };\n\n  // Clean up this element\n  Modernizr._q.push(function() {\n    delete modElem.elem;\n  });\n\n  \n\n  var mStyle = {\n    style: modElem.elem.style\n  };\n\n  // kill ref for gc, must happen before mod.elem is removed, so we unshift on to\n  // the front of the queue.\n  Modernizr._q.unshift(function() {\n    delete mStyle.style;\n  });\n\n  \n\n  /**\n   * domToCSS takes a camelCase string and converts it to kebab-case\n   * e.g. boxSizing -> box-sizing\n   *\n   * @access private\n   * @function domToCSS\n   * @param {string} name - String name of camelCase prop we want to convert\n   * @returns {string} The kebab-case version of the supplied name\n   */\n\n  function domToCSS(name) {\n    return name.replace(/([A-Z])/g, function(str, m1) {\n      return '-' + m1.toLowerCase();\n    }).replace(/^ms-/, '-ms-');\n  }\n  ;\n\n\n  /**\n   * wrapper around getComputedStyle, to fix issues with Firefox returning null when\n   * called inside of a hidden iframe\n   *\n   * @access private\n   * @function computedStyle\n   * @param {HTMLElement|SVGElement} - The element we want to find the computed styles of\n   * @param {string|null} [pseudoSelector]- An optional pseudo element selector (e.g. :before), of null if none\n   * @returns {CSSStyleDeclaration}\n   */\n\n  function computedStyle(elem, pseudo, prop) {\n    var result;\n\n    if ('getComputedStyle' in window) {\n      result = getComputedStyle.call(window, elem, pseudo);\n      var console = window.console;\n\n      if (result !== null) {\n        if (prop) {\n          result = result.getPropertyValue(prop);\n        }\n      } else {\n        if (console) {\n          var method = console.error ? 'error' : 'log';\n          console[method].call(console, 'getComputedStyle returning null, its possible modernizr test results are inaccurate');\n        }\n      }\n    } else {\n      result = !pseudo && elem.currentStyle && elem.currentStyle[prop];\n    }\n\n    return result;\n  }\n\n  ;\n\n  /**\n   * nativeTestProps allows for us to use native feature detection functionality if available.\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @access private\n   * @function nativeTestProps\n   * @param {array} props - An array of property names\n   * @param {string} value - A string representing the value we want to check via @supports\n   * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise\n   */\n\n  // Accepts a list of property names and a single value\n  // Returns `undefined` if native detection not available\n  function nativeTestProps(props, value) {\n    var i = props.length;\n    // Start with the JS API: http://www.w3.org/TR/css3-conditional/#the-css-interface\n    if ('CSS' in window && 'supports' in window.CSS) {\n      // Try every prefixed variant of the property\n      while (i--) {\n        if (window.CSS.supports(domToCSS(props[i]), value)) {\n          return true;\n        }\n      }\n      return false;\n    }\n    // Otherwise fall back to at-rule (for Opera 12.x)\n    else if ('CSSSupportsRule' in window) {\n      // Build a condition string for every prefixed variant\n      var conditionText = [];\n      while (i--) {\n        conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')');\n      }\n      conditionText = conditionText.join(' or ');\n      return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) {\n        return computedStyle(node, null, 'position') == 'absolute';\n      });\n    }\n    return undefined;\n  }\n  ;\n\n  // testProps is a generic CSS / DOM property test.\n\n  // In testing support for a given CSS property, it's legit to test:\n  //    `elem.style[styleName] !== undefined`\n  // If the property is supported it will return an empty string,\n  // if unsupported it will return undefined.\n\n  // We'll take advantage of this quick test and skip setting a style\n  // on our modernizr element, but instead just testing undefined vs\n  // empty string.\n\n  // Property names can be provided in either camelCase or kebab-case.\n\n  function testProps(props, prefixed, value, skipValueTest) {\n    skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest;\n\n    // Try native detect first\n    if (!is(value, 'undefined')) {\n      var result = nativeTestProps(props, value);\n      if (!is(result, 'undefined')) {\n        return result;\n      }\n    }\n\n    // Otherwise do it properly\n    var afterInit, i, propsLength, prop, before;\n\n    // If we don't have a style element, that means we're running async or after\n    // the core tests, so we'll need to create our own elements to use\n\n    // inside of an SVG element, in certain browsers, the `style` element is only\n    // defined for valid tags. Therefore, if `modernizr` does not have one, we\n    // fall back to a less used element and hope for the best.\n    // for strict XHTML browsers the hardly used samp element is used\n    var elems = ['modernizr', 'tspan', 'samp'];\n    while (!mStyle.style && elems.length) {\n      afterInit = true;\n      mStyle.modElem = createElement(elems.shift());\n      mStyle.style = mStyle.modElem.style;\n    }\n\n    // Delete the objects if we created them.\n    function cleanElems() {\n      if (afterInit) {\n        delete mStyle.style;\n        delete mStyle.modElem;\n      }\n    }\n\n    propsLength = props.length;\n    for (i = 0; i < propsLength; i++) {\n      prop = props[i];\n      before = mStyle.style[prop];\n\n      if (contains(prop, '-')) {\n        prop = cssToDOM(prop);\n      }\n\n      if (mStyle.style[prop] !== undefined) {\n\n        // If value to test has been passed in, do a set-and-check test.\n        // 0 (integer) is a valid property value, so check that `value` isn't\n        // undefined, rather than just checking it's truthy.\n        if (!skipValueTest && !is(value, 'undefined')) {\n\n          // Needs a try catch block because of old IE. This is slow, but will\n          // be avoided in most cases because `skipValueTest` will be used.\n          try {\n            mStyle.style[prop] = value;\n          } catch (e) {}\n\n          // If the property value has changed, we assume the value used is\n          // supported. If `value` is empty string, it'll fail here (because\n          // it hasn't changed), which matches how browsers have implemented\n          // CSS.supports()\n          if (mStyle.style[prop] != before) {\n            cleanElems();\n            return prefixed == 'pfx' ? prop : true;\n          }\n        }\n        // Otherwise just return true, or the property name if this is a\n        // `prefixed()` call\n        else {\n          cleanElems();\n          return prefixed == 'pfx' ? prop : true;\n        }\n      }\n    }\n    cleanElems();\n    return false;\n  }\n\n  ;\n\n  /**\n   * testPropsAll tests a list of DOM properties we want to check against.\n   * We specify literally ALL possible (known and/or likely) properties on\n   * the element including the non-vendor prefixed one, for forward-\n   * compatibility.\n   *\n   * @access private\n   * @function testPropsAll\n   * @param {string} prop - A string of the property to test for\n   * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip\n   * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against\n   * @param {string} [value] - A string of a css value\n   * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set\n   * @returns {false|string} returns the string version of the property, or false if it is unsupported\n   */\n  function testPropsAll(prop, prefixed, elem, value, skipValueTest) {\n\n    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),\n      props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');\n\n    // did they call .prefixed('boxSizing') or are we just testing a prop?\n    if (is(prefixed, 'string') || is(prefixed, 'undefined')) {\n      return testProps(props, prefixed, value, skipValueTest);\n\n      // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])\n    } else {\n      props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');\n      return testDOMProps(props, prefixed, elem);\n    }\n  }\n\n  // Modernizr.testAllProps() investigates whether a given style property,\n  // or any of its vendor-prefixed variants, is recognized\n  //\n  // Note that the property names must be provided in the camelCase variant.\n  // Modernizr.testAllProps('boxSizing')\n  ModernizrProto.testAllProps = testPropsAll;\n\n  \n\n  /**\n   * prefixed returns the prefixed or nonprefixed property name variant of your input\n   *\n   * @memberof Modernizr\n   * @name Modernizr.prefixed\n   * @optionName Modernizr.prefixed()\n   * @optionProp prefixed\n   * @access public\n   * @function prefixed\n   * @param {string} prop - String name of the property to test for\n   * @param {object} [obj] - An object to test for the prefixed properties on\n   * @param {HTMLElement} [elem] - An element used to test specific properties against\n   * @returns {string|false} The string representing the (possibly prefixed) valid\n   * version of the property, or `false` when it is unsupported.\n   * @example\n   *\n   * Modernizr.prefixed takes a string css value in the DOM style camelCase (as\n   * opposed to the css style kebab-case) form and returns the (possibly prefixed)\n   * version of that property that the browser actually supports.\n   *\n   * For example, in older Firefox...\n   * ```js\n   * prefixed('boxSizing')\n   * ```\n   * returns 'MozBoxSizing'\n   *\n   * In newer Firefox, as well as any other browser that support the unprefixed\n   * version would simply return `boxSizing`. Any browser that does not support\n   * the property at all, it will return `false`.\n   *\n   * By default, prefixed is checked against a DOM element. If you want to check\n   * for a property on another object, just pass it as a second argument\n   *\n   * ```js\n   * var rAF = prefixed('requestAnimationFrame', window);\n   *\n   * raf(function() {\n   *  renderFunction();\n   * })\n   * ```\n   *\n   * Note that this will return _the actual function_ - not the name of the function.\n   * If you need the actual name of the property, pass in `false` as a third argument\n   *\n   * ```js\n   * var rAFProp = prefixed('requestAnimationFrame', window, false);\n   *\n   * rafProp === 'WebkitRequestAnimationFrame' // in older webkit\n   * ```\n   *\n   * One common use case for prefixed is if you're trying to determine which transition\n   * end event to bind to, you might do something like...\n   * ```js\n   * var transEndEventNames = {\n   *     'WebkitTransition' : 'webkitTransitionEnd', * Saf 6, Android Browser\n   *     'MozTransition'    : 'transitionend',       * only for FF < 15\n   *     'transition'       : 'transitionend'        * IE10, Opera, Chrome, FF 15+, Saf 7+\n   * };\n   *\n   * var transEndEventName = transEndEventNames[ Modernizr.prefixed('transition') ];\n   * ```\n   *\n   * If you want a similar lookup, but in kebab-case, you can use [prefixedCSS](#modernizr-prefixedcss).\n   */\n\n  var prefixed = ModernizrProto.prefixed = function(prop, obj, elem) {\n    if (prop.indexOf('@') === 0) {\n      return atRule(prop);\n    }\n\n    if (prop.indexOf('-') != -1) {\n      // Convert kebab-case to camelCase\n      prop = cssToDOM(prop);\n    }\n    if (!obj) {\n      return testPropsAll(prop, 'pfx');\n    } else {\n      // Testing DOM property e.g. Modernizr.prefixed('requestAnimationFrame', window) // 'mozRequestAnimationFrame'\n      return testPropsAll(prop, obj, elem);\n    }\n  };\n\n  \n/*!\n{\n  \"name\": \"CSS Object Fit\",\n  \"caniuse\": \"object-fit\",\n  \"property\": \"objectfit\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_objectfit\"],\n  \"notes\": [{\n    \"name\": \"Opera Article on Object Fit\",\n    \"href\": \"https://dev.opera.com/articles/css3-object-fit-object-position/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('objectfit', !!prefixed('objectFit'), {aliases: ['object-fit']});\n\n\n  // Run each test\n  testRunner();\n\n  // Remove the \"no-js\" class if it exists\n  setClasses(classes);\n\n  delete ModernizrProto.addTest;\n  delete ModernizrProto.addAsyncTest;\n\n  // Run the things that are supposed to run after the tests\n  for (var i = 0; i < Modernizr._q.length; i++) {\n    Modernizr._q[i]();\n  }\n\n  // Leak Modernizr namespace\n  window.Modernizr = Modernizr;\n\n\n;\n\n})(window, document);\n","/**\n * _browser.js\n * Display a message to non supported browser.\n *\n * If needed you can update the markup of the message\n * and/or the body of browserIsCompatible() function to adjust the test based on which browsers you want to support.\n */\n\n$(function() {\n  'use strict';\n\n  var html = '<div class=\"c-browser\">\\\n                <strong class=\"c-browser__title\">Votre version de navigateur est obsolète.</strong>\\\n                <p class=\"c-browser__content\">Mettez à jour votre navigateur pour afficher correctement ce site Web.</p>\\\n                <div class=\"c-browser__action\">\\\n                  <a href=\"http://outdatedbrowser.com/fr\" class=\"c-button c-button--primary c-browser__button\">\\\n                    <span class=\"c-button__text\">Mettre à jour maintenant</span>\\\n                  </a>\\\n                </div>\\\n              </div>';\n\n  function browserIsCompatible(){\n    // By default we treat all browsers has compatible\n    var isCompatible = true;\n\n    /*\n     * No IE versions supports @supports{} and if we rely on caniuse stats this feature is pretty well supported :\n     * https://caniuse.com/#search=supports\n     * So this must cover our comptaibility expectations (usually last 2 versions)\n     */\n    var cssSupports = 'CSS' in window && 'supports' in window.CSS || 'supportsCSS' in window;\n    // Target IE11 only : https://stackoverflow.com/questions/21825157/internet-explorer-11-detection\n    var isIE11 = !!window.MSInputMethodContext && !!document.documentMode;\n\n    // If doesn't support @supports{} and is not IE11\n    if(!cssSupports && !isIE11){\n      isCompatible = false;\n    }\n\n    return isCompatible;\n  }\n\n  // When DOM is ready, if browser is not supported then we display the disclaimer message.\n  $(document).ready(function(){\n    if(!browserIsCompatible()){\n      $('body').prepend(html);\n    }\n  });\n\n});\n","!function(root, factory) {\n    \"function\" == typeof define && define.amd ? // AMD. Register as an anonymous module unless amdModuleId is set\n    define([], function() {\n        return root.svg4everybody = factory();\n    }) : \"object\" == typeof module && module.exports ? // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory() : root.svg4everybody = factory();\n}(this, function() {\n    /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */\n    function embed(parent, svg, target) {\n        // if the target exists\n        if (target) {\n            // create a document fragment to hold the contents of the target\n            var fragment = document.createDocumentFragment(), viewBox = !svg.hasAttribute(\"viewBox\") && target.getAttribute(\"viewBox\");\n            // conditionally set the viewBox on the svg\n            viewBox && svg.setAttribute(\"viewBox\", viewBox);\n            // copy the contents of the clone into the fragment\n            for (// clone the target\n            var clone = target.cloneNode(!0); clone.childNodes.length; ) {\n                fragment.appendChild(clone.firstChild);\n            }\n            // append the fragment into the svg\n            parent.appendChild(fragment);\n        }\n    }\n    function loadreadystatechange(xhr) {\n        // listen to changes in the request\n        xhr.onreadystatechange = function() {\n            // if the request is ready\n            if (4 === xhr.readyState) {\n                // get the cached html document\n                var cachedDocument = xhr._cachedDocument;\n                // ensure the cached html document based on the xhr response\n                cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(\"\"), \n                cachedDocument.body.innerHTML = xhr.responseText, xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item\n                xhr._embeds.splice(0).map(function(item) {\n                    // get the cached target\n                    var target = xhr._cachedTarget[item.id];\n                    // ensure the cached target\n                    target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), \n                    // embed the target into the svg\n                    embed(item.parent, item.svg, target);\n                });\n            }\n        }, // test the ready state change immediately\n        xhr.onreadystatechange();\n    }\n    function svg4everybody(rawopts) {\n        function oninterval() {\n            // while the index exists in the live <use> collection\n            for (// get the cached <use> index\n            var index = 0; index < uses.length; ) {\n                // get the current <use>\n                var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute(\"xlink:href\") || use.getAttribute(\"href\");\n                if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), \n                svg && src) {\n                    if (polyfill) {\n                        if (!opts.validate || opts.validate(src, svg, use)) {\n                            // remove the <use> element\n                            parent.removeChild(use);\n                            // parse the src and get the url and id\n                            var srcSplit = src.split(\"#\"), url = srcSplit.shift(), id = srcSplit.join(\"#\");\n                            // if the link is external\n                            if (url.length) {\n                                // get the cached xhr request\n                                var xhr = requests[url];\n                                // ensure the xhr request exists\n                                xhr || (xhr = requests[url] = new XMLHttpRequest(), xhr.open(\"GET\", url), xhr.send(), \n                                xhr._embeds = []), // add the svg and id as an item to the xhr embeds list\n                                xhr._embeds.push({\n                                    parent: parent,\n                                    svg: svg,\n                                    id: id\n                                }), // prepare the xhr ready state change event\n                                loadreadystatechange(xhr);\n                            } else {\n                                // embed the local id into the svg\n                                embed(parent, svg, document.getElementById(id));\n                            }\n                        } else {\n                            // increase the index when the previous value was not \"valid\"\n                            ++index, ++numberOfSvgUseElementsToBypass;\n                        }\n                    }\n                } else {\n                    // increase the index when the previous value was not \"valid\"\n                    ++index;\n                }\n            }\n            // continue the interval\n            (!uses.length || uses.length - numberOfSvgUseElementsToBypass > 0) && requestAnimationFrame(oninterval, 67);\n        }\n        var polyfill, opts = Object(rawopts), newerIEUA = /\\bTrident\\/[567]\\b|\\bMSIE (?:9|10)\\.0\\b/, webkitUA = /\\bAppleWebKit\\/(\\d+)\\b/, olderEdgeUA = /\\bEdge\\/12\\.(\\d+)\\b/, edgeUA = /\\bEdge\\/.(\\d+)\\b/, inIframe = window.top !== window.self;\n        polyfill = \"polyfill\" in opts ? opts.polyfill : newerIEUA.test(navigator.userAgent) || (navigator.userAgent.match(olderEdgeUA) || [])[1] < 10547 || (navigator.userAgent.match(webkitUA) || [])[1] < 537 || edgeUA.test(navigator.userAgent) && inIframe;\n        // create xhr requests object\n        var requests = {}, requestAnimationFrame = window.requestAnimationFrame || setTimeout, uses = document.getElementsByTagName(\"use\"), numberOfSvgUseElementsToBypass = 0;\n        // conditionally start the interval if the polyfill is active\n        polyfill && oninterval();\n    }\n    function getSVGAncestor(node) {\n        for (var svg = node; \"svg\" !== svg.nodeName.toLowerCase() && (svg = svg.parentNode); ) {}\n        return svg;\n    }\n    return svg4everybody;\n});","/**\n * requestAnimationFrame polyfill v1.0.1\n * requires Date.now\n *\n * © Polyfiller 2015\n * Released under the MIT license\n * github.com/Polyfiller/requestAnimationFrame\n */\nwindow.requestAnimationFrame || function () {\n\n    'use strict';\n\n    window.requestAnimationFrame = window.msRequestAnimationFrame\n    || window.mozRequestAnimationFrame\n    || window.webkitRequestAnimationFrame\n    || function () {\n\n        var fps = 60;\n        var delay = 1000 / fps;\n        var animationStartTime = Date.now();\n        var previousCallTime = animationStartTime;\n\n        return function requestAnimationFrame(callback) {\n\n            var requestTime = Date.now();\n            var timeout = Math.max(0, delay - (requestTime - previousCallTime));\n            var timeToCall = requestTime + timeout;\n\n            previousCallTime = timeToCall;\n\n            return window.setTimeout(function onAnimationFrame() {\n\n                callback(timeToCall - animationStartTime);\n\n            }, timeout);\n        };\n    }();\n\n    window.cancelAnimationFrame = window.mozCancelAnimationFrame\n    || window.webkitCancelAnimationFrame\n    || window.cancelRequestAnimationFrame\n    || window.msCancelRequestAnimationFrame\n    || window.mozCancelRequestAnimationFrame\n    || window.webkitCancelRequestAnimationFrame\n    || function cancelAnimationFrame(id) {\n           window.clearTimeout(id);\n       };\n\n}();\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n\n(function(window, document) {\n'use strict';\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}(window, document));\n","/*!\n * modernizr v3.6.0\n * Build https://modernizr.com/download?-objectfit-touchevents-setclasses-dontmin\n *\n * Copyright (c)\n *  Faruk Ates\n *  Paul Irish\n *  Alex Sexton\n *  Ryan Seddon\n *  Patrick Kettner\n *  Stu Cox\n *  Richard Herrera\n\n * MIT License\n */\n\n/*\n * Modernizr tests which native CSS3 and HTML5 features are available in the\n * current UA and makes the results available to you in two ways: as properties on\n * a global `Modernizr` object, and as classes on the `<html>` element. This\n * information allows you to progressively enhance your pages with a granular level\n * of control over the experience.\n*/\n\n;(function(window, document, undefined){\n  var classes = [];\n  \n\n  var tests = [];\n  \n\n  /**\n   *\n   * ModernizrProto is the constructor for Modernizr\n   *\n   * @class\n   * @access public\n   */\n\n  var ModernizrProto = {\n    // The current version, dummy\n    _version: '3.6.0',\n\n    // Any settings that don't work as separate modules\n    // can go in here as configuration.\n    _config: {\n      'classPrefix': '',\n      'enableClasses': true,\n      'enableJSClass': true,\n      'usePrefixes': true\n    },\n\n    // Queue of tests\n    _q: [],\n\n    // Stub these for people who are listening\n    on: function(test, cb) {\n      // I don't really think people should do this, but we can\n      // safe guard it a bit.\n      // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.\n      // This is in case people listen to synchronous tests. I would leave it out,\n      // but the code to *disallow* sync tests in the real version of this\n      // function is actually larger than this.\n      var self = this;\n      setTimeout(function() {\n        cb(self[test]);\n      }, 0);\n    },\n\n    addTest: function(name, fn, options) {\n      tests.push({name: name, fn: fn, options: options});\n    },\n\n    addAsyncTest: function(fn) {\n      tests.push({name: null, fn: fn});\n    }\n  };\n\n  \n\n  // Fake some of Object.create so we can force non test results to be non \"own\" properties.\n  var Modernizr = function() {};\n  Modernizr.prototype = ModernizrProto;\n\n  // Leak modernizr globally when you `require` it rather than force it here.\n  // Overwrite name so constructor name is nicer :D\n  Modernizr = new Modernizr();\n\n  \n\n  /**\n   * is returns a boolean if the typeof an obj is exactly type.\n   *\n   * @access private\n   * @function is\n   * @param {*} obj - A thing we want to check the type of\n   * @param {string} type - A string to compare the typeof against\n   * @returns {boolean}\n   */\n\n  function is(obj, type) {\n    return typeof obj === type;\n  }\n  ;\n\n  /**\n   * Run through all tests and detect their support in the current UA.\n   *\n   * @access private\n   */\n\n  function testRunner() {\n    var featureNames;\n    var feature;\n    var aliasIdx;\n    var result;\n    var nameIdx;\n    var featureName;\n    var featureNameSplit;\n\n    for (var featureIdx in tests) {\n      if (tests.hasOwnProperty(featureIdx)) {\n        featureNames = [];\n        feature = tests[featureIdx];\n        // run the test, throw the return value into the Modernizr,\n        // then based on that boolean, define an appropriate className\n        // and push it into an array of classes we'll join later.\n        //\n        // If there is no name, it's an 'async' test that is run,\n        // but not directly added to the object. That should\n        // be done with a post-run addTest call.\n        if (feature.name) {\n          featureNames.push(feature.name.toLowerCase());\n\n          if (feature.options && feature.options.aliases && feature.options.aliases.length) {\n            // Add all the aliases into the names list\n            for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) {\n              featureNames.push(feature.options.aliases[aliasIdx].toLowerCase());\n            }\n          }\n        }\n\n        // Run the test, or use the raw value if it's not a function\n        result = is(feature.fn, 'function') ? feature.fn() : feature.fn;\n\n\n        // Set each of the names on the Modernizr object\n        for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {\n          featureName = featureNames[nameIdx];\n          // Support dot properties as sub tests. We don't do checking to make sure\n          // that the implied parent tests have been added. You must call them in\n          // order (either in the test, or make the parent test a dependency).\n          //\n          // Cap it to TWO to make the logic simple and because who needs that kind of subtesting\n          // hashtag famous last words\n          featureNameSplit = featureName.split('.');\n\n          if (featureNameSplit.length === 1) {\n            Modernizr[featureNameSplit[0]] = result;\n          } else {\n            // cast to a Boolean, if not one already\n            if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n              Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n            }\n\n            Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;\n          }\n\n          classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));\n        }\n      }\n    }\n  }\n  ;\n\n  /**\n   * docElement is a convenience wrapper to grab the root element of the document\n   *\n   * @access private\n   * @returns {HTMLElement|SVGElement} The root element of the document\n   */\n\n  var docElement = document.documentElement;\n  \n\n  /**\n   * A convenience helper to check if the document we are running in is an SVG document\n   *\n   * @access private\n   * @returns {boolean}\n   */\n\n  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\n  \n\n  /**\n   * setClasses takes an array of class names and adds them to the root element\n   *\n   * @access private\n   * @function setClasses\n   * @param {string[]} classes - Array of class names\n   */\n\n  // Pass in an and array of class names, e.g.:\n  //  ['no-webp', 'borderradius', ...]\n  function setClasses(classes) {\n    var className = docElement.className;\n    var classPrefix = Modernizr._config.classPrefix || '';\n\n    if (isSVG) {\n      className = className.baseVal;\n    }\n\n    // Change `no-js` to `js` (independently of the `enableClasses` option)\n    // Handle classPrefix on this too\n    if (Modernizr._config.enableJSClass) {\n      var reJS = new RegExp('(^|\\\\s)' + classPrefix + 'no-js(\\\\s|$)');\n      className = className.replace(reJS, '$1' + classPrefix + 'js$2');\n    }\n\n    if (Modernizr._config.enableClasses) {\n      // Add the new classes\n      className += ' ' + classPrefix + classes.join(' ' + classPrefix);\n      if (isSVG) {\n        docElement.className.baseVal = className;\n      } else {\n        docElement.className = className;\n      }\n    }\n\n  }\n\n  ;\n\n  /**\n   * List of property values to set for css tests. See ticket #21\n   * http://git.io/vUGl4\n   *\n   * @memberof Modernizr\n   * @name Modernizr._prefixes\n   * @optionName Modernizr._prefixes\n   * @optionProp prefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._prefixes is the internal list of prefixes that we test against\n   * inside of things like [prefixed](#modernizr-prefixed) and [prefixedCSS](#-code-modernizr-prefixedcss). It is simply\n   * an array of kebab-case vendor prefixes you can use within your code.\n   *\n   * Some common use cases include\n   *\n   * Generating all possible prefixed version of a CSS property\n   * ```js\n   * var rule = Modernizr._prefixes.join('transform: rotate(20deg); ');\n   *\n   * rule === 'transform: rotate(20deg); webkit-transform: rotate(20deg); moz-transform: rotate(20deg); o-transform: rotate(20deg); ms-transform: rotate(20deg);'\n   * ```\n   *\n   * Generating all possible prefixed version of a CSS value\n   * ```js\n   * rule = 'display:' +  Modernizr._prefixes.join('flex; display:') + 'flex';\n   *\n   * rule === 'display:flex; display:-webkit-flex; display:-moz-flex; display:-o-flex; display:-ms-flex; display:flex'\n   * ```\n   */\n\n  // we use ['',''] rather than an empty array in order to allow a pattern of .`join()`ing prefixes to test\n  // values in feature detects to continue to work\n  var prefixes = (ModernizrProto._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : ['','']);\n\n  // expose these for the plugin API. Look in the source for how to join() them against your input\n  ModernizrProto._prefixes = prefixes;\n\n  \n\n  /**\n   * createElement is a convenience wrapper around document.createElement. Since we\n   * use createElement all over the place, this allows for (slightly) smaller code\n   * as well as abstracting away issues with creating elements in contexts other than\n   * HTML documents (e.g. SVG documents).\n   *\n   * @access private\n   * @function createElement\n   * @returns {HTMLElement|SVGElement} An HTML or SVG element\n   */\n\n  function createElement() {\n    if (typeof document.createElement !== 'function') {\n      // This is the case in IE7, where the type of createElement is \"object\".\n      // For this reason, we cannot call apply() as Object is not a Function.\n      return document.createElement(arguments[0]);\n    } else if (isSVG) {\n      return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]);\n    } else {\n      return document.createElement.apply(document, arguments);\n    }\n  }\n\n  ;\n\n  /**\n   * getBody returns the body of a document, or an element that can stand in for\n   * the body if a real body does not exist\n   *\n   * @access private\n   * @function getBody\n   * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an\n   * artificially created element that stands in for the body\n   */\n\n  function getBody() {\n    // After page load injecting a fake body doesn't work so check if body exists\n    var body = document.body;\n\n    if (!body) {\n      // Can't use the real body create a fake one.\n      body = createElement(isSVG ? 'svg' : 'body');\n      body.fake = true;\n    }\n\n    return body;\n  }\n\n  ;\n\n  /**\n   * injectElementWithStyles injects an element with style element and some CSS rules\n   *\n   * @access private\n   * @function injectElementWithStyles\n   * @param {string} rule - String representing a css rule\n   * @param {function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean}\n   */\n\n  function injectElementWithStyles(rule, callback, nodes, testnames) {\n    var mod = 'modernizr';\n    var style;\n    var ret;\n    var node;\n    var docOverflow;\n    var div = createElement('div');\n    var body = getBody();\n\n    if (parseInt(nodes, 10)) {\n      // In order not to give false positives we create a node for each test\n      // This also allows the method to scale for unspecified uses\n      while (nodes--) {\n        node = createElement('div');\n        node.id = testnames ? testnames[nodes] : mod + (nodes + 1);\n        div.appendChild(node);\n      }\n    }\n\n    style = createElement('style');\n    style.type = 'text/css';\n    style.id = 's' + mod;\n\n    // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.\n    // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270\n    (!body.fake ? div : body).appendChild(style);\n    body.appendChild(div);\n\n    if (style.styleSheet) {\n      style.styleSheet.cssText = rule;\n    } else {\n      style.appendChild(document.createTextNode(rule));\n    }\n    div.id = mod;\n\n    if (body.fake) {\n      //avoid crashing IE8, if background image is used\n      body.style.background = '';\n      //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible\n      body.style.overflow = 'hidden';\n      docOverflow = docElement.style.overflow;\n      docElement.style.overflow = 'hidden';\n      docElement.appendChild(body);\n    }\n\n    ret = callback(div, rule);\n    // If this is done after page load we don't want to remove the body so check if body exists\n    if (body.fake) {\n      body.parentNode.removeChild(body);\n      docElement.style.overflow = docOverflow;\n      // Trigger layout so kinetic scrolling isn't disabled in iOS6+\n      // eslint-disable-next-line\n      docElement.offsetHeight;\n    } else {\n      div.parentNode.removeChild(div);\n    }\n\n    return !!ret;\n\n  }\n\n  ;\n\n  /**\n   * testStyles injects an element with style element and some CSS rules\n   *\n   * @memberof Modernizr\n   * @name Modernizr.testStyles\n   * @optionName Modernizr.testStyles()\n   * @optionProp testStyles\n   * @access public\n   * @function testStyles\n   * @param {string} rule - String representing a css rule\n   * @param {function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean}\n   * @example\n   *\n   * `Modernizr.testStyles` takes a CSS rule and injects it onto the current page\n   * along with (possibly multiple) DOM elements. This lets you check for features\n   * that can not be detected by simply checking the [IDL](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Interface_development_guide/IDL_interface_rules).\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr { width: 9px; color: papayawhip; }', function(elem, rule) {\n   *   // elem is the first DOM node in the page (by default #modernizr)\n   *   // rule is the first argument you supplied - the CSS rule in string form\n   *\n   *   addTest('widthworks', elem.style.width === '9px')\n   * });\n   * ```\n   *\n   * If your test requires multiple nodes, you can include a third argument\n   * indicating how many additional div elements to include on the page. The\n   * additional nodes are injected as children of the `elem` that is returned as\n   * the first argument to the callback.\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr {width: 1px}; #modernizr2 {width: 2px}', function(elem) {\n   *   document.getElementById('modernizr').style.width === '1px'; // true\n   *   document.getElementById('modernizr2').style.width === '2px'; // true\n   *   elem.firstChild === document.getElementById('modernizr2'); // true\n   * }, 1);\n   * ```\n   *\n   * By default, all of the additional elements have an ID of `modernizr[n]`, where\n   * `n` is its index (e.g. the first additional, second overall is `#modernizr2`,\n   * the second additional is `#modernizr3`, etc.).\n   * If you want to have more meaningful IDs for your function, you can provide\n   * them as the fourth argument, as an array of strings\n   *\n   * ```js\n   * Modernizr.testStyles('#foo {width: 10px}; #bar {height: 20px}', function(elem) {\n   *   elem.firstChild === document.getElementById('foo'); // true\n   *   elem.lastChild === document.getElementById('bar'); // true\n   * }, 2, ['foo', 'bar']);\n   * ```\n   *\n   */\n\n  var testStyles = ModernizrProto.testStyles = injectElementWithStyles;\n  \n/*!\n{\n  \"name\": \"Touch Events\",\n  \"property\": \"touchevents\",\n  \"caniuse\" : \"touch\",\n  \"tags\": [\"media\", \"attribute\"],\n  \"notes\": [{\n    \"name\": \"Touch Events spec\",\n    \"href\": \"https://www.w3.org/TR/2013/WD-touch-events-20130124/\"\n  }],\n  \"warnings\": [\n    \"Indicates if the browser supports the Touch Events spec, and does not necessarily reflect a touchscreen device\"\n  ],\n  \"knownBugs\": [\n    \"False-positive on some configurations of Nokia N900\",\n    \"False-positive on some BlackBerry 6.0 builds – https://github.com/Modernizr/Modernizr/issues/372#issuecomment-3112695\"\n  ]\n}\n!*/\n/* DOC\nIndicates if the browser supports the W3C Touch Events API.\n\nThis *does not* necessarily reflect a touchscreen device:\n\n* Older touchscreen devices only emulate mouse events\n* Modern IE touch devices implement the Pointer Events API instead: use `Modernizr.pointerevents` to detect support for that\n* Some browsers & OS setups may enable touch APIs when no touchscreen is connected\n* Future browsers may implement other event models for touch interactions\n\nSee this article: [You Can't Detect A Touchscreen](http://www.stucox.com/blog/you-cant-detect-a-touchscreen/).\n\nIt's recommended to bind both mouse and touch/pointer events simultaneously – see [this HTML5 Rocks tutorial](http://www.html5rocks.com/en/mobile/touchandmouse/).\n\nThis test will also return `true` for Firefox 4 Multitouch support.\n*/\n\n  // Chrome (desktop) used to lie about its support on this, but that has since been rectified: http://crbug.com/36415\n  Modernizr.addTest('touchevents', function() {\n    var bool;\n    if (('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch) {\n      bool = true;\n    } else {\n      // include the 'heartz' as a way to have a non matching MQ to help terminate the join\n      // https://git.io/vznFH\n      var query = ['@media (', prefixes.join('touch-enabled),('), 'heartz', ')', '{#modernizr{top:9px;position:absolute}}'].join('');\n      testStyles(query, function(node) {\n        bool = node.offsetTop === 9;\n      });\n    }\n    return bool;\n  });\n\n\n  /**\n   * cssToDOM takes a kebab-case string and converts it to camelCase\n   * e.g. box-sizing -> boxSizing\n   *\n   * @access private\n   * @function cssToDOM\n   * @param {string} name - String name of kebab-case prop we want to convert\n   * @returns {string} The camelCase version of the supplied name\n   */\n\n  function cssToDOM(name) {\n    return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) {\n      return m1 + m2.toUpperCase();\n    }).replace(/^-/, '');\n  }\n  ;\n\n  /**\n   * If the browsers follow the spec, then they would expose vendor-specific styles as:\n   *   elem.style.WebkitBorderRadius\n   * instead of something like the following (which is technically incorrect):\n   *   elem.style.webkitBorderRadius\n\n   * WebKit ghosts their properties in lowercase but Opera & Moz do not.\n   * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+\n   *   erik.eae.net/archives/2008/03/10/21.48.10/\n\n   * More here: github.com/Modernizr/Modernizr/issues/issue/21\n   *\n   * @access private\n   * @returns {string} The string representing the vendor-specific style properties\n   */\n\n  var omPrefixes = 'Moz O ms Webkit';\n  \n\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\n  \n\n  /**\n   * atRule returns a given CSS property at-rule (eg @keyframes), possibly in\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @memberof Modernizr\n   * @name Modernizr.atRule\n   * @optionName Modernizr.atRule()\n   * @optionProp atRule\n   * @access public\n   * @function atRule\n   * @param {string} prop - String name of the @-rule to test for\n   * @returns {string|boolean} The string representing the (possibly prefixed)\n   * valid version of the @-rule, or `false` when it is unsupported.\n   * @example\n   * ```js\n   *  var keyframes = Modernizr.atRule('@keyframes');\n   *\n   *  if (keyframes) {\n   *    // keyframes are supported\n   *    // could be `@-webkit-keyframes` or `@keyframes`\n   *  } else {\n   *    // keyframes === `false`\n   *  }\n   * ```\n   *\n   */\n\n  var atRule = function(prop) {\n    var length = prefixes.length;\n    var cssrule = window.CSSRule;\n    var rule;\n\n    if (typeof cssrule === 'undefined') {\n      return undefined;\n    }\n\n    if (!prop) {\n      return false;\n    }\n\n    // remove literal @ from beginning of provided property\n    prop = prop.replace(/^@/, '');\n\n    // CSSRules use underscores instead of dashes\n    rule = prop.replace(/-/g, '_').toUpperCase() + '_RULE';\n\n    if (rule in cssrule) {\n      return '@' + prop;\n    }\n\n    for (var i = 0; i < length; i++) {\n      // prefixes gives us something like -o-, and we want O_\n      var prefix = prefixes[i];\n      var thisRule = prefix.toUpperCase() + '_' + rule;\n\n      if (thisRule in cssrule) {\n        return '@-' + prefix.toLowerCase() + '-' + prop;\n      }\n    }\n\n    return false;\n  };\n\n  ModernizrProto.atRule = atRule;\n\n  \n\n  /**\n   * List of JavaScript DOM values used for tests\n   *\n   * @memberof Modernizr\n   * @name Modernizr._domPrefixes\n   * @optionName Modernizr._domPrefixes\n   * @optionProp domPrefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather\n   * than kebab-case properties, all properties are their Capitalized variant\n   *\n   * ```js\n   * Modernizr._domPrefixes === [ \"Moz\", \"O\", \"ms\", \"Webkit\" ];\n   * ```\n   */\n\n  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\n  ModernizrProto._domPrefixes = domPrefixes;\n  \n\n\n  /**\n   * contains checks to see if a string contains another string\n   *\n   * @access private\n   * @function contains\n   * @param {string} str - The string we want to check for substrings\n   * @param {string} substr - The substring we want to search the first string for\n   * @returns {boolean}\n   */\n\n  function contains(str, substr) {\n    return !!~('' + str).indexOf(substr);\n  }\n\n  ;\n\n  /**\n   * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill.\n   *\n   * @access private\n   * @function fnBind\n   * @param {function} fn - a function you want to change `this` reference to\n   * @param {object} that - the `this` you want to call the function with\n   * @returns {function} The wrapped version of the supplied function\n   */\n\n  function fnBind(fn, that) {\n    return function() {\n      return fn.apply(that, arguments);\n    };\n  }\n\n  ;\n\n  /**\n   * testDOMProps is a generic DOM property test; if a browser supports\n   *   a certain property, it won't return undefined for it.\n   *\n   * @access private\n   * @function testDOMProps\n   * @param {array.<string>} props - An array of properties to test for\n   * @param {object} obj - An object or Element you want to use to test the parameters again\n   * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check\n   * @returns {false|*} returns false if the prop is unsupported, otherwise the value that is supported\n   */\n  function testDOMProps(props, obj, elem) {\n    var item;\n\n    for (var i in props) {\n      if (props[i] in obj) {\n\n        // return the property name as a string\n        if (elem === false) {\n          return props[i];\n        }\n\n        item = obj[props[i]];\n\n        // let's bind a function\n        if (is(item, 'function')) {\n          // bind to obj unless overriden\n          return fnBind(item, elem || obj);\n        }\n\n        // return the unbound function or obj or value\n        return item;\n      }\n    }\n    return false;\n  }\n\n  ;\n\n  /**\n   * Create our \"modernizr\" element that we do most feature tests on.\n   *\n   * @access private\n   */\n\n  var modElem = {\n    elem: createElement('modernizr')\n  };\n\n  // Clean up this element\n  Modernizr._q.push(function() {\n    delete modElem.elem;\n  });\n\n  \n\n  var mStyle = {\n    style: modElem.elem.style\n  };\n\n  // kill ref for gc, must happen before mod.elem is removed, so we unshift on to\n  // the front of the queue.\n  Modernizr._q.unshift(function() {\n    delete mStyle.style;\n  });\n\n  \n\n  /**\n   * domToCSS takes a camelCase string and converts it to kebab-case\n   * e.g. boxSizing -> box-sizing\n   *\n   * @access private\n   * @function domToCSS\n   * @param {string} name - String name of camelCase prop we want to convert\n   * @returns {string} The kebab-case version of the supplied name\n   */\n\n  function domToCSS(name) {\n    return name.replace(/([A-Z])/g, function(str, m1) {\n      return '-' + m1.toLowerCase();\n    }).replace(/^ms-/, '-ms-');\n  }\n  ;\n\n\n  /**\n   * wrapper around getComputedStyle, to fix issues with Firefox returning null when\n   * called inside of a hidden iframe\n   *\n   * @access private\n   * @function computedStyle\n   * @param {HTMLElement|SVGElement} - The element we want to find the computed styles of\n   * @param {string|null} [pseudoSelector]- An optional pseudo element selector (e.g. :before), of null if none\n   * @returns {CSSStyleDeclaration}\n   */\n\n  function computedStyle(elem, pseudo, prop) {\n    var result;\n\n    if ('getComputedStyle' in window) {\n      result = getComputedStyle.call(window, elem, pseudo);\n      var console = window.console;\n\n      if (result !== null) {\n        if (prop) {\n          result = result.getPropertyValue(prop);\n        }\n      } else {\n        if (console) {\n          var method = console.error ? 'error' : 'log';\n          console[method].call(console, 'getComputedStyle returning null, its possible modernizr test results are inaccurate');\n        }\n      }\n    } else {\n      result = !pseudo && elem.currentStyle && elem.currentStyle[prop];\n    }\n\n    return result;\n  }\n\n  ;\n\n  /**\n   * nativeTestProps allows for us to use native feature detection functionality if available.\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @access private\n   * @function nativeTestProps\n   * @param {array} props - An array of property names\n   * @param {string} value - A string representing the value we want to check via @supports\n   * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise\n   */\n\n  // Accepts a list of property names and a single value\n  // Returns `undefined` if native detection not available\n  function nativeTestProps(props, value) {\n    var i = props.length;\n    // Start with the JS API: http://www.w3.org/TR/css3-conditional/#the-css-interface\n    if ('CSS' in window && 'supports' in window.CSS) {\n      // Try every prefixed variant of the property\n      while (i--) {\n        if (window.CSS.supports(domToCSS(props[i]), value)) {\n          return true;\n        }\n      }\n      return false;\n    }\n    // Otherwise fall back to at-rule (for Opera 12.x)\n    else if ('CSSSupportsRule' in window) {\n      // Build a condition string for every prefixed variant\n      var conditionText = [];\n      while (i--) {\n        conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')');\n      }\n      conditionText = conditionText.join(' or ');\n      return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) {\n        return computedStyle(node, null, 'position') == 'absolute';\n      });\n    }\n    return undefined;\n  }\n  ;\n\n  // testProps is a generic CSS / DOM property test.\n\n  // In testing support for a given CSS property, it's legit to test:\n  //    `elem.style[styleName] !== undefined`\n  // If the property is supported it will return an empty string,\n  // if unsupported it will return undefined.\n\n  // We'll take advantage of this quick test and skip setting a style\n  // on our modernizr element, but instead just testing undefined vs\n  // empty string.\n\n  // Property names can be provided in either camelCase or kebab-case.\n\n  function testProps(props, prefixed, value, skipValueTest) {\n    skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest;\n\n    // Try native detect first\n    if (!is(value, 'undefined')) {\n      var result = nativeTestProps(props, value);\n      if (!is(result, 'undefined')) {\n        return result;\n      }\n    }\n\n    // Otherwise do it properly\n    var afterInit, i, propsLength, prop, before;\n\n    // If we don't have a style element, that means we're running async or after\n    // the core tests, so we'll need to create our own elements to use\n\n    // inside of an SVG element, in certain browsers, the `style` element is only\n    // defined for valid tags. Therefore, if `modernizr` does not have one, we\n    // fall back to a less used element and hope for the best.\n    // for strict XHTML browsers the hardly used samp element is used\n    var elems = ['modernizr', 'tspan', 'samp'];\n    while (!mStyle.style && elems.length) {\n      afterInit = true;\n      mStyle.modElem = createElement(elems.shift());\n      mStyle.style = mStyle.modElem.style;\n    }\n\n    // Delete the objects if we created them.\n    function cleanElems() {\n      if (afterInit) {\n        delete mStyle.style;\n        delete mStyle.modElem;\n      }\n    }\n\n    propsLength = props.length;\n    for (i = 0; i < propsLength; i++) {\n      prop = props[i];\n      before = mStyle.style[prop];\n\n      if (contains(prop, '-')) {\n        prop = cssToDOM(prop);\n      }\n\n      if (mStyle.style[prop] !== undefined) {\n\n        // If value to test has been passed in, do a set-and-check test.\n        // 0 (integer) is a valid property value, so check that `value` isn't\n        // undefined, rather than just checking it's truthy.\n        if (!skipValueTest && !is(value, 'undefined')) {\n\n          // Needs a try catch block because of old IE. This is slow, but will\n          // be avoided in most cases because `skipValueTest` will be used.\n          try {\n            mStyle.style[prop] = value;\n          } catch (e) {}\n\n          // If the property value has changed, we assume the value used is\n          // supported. If `value` is empty string, it'll fail here (because\n          // it hasn't changed), which matches how browsers have implemented\n          // CSS.supports()\n          if (mStyle.style[prop] != before) {\n            cleanElems();\n            return prefixed == 'pfx' ? prop : true;\n          }\n        }\n        // Otherwise just return true, or the property name if this is a\n        // `prefixed()` call\n        else {\n          cleanElems();\n          return prefixed == 'pfx' ? prop : true;\n        }\n      }\n    }\n    cleanElems();\n    return false;\n  }\n\n  ;\n\n  /**\n   * testPropsAll tests a list of DOM properties we want to check against.\n   * We specify literally ALL possible (known and/or likely) properties on\n   * the element including the non-vendor prefixed one, for forward-\n   * compatibility.\n   *\n   * @access private\n   * @function testPropsAll\n   * @param {string} prop - A string of the property to test for\n   * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip\n   * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against\n   * @param {string} [value] - A string of a css value\n   * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set\n   * @returns {false|string} returns the string version of the property, or false if it is unsupported\n   */\n  function testPropsAll(prop, prefixed, elem, value, skipValueTest) {\n\n    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),\n      props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');\n\n    // did they call .prefixed('boxSizing') or are we just testing a prop?\n    if (is(prefixed, 'string') || is(prefixed, 'undefined')) {\n      return testProps(props, prefixed, value, skipValueTest);\n\n      // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])\n    } else {\n      props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');\n      return testDOMProps(props, prefixed, elem);\n    }\n  }\n\n  // Modernizr.testAllProps() investigates whether a given style property,\n  // or any of its vendor-prefixed variants, is recognized\n  //\n  // Note that the property names must be provided in the camelCase variant.\n  // Modernizr.testAllProps('boxSizing')\n  ModernizrProto.testAllProps = testPropsAll;\n\n  \n\n  /**\n   * prefixed returns the prefixed or nonprefixed property name variant of your input\n   *\n   * @memberof Modernizr\n   * @name Modernizr.prefixed\n   * @optionName Modernizr.prefixed()\n   * @optionProp prefixed\n   * @access public\n   * @function prefixed\n   * @param {string} prop - String name of the property to test for\n   * @param {object} [obj] - An object to test for the prefixed properties on\n   * @param {HTMLElement} [elem] - An element used to test specific properties against\n   * @returns {string|false} The string representing the (possibly prefixed) valid\n   * version of the property, or `false` when it is unsupported.\n   * @example\n   *\n   * Modernizr.prefixed takes a string css value in the DOM style camelCase (as\n   * opposed to the css style kebab-case) form and returns the (possibly prefixed)\n   * version of that property that the browser actually supports.\n   *\n   * For example, in older Firefox...\n   * ```js\n   * prefixed('boxSizing')\n   * ```\n   * returns 'MozBoxSizing'\n   *\n   * In newer Firefox, as well as any other browser that support the unprefixed\n   * version would simply return `boxSizing`. Any browser that does not support\n   * the property at all, it will return `false`.\n   *\n   * By default, prefixed is checked against a DOM element. If you want to check\n   * for a property on another object, just pass it as a second argument\n   *\n   * ```js\n   * var rAF = prefixed('requestAnimationFrame', window);\n   *\n   * raf(function() {\n   *  renderFunction();\n   * })\n   * ```\n   *\n   * Note that this will return _the actual function_ - not the name of the function.\n   * If you need the actual name of the property, pass in `false` as a third argument\n   *\n   * ```js\n   * var rAFProp = prefixed('requestAnimationFrame', window, false);\n   *\n   * rafProp === 'WebkitRequestAnimationFrame' // in older webkit\n   * ```\n   *\n   * One common use case for prefixed is if you're trying to determine which transition\n   * end event to bind to, you might do something like...\n   * ```js\n   * var transEndEventNames = {\n   *     'WebkitTransition' : 'webkitTransitionEnd', * Saf 6, Android Browser\n   *     'MozTransition'    : 'transitionend',       * only for FF < 15\n   *     'transition'       : 'transitionend'        * IE10, Opera, Chrome, FF 15+, Saf 7+\n   * };\n   *\n   * var transEndEventName = transEndEventNames[ Modernizr.prefixed('transition') ];\n   * ```\n   *\n   * If you want a similar lookup, but in kebab-case, you can use [prefixedCSS](#modernizr-prefixedcss).\n   */\n\n  var prefixed = ModernizrProto.prefixed = function(prop, obj, elem) {\n    if (prop.indexOf('@') === 0) {\n      return atRule(prop);\n    }\n\n    if (prop.indexOf('-') != -1) {\n      // Convert kebab-case to camelCase\n      prop = cssToDOM(prop);\n    }\n    if (!obj) {\n      return testPropsAll(prop, 'pfx');\n    } else {\n      // Testing DOM property e.g. Modernizr.prefixed('requestAnimationFrame', window) // 'mozRequestAnimationFrame'\n      return testPropsAll(prop, obj, elem);\n    }\n  };\n\n  \n/*!\n{\n  \"name\": \"CSS Object Fit\",\n  \"caniuse\": \"object-fit\",\n  \"property\": \"objectfit\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_objectfit\"],\n  \"notes\": [{\n    \"name\": \"Opera Article on Object Fit\",\n    \"href\": \"https://dev.opera.com/articles/css3-object-fit-object-position/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('objectfit', !!prefixed('objectFit'), {aliases: ['object-fit']});\n\n\n  // Run each test\n  testRunner();\n\n  // Remove the \"no-js\" class if it exists\n  setClasses(classes);\n\n  delete ModernizrProto.addTest;\n  delete ModernizrProto.addAsyncTest;\n\n  // Run the things that are supposed to run after the tests\n  for (var i = 0; i < Modernizr._q.length; i++) {\n    Modernizr._q[i]();\n  }\n\n  // Leak Modernizr namespace\n  window.Modernizr = Modernizr;\n\n\n;\n\n})(window, document);\n\n/**\n * _browser.js\n * Display a message to non supported browser.\n *\n * If needed you can update the markup of the message\n * and/or the body of browserIsCompatible() function to adjust the test based on which browsers you want to support.\n */\n\n$(function() {\n  'use strict';\n\n  var html = '<div class=\"c-browser\">\\\n                <strong class=\"c-browser__title\">Votre version de navigateur est obsolète.</strong>\\\n                <p class=\"c-browser__content\">Mettez à jour votre navigateur pour afficher correctement ce site Web.</p>\\\n                <div class=\"c-browser__action\">\\\n                  <a href=\"http://outdatedbrowser.com/fr\" class=\"c-button c-button--primary c-browser__button\">\\\n                    <span class=\"c-button__text\">Mettre à jour maintenant</span>\\\n                  </a>\\\n                </div>\\\n              </div>';\n\n  function browserIsCompatible(){\n    // By default we treat all browsers has compatible\n    var isCompatible = true;\n\n    /*\n     * No IE versions supports @supports{} and if we rely on caniuse stats this feature is pretty well supported :\n     * https://caniuse.com/#search=supports\n     * So this must cover our comptaibility expectations (usually last 2 versions)\n     */\n    var cssSupports = 'CSS' in window && 'supports' in window.CSS || 'supportsCSS' in window;\n    // Target IE11 only : https://stackoverflow.com/questions/21825157/internet-explorer-11-detection\n    var isIE11 = !!window.MSInputMethodContext && !!document.documentMode;\n\n    // If doesn't support @supports{} and is not IE11\n    if(!cssSupports && !isIE11){\n      isCompatible = false;\n    }\n\n    return isCompatible;\n  }\n\n  // When DOM is ready, if browser is not supported then we display the disclaimer message.\n  $(document).ready(function(){\n    if(!browserIsCompatible()){\n      $('body').prepend(html);\n    }\n  });\n\n});\n\n!function(root, factory) {\n    \"function\" == typeof define && define.amd ? // AMD. Register as an anonymous module unless amdModuleId is set\n    define([], function() {\n        return root.svg4everybody = factory();\n    }) : \"object\" == typeof module && module.exports ? // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory() : root.svg4everybody = factory();\n}(this, function() {\n    /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */\n    function embed(parent, svg, target) {\n        // if the target exists\n        if (target) {\n            // create a document fragment to hold the contents of the target\n            var fragment = document.createDocumentFragment(), viewBox = !svg.hasAttribute(\"viewBox\") && target.getAttribute(\"viewBox\");\n            // conditionally set the viewBox on the svg\n            viewBox && svg.setAttribute(\"viewBox\", viewBox);\n            // copy the contents of the clone into the fragment\n            for (// clone the target\n            var clone = target.cloneNode(!0); clone.childNodes.length; ) {\n                fragment.appendChild(clone.firstChild);\n            }\n            // append the fragment into the svg\n            parent.appendChild(fragment);\n        }\n    }\n    function loadreadystatechange(xhr) {\n        // listen to changes in the request\n        xhr.onreadystatechange = function() {\n            // if the request is ready\n            if (4 === xhr.readyState) {\n                // get the cached html document\n                var cachedDocument = xhr._cachedDocument;\n                // ensure the cached html document based on the xhr response\n                cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(\"\"), \n                cachedDocument.body.innerHTML = xhr.responseText, xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item\n                xhr._embeds.splice(0).map(function(item) {\n                    // get the cached target\n                    var target = xhr._cachedTarget[item.id];\n                    // ensure the cached target\n                    target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), \n                    // embed the target into the svg\n                    embed(item.parent, item.svg, target);\n                });\n            }\n        }, // test the ready state change immediately\n        xhr.onreadystatechange();\n    }\n    function svg4everybody(rawopts) {\n        function oninterval() {\n            // while the index exists in the live <use> collection\n            for (// get the cached <use> index\n            var index = 0; index < uses.length; ) {\n                // get the current <use>\n                var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute(\"xlink:href\") || use.getAttribute(\"href\");\n                if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), \n                svg && src) {\n                    if (polyfill) {\n                        if (!opts.validate || opts.validate(src, svg, use)) {\n                            // remove the <use> element\n                            parent.removeChild(use);\n                            // parse the src and get the url and id\n                            var srcSplit = src.split(\"#\"), url = srcSplit.shift(), id = srcSplit.join(\"#\");\n                            // if the link is external\n                            if (url.length) {\n                                // get the cached xhr request\n                                var xhr = requests[url];\n                                // ensure the xhr request exists\n                                xhr || (xhr = requests[url] = new XMLHttpRequest(), xhr.open(\"GET\", url), xhr.send(), \n                                xhr._embeds = []), // add the svg and id as an item to the xhr embeds list\n                                xhr._embeds.push({\n                                    parent: parent,\n                                    svg: svg,\n                                    id: id\n                                }), // prepare the xhr ready state change event\n                                loadreadystatechange(xhr);\n                            } else {\n                                // embed the local id into the svg\n                                embed(parent, svg, document.getElementById(id));\n                            }\n                        } else {\n                            // increase the index when the previous value was not \"valid\"\n                            ++index, ++numberOfSvgUseElementsToBypass;\n                        }\n                    }\n                } else {\n                    // increase the index when the previous value was not \"valid\"\n                    ++index;\n                }\n            }\n            // continue the interval\n            (!uses.length || uses.length - numberOfSvgUseElementsToBypass > 0) && requestAnimationFrame(oninterval, 67);\n        }\n        var polyfill, opts = Object(rawopts), newerIEUA = /\\bTrident\\/[567]\\b|\\bMSIE (?:9|10)\\.0\\b/, webkitUA = /\\bAppleWebKit\\/(\\d+)\\b/, olderEdgeUA = /\\bEdge\\/12\\.(\\d+)\\b/, edgeUA = /\\bEdge\\/.(\\d+)\\b/, inIframe = window.top !== window.self;\n        polyfill = \"polyfill\" in opts ? opts.polyfill : newerIEUA.test(navigator.userAgent) || (navigator.userAgent.match(olderEdgeUA) || [])[1] < 10547 || (navigator.userAgent.match(webkitUA) || [])[1] < 537 || edgeUA.test(navigator.userAgent) && inIframe;\n        // create xhr requests object\n        var requests = {}, requestAnimationFrame = window.requestAnimationFrame || setTimeout, uses = document.getElementsByTagName(\"use\"), numberOfSvgUseElementsToBypass = 0;\n        // conditionally start the interval if the polyfill is active\n        polyfill && oninterval();\n    }\n    function getSVGAncestor(node) {\n        for (var svg = node; \"svg\" !== svg.nodeName.toLowerCase() && (svg = svg.parentNode); ) {}\n        return svg;\n    }\n    return svg4everybody;\n});\n/**\n * requestAnimationFrame polyfill v1.0.1\n * requires Date.now\n *\n * © Polyfiller 2015\n * Released under the MIT license\n * github.com/Polyfiller/requestAnimationFrame\n */\nwindow.requestAnimationFrame || function () {\n\n    'use strict';\n\n    window.requestAnimationFrame = window.msRequestAnimationFrame\n    || window.mozRequestAnimationFrame\n    || window.webkitRequestAnimationFrame\n    || function () {\n\n        var fps = 60;\n        var delay = 1000 / fps;\n        var animationStartTime = Date.now();\n        var previousCallTime = animationStartTime;\n\n        return function requestAnimationFrame(callback) {\n\n            var requestTime = Date.now();\n            var timeout = Math.max(0, delay - (requestTime - previousCallTime));\n            var timeToCall = requestTime + timeout;\n\n            previousCallTime = timeToCall;\n\n            return window.setTimeout(function onAnimationFrame() {\n\n                callback(timeToCall - animationStartTime);\n\n            }, timeout);\n        };\n    }();\n\n    window.cancelAnimationFrame = window.mozCancelAnimationFrame\n    || window.webkitCancelAnimationFrame\n    || window.cancelRequestAnimationFrame\n    || window.msCancelRequestAnimationFrame\n    || window.mozCancelRequestAnimationFrame\n    || window.webkitCancelRequestAnimationFrame\n    || function cancelAnimationFrame(id) {\n           window.clearTimeout(id);\n       };\n\n}();\n\n\nsvg4everybody();\n\n/**\n * External links\n */\n\n// Open external links in new window\n(function () {\n  $(document).find('a[href]:not([href=\"#\"])').each(function (index, link) {\n    var isBlankable =\n      !link.href.match(/^(mailto|tel)\\:/) &&                                                       // Ignore mailto and tel\n      (link.href.match(/\\.(pdf|xls|doc|ppt)/) ||                                                   // Enable if document\n        (link.hostname != location.hostname && (!link.download || !link.target || !link.rel)));    // Enable if different domain with no download, target or rel attributes\n\n    if (isBlankable) {\n      link.target = \"_blank\";\n      link.rel = \"noopener\";\n    }\n  });\n})();\n\n\n\n/**\n\n\n * Copyright 2016 Google Inc. All Rights Reserved.\n\n\n *\n\n\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n\n\n *\n\n\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n\n\n *\n\n\n */\n\n\n\n\n\n(function(window, document) {\n\n\n'use strict';\n\n\n\n\n\n\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n\n\n// features are natively supported.\n\n\nif ('IntersectionObserver' in window &&\n\n\n    'IntersectionObserverEntry' in window &&\n\n\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n\n\n\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n\n\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n\n\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n\n\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n\n\n      'isIntersecting', {\n\n\n      get: function () {\n\n\n        return this.intersectionRatio > 0;\n\n\n      }\n\n\n    });\n\n\n  }\n\n\n  return;\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * An IntersectionObserver registry. This registry exists to hold a strong\n\n\n * reference to IntersectionObserver instances currently observing a target\n\n\n * element. Without this registry, instances without another reference may be\n\n\n * garbage collected.\n\n\n */\n\n\nvar registry = [];\n\n\n\n\n\n\n\n\n/**\n\n\n * Creates the global IntersectionObserverEntry constructor.\n\n\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n\n\n * @param {Object} entry A dictionary of instance properties.\n\n\n * @constructor\n\n\n */\n\n\nfunction IntersectionObserverEntry(entry) {\n\n\n  this.time = entry.time;\n\n\n  this.target = entry.target;\n\n\n  this.rootBounds = entry.rootBounds;\n\n\n  this.boundingClientRect = entry.boundingClientRect;\n\n\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n\n\n  this.isIntersecting = !!entry.intersectionRect;\n\n\n\n\n\n  // Calculates the intersection ratio.\n\n\n  var targetRect = this.boundingClientRect;\n\n\n  var targetArea = targetRect.width * targetRect.height;\n\n\n  var intersectionRect = this.intersectionRect;\n\n\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n\n\n\n\n  // Sets intersection ratio.\n\n\n  if (targetArea) {\n\n\n    // Round the intersection ratio to avoid floating point math issues:\n\n\n    // https://github.com/w3c/IntersectionObserver/issues/324\n\n\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n\n\n  } else {\n\n\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n\n\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n\n\n  }\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Creates the global IntersectionObserver constructor.\n\n\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n\n\n * @param {Function} callback The function to be invoked after intersection\n\n\n *     changes have queued. The function is not invoked if the queue has\n\n\n *     been emptied by calling the `takeRecords` method.\n\n\n * @param {Object=} opt_options Optional configuration options.\n\n\n * @constructor\n\n\n */\n\n\nfunction IntersectionObserver(callback, opt_options) {\n\n\n\n\n\n  var options = opt_options || {};\n\n\n\n\n\n  if (typeof callback != 'function') {\n\n\n    throw new Error('callback must be a function');\n\n\n  }\n\n\n\n\n\n  if (options.root && options.root.nodeType != 1) {\n\n\n    throw new Error('root must be an Element');\n\n\n  }\n\n\n\n\n\n  // Binds and throttles `this._checkForIntersections`.\n\n\n  this._checkForIntersections = throttle(\n\n\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n\n\n\n\n  // Private properties.\n\n\n  this._callback = callback;\n\n\n  this._observationTargets = [];\n\n\n  this._queuedEntries = [];\n\n\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n\n\n\n\n  // Public properties.\n\n\n  this.thresholds = this._initThresholds(options.threshold);\n\n\n  this.root = options.root || null;\n\n\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n\n\n    return margin.value + margin.unit;\n\n\n  }).join(' ');\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * The minimum interval within which the document will be checked for\n\n\n * intersection changes.\n\n\n */\n\n\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n\n\n\n\n\n\n/**\n\n\n * The frequency in which the polyfill polls for intersection changes.\n\n\n * this can be updated on a per instance basis and must be set prior to\n\n\n * calling `observe` on the first target.\n\n\n */\n\n\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n\n\n\n\n/**\n\n\n * Use a mutation observer on the root element\n\n\n * to detect intersection changes.\n\n\n */\n\n\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n\n\n\n\n\n\n/**\n\n\n * Starts observing a target element for intersection changes based on\n\n\n * the thresholds values.\n\n\n * @param {Element} target The DOM element to observe.\n\n\n */\n\n\nIntersectionObserver.prototype.observe = function(target) {\n\n\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n\n\n    return item.element == target;\n\n\n  });\n\n\n\n\n\n  if (isTargetAlreadyObserved) {\n\n\n    return;\n\n\n  }\n\n\n\n\n\n  if (!(target && target.nodeType == 1)) {\n\n\n    throw new Error('target must be an Element');\n\n\n  }\n\n\n\n\n\n  this._registerInstance();\n\n\n  this._observationTargets.push({element: target, entry: null});\n\n\n  this._monitorIntersections();\n\n\n  this._checkForIntersections();\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Stops observing a target element for intersection changes.\n\n\n * @param {Element} target The DOM element to observe.\n\n\n */\n\n\nIntersectionObserver.prototype.unobserve = function(target) {\n\n\n  this._observationTargets =\n\n\n      this._observationTargets.filter(function(item) {\n\n\n\n\n\n    return item.element != target;\n\n\n  });\n\n\n  if (!this._observationTargets.length) {\n\n\n    this._unmonitorIntersections();\n\n\n    this._unregisterInstance();\n\n\n  }\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Stops observing all target elements for intersection changes.\n\n\n */\n\n\nIntersectionObserver.prototype.disconnect = function() {\n\n\n  this._observationTargets = [];\n\n\n  this._unmonitorIntersections();\n\n\n  this._unregisterInstance();\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns any queue entries that have not yet been reported to the\n\n\n * callback and clears the queue. This can be used in conjunction with the\n\n\n * callback to obtain the absolute most up-to-date intersection information.\n\n\n * @return {Array} The currently queued entries.\n\n\n */\n\n\nIntersectionObserver.prototype.takeRecords = function() {\n\n\n  var records = this._queuedEntries.slice();\n\n\n  this._queuedEntries = [];\n\n\n  return records;\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Accepts the threshold value from the user configuration object and\n\n\n * returns a sorted array of unique threshold values. If a value is not\n\n\n * between 0 and 1 and error is thrown.\n\n\n * @private\n\n\n * @param {Array|number=} opt_threshold An optional threshold value or\n\n\n *     a list of threshold values, defaulting to [0].\n\n\n * @return {Array} A sorted list of unique and valid threshold values.\n\n\n */\n\n\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n\n\n  var threshold = opt_threshold || [0];\n\n\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n\n\n\n\n  return threshold.sort().filter(function(t, i, a) {\n\n\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n\n\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n\n\n    }\n\n\n    return t !== a[i - 1];\n\n\n  });\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Accepts the rootMargin value from the user configuration object\n\n\n * and returns an array of the four margin values as an object containing\n\n\n * the value and unit properties. If any of the values are not properly\n\n\n * formatted or use a unit other than px or %, and error is thrown.\n\n\n * @private\n\n\n * @param {string=} opt_rootMargin An optional rootMargin value,\n\n\n *     defaulting to '0px'.\n\n\n * @return {Array<Object>} An array of margin objects with the keys\n\n\n *     value and unit.\n\n\n */\n\n\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n\n\n  var marginString = opt_rootMargin || '0px';\n\n\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n\n\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n\n\n    if (!parts) {\n\n\n      throw new Error('rootMargin must be specified in pixels or percent');\n\n\n    }\n\n\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n\n\n  });\n\n\n\n\n\n  // Handles shorthand.\n\n\n  margins[1] = margins[1] || margins[0];\n\n\n  margins[2] = margins[2] || margins[0];\n\n\n  margins[3] = margins[3] || margins[1];\n\n\n\n\n\n  return margins;\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Starts polling for intersection changes if the polling is not already\n\n\n * happening, and if the page's visibility state is visible.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._monitorIntersections = function() {\n\n\n  if (!this._monitoringIntersections) {\n\n\n    this._monitoringIntersections = true;\n\n\n\n\n\n    // If a poll interval is set, use polling instead of listening to\n\n\n    // resize and scroll events or DOM mutations.\n\n\n    if (this.POLL_INTERVAL) {\n\n\n      this._monitoringInterval = setInterval(\n\n\n          this._checkForIntersections, this.POLL_INTERVAL);\n\n\n    }\n\n\n    else {\n\n\n      addEvent(window, 'resize', this._checkForIntersections, true);\n\n\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n\n\n\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n\n\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n\n\n        this._domObserver.observe(document, {\n\n\n          attributes: true,\n\n\n          childList: true,\n\n\n          characterData: true,\n\n\n          subtree: true\n\n\n        });\n\n\n      }\n\n\n    }\n\n\n  }\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Stops polling for intersection changes.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n\n\n  if (this._monitoringIntersections) {\n\n\n    this._monitoringIntersections = false;\n\n\n\n\n\n    clearInterval(this._monitoringInterval);\n\n\n    this._monitoringInterval = null;\n\n\n\n\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n\n\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n\n\n\n\n    if (this._domObserver) {\n\n\n      this._domObserver.disconnect();\n\n\n      this._domObserver = null;\n\n\n    }\n\n\n  }\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Scans each observation target for intersection changes and adds them\n\n\n * to the internal entries queue. If new entries are found, it\n\n\n * schedules the callback to be invoked.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._checkForIntersections = function() {\n\n\n  var rootIsInDom = this._rootIsInDom();\n\n\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n\n\n\n\n  this._observationTargets.forEach(function(item) {\n\n\n    var target = item.element;\n\n\n    var targetRect = getBoundingClientRect(target);\n\n\n    var rootContainsTarget = this._rootContainsTarget(target);\n\n\n    var oldEntry = item.entry;\n\n\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n\n\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n\n\n\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n\n\n      time: now(),\n\n\n      target: target,\n\n\n      boundingClientRect: targetRect,\n\n\n      rootBounds: rootRect,\n\n\n      intersectionRect: intersectionRect\n\n\n    });\n\n\n\n\n\n    if (!oldEntry) {\n\n\n      this._queuedEntries.push(newEntry);\n\n\n    } else if (rootIsInDom && rootContainsTarget) {\n\n\n      // If the new entry intersection ratio has crossed any of the\n\n\n      // thresholds, add a new entry.\n\n\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n\n\n        this._queuedEntries.push(newEntry);\n\n\n      }\n\n\n    } else {\n\n\n      // If the root is not in the DOM or target is not contained within\n\n\n      // root but the previous entry for this target had an intersection,\n\n\n      // add a new record indicating removal.\n\n\n      if (oldEntry && oldEntry.isIntersecting) {\n\n\n        this._queuedEntries.push(newEntry);\n\n\n      }\n\n\n    }\n\n\n  }, this);\n\n\n\n\n\n  if (this._queuedEntries.length) {\n\n\n    this._callback(this.takeRecords(), this);\n\n\n  }\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Accepts a target and root rect computes the intersection between then\n\n\n * following the algorithm in the spec.\n\n\n * TODO(philipwalton): at this time clip-path is not considered.\n\n\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n\n\n * @param {Element} target The target DOM element\n\n\n * @param {Object} rootRect The bounding rect of the root after being\n\n\n *     expanded by the rootMargin value.\n\n\n * @return {?Object} The final intersection rect object or undefined if no\n\n\n *     intersection is found.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n\n\n    function(target, rootRect) {\n\n\n\n\n\n  // If the element isn't displayed, an intersection can't happen.\n\n\n  if (window.getComputedStyle(target).display == 'none') return;\n\n\n\n\n\n  var targetRect = getBoundingClientRect(target);\n\n\n  var intersectionRect = targetRect;\n\n\n  var parent = getParentNode(target);\n\n\n  var atRoot = false;\n\n\n\n\n\n  while (!atRoot) {\n\n\n    var parentRect = null;\n\n\n    var parentComputedStyle = parent.nodeType == 1 ?\n\n\n        window.getComputedStyle(parent) : {};\n\n\n\n\n\n    // If the parent isn't displayed, an intersection can't happen.\n\n\n    if (parentComputedStyle.display == 'none') return;\n\n\n\n\n\n    if (parent == this.root || parent == document) {\n\n\n      atRoot = true;\n\n\n      parentRect = rootRect;\n\n\n    } else {\n\n\n      // If the element has a non-visible overflow, and it's not the <body>\n\n\n      // or <html> element, update the intersection rect.\n\n\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n\n\n      // the document rect, so no need to compute a new intersection.\n\n\n      if (parent != document.body &&\n\n\n          parent != document.documentElement &&\n\n\n          parentComputedStyle.overflow != 'visible') {\n\n\n        parentRect = getBoundingClientRect(parent);\n\n\n      }\n\n\n    }\n\n\n\n\n\n    // If either of the above conditionals set a new parentRect,\n\n\n    // calculate new intersection data.\n\n\n    if (parentRect) {\n\n\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n\n\n\n\n      if (!intersectionRect) break;\n\n\n    }\n\n\n    parent = getParentNode(parent);\n\n\n  }\n\n\n  return intersectionRect;\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns the root rect after being expanded by the rootMargin value.\n\n\n * @return {Object} The expanded root rect.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._getRootRect = function() {\n\n\n  var rootRect;\n\n\n  if (this.root) {\n\n\n    rootRect = getBoundingClientRect(this.root);\n\n\n  } else {\n\n\n    // Use <html>/<body> instead of window since scroll bars affect size.\n\n\n    var html = document.documentElement;\n\n\n    var body = document.body;\n\n\n    rootRect = {\n\n\n      top: 0,\n\n\n      left: 0,\n\n\n      right: html.clientWidth || body.clientWidth,\n\n\n      width: html.clientWidth || body.clientWidth,\n\n\n      bottom: html.clientHeight || body.clientHeight,\n\n\n      height: html.clientHeight || body.clientHeight\n\n\n    };\n\n\n  }\n\n\n  return this._expandRectByRootMargin(rootRect);\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Accepts a rect and expands it by the rootMargin value.\n\n\n * @param {Object} rect The rect object to expand.\n\n\n * @return {Object} The expanded rect.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n\n\n  var margins = this._rootMarginValues.map(function(margin, i) {\n\n\n    return margin.unit == 'px' ? margin.value :\n\n\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n\n\n  });\n\n\n  var newRect = {\n\n\n    top: rect.top - margins[0],\n\n\n    right: rect.right + margins[1],\n\n\n    bottom: rect.bottom + margins[2],\n\n\n    left: rect.left - margins[3]\n\n\n  };\n\n\n  newRect.width = newRect.right - newRect.left;\n\n\n  newRect.height = newRect.bottom - newRect.top;\n\n\n\n\n\n  return newRect;\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Accepts an old and new entry and returns true if at least one of the\n\n\n * threshold values has been crossed.\n\n\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n\n\n *    particular target element or null if no previous entry exists.\n\n\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n\n\n *    particular target element.\n\n\n * @return {boolean} Returns true if a any threshold has been crossed.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._hasCrossedThreshold =\n\n\n    function(oldEntry, newEntry) {\n\n\n\n\n\n  // To make comparing easier, an entry that has a ratio of 0\n\n\n  // but does not actually intersect is given a value of -1\n\n\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n\n\n      oldEntry.intersectionRatio || 0 : -1;\n\n\n  var newRatio = newEntry.isIntersecting ?\n\n\n      newEntry.intersectionRatio || 0 : -1;\n\n\n\n\n\n  // Ignore unchanged ratios\n\n\n  if (oldRatio === newRatio) return;\n\n\n\n\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n\n\n    var threshold = this.thresholds[i];\n\n\n\n\n\n    // Return true if an entry matches a threshold or if the new ratio\n\n\n    // and the old ratio are on the opposite sides of a threshold.\n\n\n    if (threshold == oldRatio || threshold == newRatio ||\n\n\n        threshold < oldRatio !== threshold < newRatio) {\n\n\n      return true;\n\n\n    }\n\n\n  }\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns whether or not the root element is an element and is in the DOM.\n\n\n * @return {boolean} True if the root element is an element and is in the DOM.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._rootIsInDom = function() {\n\n\n  return !this.root || containsDeep(document, this.root);\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns whether or not the target element is a child of root.\n\n\n * @param {Element} target The target element to check.\n\n\n * @return {boolean} True if the target element is a child of root.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n\n\n  return containsDeep(this.root || document, target);\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Adds the instance to the global IntersectionObserver registry if it isn't\n\n\n * already present.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._registerInstance = function() {\n\n\n  if (registry.indexOf(this) < 0) {\n\n\n    registry.push(this);\n\n\n  }\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Removes the instance from the global IntersectionObserver registry.\n\n\n * @private\n\n\n */\n\n\nIntersectionObserver.prototype._unregisterInstance = function() {\n\n\n  var index = registry.indexOf(this);\n\n\n  if (index != -1) registry.splice(index, 1);\n\n\n};\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns the result of the performance.now() method or null in browsers\n\n\n * that don't support the API.\n\n\n * @return {number} The elapsed time since the page was requested.\n\n\n */\n\n\nfunction now() {\n\n\n  return window.performance && performance.now && performance.now();\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Throttles a function and delays its execution, so it's only called at most\n\n\n * once within a given time period.\n\n\n * @param {Function} fn The function to throttle.\n\n\n * @param {number} timeout The amount of time that must pass before the\n\n\n *     function can be called again.\n\n\n * @return {Function} The throttled function.\n\n\n */\n\n\nfunction throttle(fn, timeout) {\n\n\n  var timer = null;\n\n\n  return function () {\n\n\n    if (!timer) {\n\n\n      timer = setTimeout(function() {\n\n\n        fn();\n\n\n        timer = null;\n\n\n      }, timeout);\n\n\n    }\n\n\n  };\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n\n\n * @param {Node} node The DOM node to add the event handler to.\n\n\n * @param {string} event The event name.\n\n\n * @param {Function} fn The event handler to add.\n\n\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n\n\n *     phase. Note: this only works in modern browsers.\n\n\n */\n\n\nfunction addEvent(node, event, fn, opt_useCapture) {\n\n\n  if (typeof node.addEventListener == 'function') {\n\n\n    node.addEventListener(event, fn, opt_useCapture || false);\n\n\n  }\n\n\n  else if (typeof node.attachEvent == 'function') {\n\n\n    node.attachEvent('on' + event, fn);\n\n\n  }\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Removes a previously added event handler from a DOM node.\n\n\n * @param {Node} node The DOM node to remove the event handler from.\n\n\n * @param {string} event The event name.\n\n\n * @param {Function} fn The event handler to remove.\n\n\n * @param {boolean} opt_useCapture If the event handler was added with this\n\n\n *     flag set to true, it should be set to true here in order to remove it.\n\n\n */\n\n\nfunction removeEvent(node, event, fn, opt_useCapture) {\n\n\n  if (typeof node.removeEventListener == 'function') {\n\n\n    node.removeEventListener(event, fn, opt_useCapture || false);\n\n\n  }\n\n\n  else if (typeof node.detatchEvent == 'function') {\n\n\n    node.detatchEvent('on' + event, fn);\n\n\n  }\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns the intersection between two rect objects.\n\n\n * @param {Object} rect1 The first rect.\n\n\n * @param {Object} rect2 The second rect.\n\n\n * @return {?Object} The intersection rect or undefined if no intersection\n\n\n *     is found.\n\n\n */\n\n\nfunction computeRectIntersection(rect1, rect2) {\n\n\n  var top = Math.max(rect1.top, rect2.top);\n\n\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n\n\n  var left = Math.max(rect1.left, rect2.left);\n\n\n  var right = Math.min(rect1.right, rect2.right);\n\n\n  var width = right - left;\n\n\n  var height = bottom - top;\n\n\n\n\n\n  return (width >= 0 && height >= 0) && {\n\n\n    top: top,\n\n\n    bottom: bottom,\n\n\n    left: left,\n\n\n    right: right,\n\n\n    width: width,\n\n\n    height: height\n\n\n  };\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Shims the native getBoundingClientRect for compatibility with older IE.\n\n\n * @param {Element} el The element whose bounding rect to get.\n\n\n * @return {Object} The (possibly shimmed) rect of the element.\n\n\n */\n\n\nfunction getBoundingClientRect(el) {\n\n\n  var rect;\n\n\n\n\n\n  try {\n\n\n    rect = el.getBoundingClientRect();\n\n\n  } catch (err) {\n\n\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n\n\n    // https://github.com/w3c/IntersectionObserver/pull/205\n\n\n  }\n\n\n\n\n\n  if (!rect) return getEmptyRect();\n\n\n\n\n\n  // Older IE\n\n\n  if (!(rect.width && rect.height)) {\n\n\n    rect = {\n\n\n      top: rect.top,\n\n\n      right: rect.right,\n\n\n      bottom: rect.bottom,\n\n\n      left: rect.left,\n\n\n      width: rect.right - rect.left,\n\n\n      height: rect.bottom - rect.top\n\n\n    };\n\n\n  }\n\n\n  return rect;\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Returns an empty rect object. An empty rect is returned when an element\n\n\n * is not in the DOM.\n\n\n * @return {Object} The empty rect.\n\n\n */\n\n\nfunction getEmptyRect() {\n\n\n  return {\n\n\n    top: 0,\n\n\n    bottom: 0,\n\n\n    left: 0,\n\n\n    right: 0,\n\n\n    width: 0,\n\n\n    height: 0\n\n\n  };\n\n\n}\n\n\n\n\n\n/**\n\n\n * Checks to see if a parent element contains a child element (including inside\n\n\n * shadow DOM).\n\n\n * @param {Node} parent The parent element.\n\n\n * @param {Node} child The child element.\n\n\n * @return {boolean} True if the parent node contains the child node.\n\n\n */\n\n\nfunction containsDeep(parent, child) {\n\n\n  var node = child;\n\n\n  while (node) {\n\n\n    if (node == parent) return true;\n\n\n\n\n\n    node = getParentNode(node);\n\n\n  }\n\n\n  return false;\n\n\n}\n\n\n\n\n\n\n\n\n/**\n\n\n * Gets the parent node of an element or its host element if the parent node\n\n\n * is a shadow root.\n\n\n * @param {Node} node The node whose parent to get.\n\n\n * @return {Node|null} The parent node or null if no parent exists.\n\n\n */\n\n\nfunction getParentNode(node) {\n\n\n  var parent = node.parentNode;\n\n\n\n\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n\n\n    // If the parent is a shadow root, return the host element.\n\n\n    return parent.host;\n\n\n  }\n\n\n  return parent;\n\n\n}\n\n\n\n\n\n\n\n\n// Exposes the constructors globally.\n\n\nwindow.IntersectionObserver = IntersectionObserver;\n\n\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n\n\n\n\n}(window, document));\n\n\n\n\n(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define(factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory(require, exports, module);\n  } else {\n    root.CountUp = factory();\n  }\n}(this, function(require, exports, module) {\n\n/*\n\n\tcountUp.js\n\tby @inorganik\n\n*/\n\n// target = id of html element or var of previously selected html element where counting occurs\n// startVal = the value you want to begin at\n// endVal = the value you want to arrive at\n// decimals = number of decimal places, default 0\n// duration = duration of animation in seconds, default 2\n// options = optional object of options (see below)\n\nvar CountUp = function(target, startVal, endVal, decimals, duration, options) {\n\n\tvar self = this;\n\tself.version = function () { return '1.9.3'; };\n\t\n\t// default options\n\tself.options = {\n\t\tuseEasing: true, // toggle easing\n\t\tuseGrouping: true, // 1,000,000 vs 1000000\n\t\tseparator: ',', // character to use as a separator\n\t\tdecimal: '.', // character to use as a decimal\n\t\teasingFn: easeOutExpo, // optional custom easing function, default is Robert Penner's easeOutExpo\n\t\tformattingFn: formatNumber, // optional custom formatting function, default is formatNumber above\n\t\tprefix: '', // optional text before the result\n\t\tsuffix: '', // optional text after the result\n\t\tnumerals: [] // optionally pass an array of custom numerals for 0-9\n\t};\n\n\t// extend default options with passed options object\n\tif (options && typeof options === 'object') {\n\t\tfor (var key in self.options) {\n\t\t\tif (options.hasOwnProperty(key) && options[key] !== null) {\n\t\t\t\tself.options[key] = options[key];\n\t\t\t}\n\t\t}\n\t}\n\n\tif (self.options.separator === '') {\n\t\tself.options.useGrouping = false;\n\t}\n\telse {\n\t\t// ensure the separator is a string (formatNumber assumes this)\n\t\tself.options.separator = '' + self.options.separator;\n\t}\n\n\t// make sure requestAnimationFrame and cancelAnimationFrame are defined\n\t// polyfill for browsers without native support\n\t// by Opera engineer Erik Möller\n\tvar lastTime = 0;\n\tvar vendors = ['webkit', 'moz', 'ms', 'o'];\n\tfor(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {\n\t\twindow.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];\n\t\twindow.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame'] || window[vendors[x]+'CancelRequestAnimationFrame'];\n\t}\n\tif (!window.requestAnimationFrame) {\n\t\twindow.requestAnimationFrame = function(callback, element) {\n\t\t\tvar currTime = new Date().getTime();\n\t\t\tvar timeToCall = Math.max(0, 16 - (currTime - lastTime));\n\t\t\tvar id = window.setTimeout(function() { callback(currTime + timeToCall); }, timeToCall);\n\t\t\tlastTime = currTime + timeToCall;\n\t\t\treturn id;\n\t\t};\n\t}\n\tif (!window.cancelAnimationFrame) {\n\t\twindow.cancelAnimationFrame = function(id) {\n\t\t\tclearTimeout(id);\n\t\t};\n\t}\n\n\tfunction formatNumber(num) {\n\t\tvar neg = (num < 0),\n        \tx, x1, x2, x3, i, len;\n\t\tnum = Math.abs(num).toFixed(self.decimals);\n\t\tnum += '';\n\t\tx = num.split('.');\n\t\tx1 = x[0];\n\t\tx2 = x.length > 1 ? self.options.decimal + x[1] : '';\n\t\tif (self.options.useGrouping) {\n\t\t\tx3 = '';\n\t\t\tfor (i = 0, len = x1.length; i < len; ++i) {\n\t\t\t\tif (i !== 0 && ((i % 3) === 0)) {\n\t\t\t\t\tx3 = self.options.separator + x3;\n\t\t\t\t}\n\t\t\t\tx3 = x1[len - i - 1] + x3;\n\t\t\t}\n\t\t\tx1 = x3;\n\t\t}\n\t\t// optional numeral substitution\n\t\tif (self.options.numerals.length) {\n\t\t\tx1 = x1.replace(/[0-9]/g, function(w) {\n\t\t\t\treturn self.options.numerals[+w];\n\t\t\t})\n\t\t\tx2 = x2.replace(/[0-9]/g, function(w) {\n\t\t\t\treturn self.options.numerals[+w];\n\t\t\t})\n\t\t}\n\t\treturn (neg ? '-' : '') + self.options.prefix + x1 + x2 + self.options.suffix;\n\t}\n\t// Robert Penner's easeOutExpo\n\tfunction easeOutExpo(t, b, c, d) {\n\t\treturn c * (-Math.pow(2, -10 * t / d) + 1) * 1024 / 1023 + b;\n\t}\n\tfunction ensureNumber(n) {\n\t\treturn (typeof n === 'number' && !isNaN(n));\n\t}\n\n\tself.initialize = function() { \n\t\tif (self.initialized) return true;\n\t\t\n\t\tself.error = '';\n\t\tself.d = (typeof target === 'string') ? document.getElementById(target) : target;\n\t\tif (!self.d) { \n\t\t\tself.error = '[CountUp] target is null or undefined'\n\t\t\treturn false;\n\t\t}\n\t\tself.startVal = Number(startVal);\n\t\tself.endVal = Number(endVal);\n\t\t// error checks\n\t\tif (ensureNumber(self.startVal) && ensureNumber(self.endVal)) {\n\t\t\tself.decimals = Math.max(0, decimals || 0);\n\t\t\tself.dec = Math.pow(10, self.decimals);\n\t\t\tself.duration = Number(duration) * 1000 || 2000;\n\t\t\tself.countDown = (self.startVal > self.endVal);\n\t\t\tself.frameVal = self.startVal;\n\t\t\tself.initialized = true;\n\t\t\treturn true;\n\t\t}\n\t\telse {\n\t\t\tself.error = '[CountUp] startVal ('+startVal+') or endVal ('+endVal+') is not a number';\n\t\t\treturn false;\n\t\t}\n\t};\n\n\t// Print value to target\n\tself.printValue = function(value) {\n\t\tvar result = self.options.formattingFn(value);\n\n\t\tif (self.d.tagName === 'INPUT') {\n\t\t\tthis.d.value = result;\n\t\t}\n\t\telse if (self.d.tagName === 'text' || self.d.tagName === 'tspan') {\n\t\t\tthis.d.textContent = result;\n\t\t}\n\t\telse {\n\t\t\tthis.d.innerHTML = result;\n\t\t}\n\t};\n\n\tself.count = function(timestamp) {\n\n\t\tif (!self.startTime) { self.startTime = timestamp; }\n\n\t\tself.timestamp = timestamp;\n\t\tvar progress = timestamp - self.startTime;\n\t\tself.remaining = self.duration - progress;\n\n\t\t// to ease or not to ease\n\t\tif (self.options.useEasing) {\n\t\t\tif (self.countDown) {\n\t\t\t\tself.frameVal = self.startVal - self.options.easingFn(progress, 0, self.startVal - self.endVal, self.duration);\n\t\t\t} else {\n\t\t\t\tself.frameVal = self.options.easingFn(progress, self.startVal, self.endVal - self.startVal, self.duration);\n\t\t\t}\n\t\t} else {\n\t\t\tif (self.countDown) {\n\t\t\t\tself.frameVal = self.startVal - ((self.startVal - self.endVal) * (progress / self.duration));\n\t\t\t} else {\n\t\t\t\tself.frameVal = self.startVal + (self.endVal - self.startVal) * (progress / self.duration);\n\t\t\t}\n\t\t}\n\n\t\t// don't go past endVal since progress can exceed duration in the last frame\n\t\tif (self.countDown) {\n\t\t\tself.frameVal = (self.frameVal < self.endVal) ? self.endVal : self.frameVal;\n\t\t} else {\n\t\t\tself.frameVal = (self.frameVal > self.endVal) ? self.endVal : self.frameVal;\n\t\t}\n\n\t\t// decimal\n\t\tself.frameVal = Math.round(self.frameVal*self.dec)/self.dec;\n\n\t\t// format and print value\n\t\tself.printValue(self.frameVal);\n\n\t\t// whether to continue\n\t\tif (progress < self.duration) {\n\t\t\tself.rAF = requestAnimationFrame(self.count);\n\t\t} else {\n\t\t\tif (self.callback) self.callback();\n\t\t}\n\t};\n\t// start your animation\n\tself.start = function(callback) {\n\t\tif (!self.initialize()) return;\n\t\tself.callback = callback;\n\t\tself.rAF = requestAnimationFrame(self.count);\n\t};\n\t// toggles pause/resume animation\n\tself.pauseResume = function() {\n\t\tif (!self.paused) {\n\t\t\tself.paused = true;\n\t\t\tcancelAnimationFrame(self.rAF);\n\t\t} else {\n\t\t\tself.paused = false;\n\t\t\tdelete self.startTime;\n\t\t\tself.duration = self.remaining;\n\t\t\tself.startVal = self.frameVal;\n\t\t\trequestAnimationFrame(self.count);\n\t\t}\n\t};\n\t// reset to startVal so animation can be run again\n\tself.reset = function() {\n\t\tself.paused = false;\n\t\tdelete self.startTime;\n\t\tself.initialized = false;\n\t\tif (self.initialize()) {\n\t\t\tcancelAnimationFrame(self.rAF);\n\t\t\tself.printValue(self.startVal);\n\t\t}\n\t};\n\t// pass a new endVal and start animation\n\tself.update = function (newEndVal) {\n\t\tif (!self.initialize()) return;\n\t\tnewEndVal = Number(newEndVal);\n\t\tif (!ensureNumber(newEndVal)) {\n\t\t\tself.error = '[CountUp] update() - new endVal is not a number: '+newEndVal;\n\t\t\treturn;\n\t\t}\n\t\tself.error = '';\n\t\tif (newEndVal === self.frameVal) return;\n\t\tcancelAnimationFrame(self.rAF);\n\t\tself.paused = false;\n\t\tdelete self.startTime;\n\t\tself.startVal = self.frameVal;\n\t\tself.endVal = newEndVal;\n\t\tself.countDown = (self.startVal > self.endVal);\n\t\tself.rAF = requestAnimationFrame(self.count);\n\t};\n\n\t// format startVal on initialization\n\tif (self.initialize()) self.printValue(self.startVal);\n};\n\nreturn CountUp;\n\n}));\n\n","\n(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define(factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory(require, exports, module);\n  } else {\n    root.CountUp = factory();\n  }\n}(this, function(require, exports, module) {\n\n/*\n\n\tcountUp.js\n\tby @inorganik\n\n*/\n\n// target = id of html element or var of previously selected html element where counting occurs\n// startVal = the value you want to begin at\n// endVal = the value you want to arrive at\n// decimals = number of decimal places, default 0\n// duration = duration of animation in seconds, default 2\n// options = optional object of options (see below)\n\nvar CountUp = function(target, startVal, endVal, decimals, duration, options) {\n\n\tvar self = this;\n\tself.version = function () { return '1.9.3'; };\n\t\n\t// default options\n\tself.options = {\n\t\tuseEasing: true, // toggle easing\n\t\tuseGrouping: true, // 1,000,000 vs 1000000\n\t\tseparator: ',', // character to use as a separator\n\t\tdecimal: '.', // character to use as a decimal\n\t\teasingFn: easeOutExpo, // optional custom easing function, default is Robert Penner's easeOutExpo\n\t\tformattingFn: formatNumber, // optional custom formatting function, default is formatNumber above\n\t\tprefix: '', // optional text before the result\n\t\tsuffix: '', // optional text after the result\n\t\tnumerals: [] // optionally pass an array of custom numerals for 0-9\n\t};\n\n\t// extend default options with passed options object\n\tif (options && typeof options === 'object') {\n\t\tfor (var key in self.options) {\n\t\t\tif (options.hasOwnProperty(key) && options[key] !== null) {\n\t\t\t\tself.options[key] = options[key];\n\t\t\t}\n\t\t}\n\t}\n\n\tif (self.options.separator === '') {\n\t\tself.options.useGrouping = false;\n\t}\n\telse {\n\t\t// ensure the separator is a string (formatNumber assumes this)\n\t\tself.options.separator = '' + self.options.separator;\n\t}\n\n\t// make sure requestAnimationFrame and cancelAnimationFrame are defined\n\t// polyfill for browsers without native support\n\t// by Opera engineer Erik Möller\n\tvar lastTime = 0;\n\tvar vendors = ['webkit', 'moz', 'ms', 'o'];\n\tfor(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {\n\t\twindow.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];\n\t\twindow.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame'] || window[vendors[x]+'CancelRequestAnimationFrame'];\n\t}\n\tif (!window.requestAnimationFrame) {\n\t\twindow.requestAnimationFrame = function(callback, element) {\n\t\t\tvar currTime = new Date().getTime();\n\t\t\tvar timeToCall = Math.max(0, 16 - (currTime - lastTime));\n\t\t\tvar id = window.setTimeout(function() { callback(currTime + timeToCall); }, timeToCall);\n\t\t\tlastTime = currTime + timeToCall;\n\t\t\treturn id;\n\t\t};\n\t}\n\tif (!window.cancelAnimationFrame) {\n\t\twindow.cancelAnimationFrame = function(id) {\n\t\t\tclearTimeout(id);\n\t\t};\n\t}\n\n\tfunction formatNumber(num) {\n\t\tvar neg = (num < 0),\n        \tx, x1, x2, x3, i, len;\n\t\tnum = Math.abs(num).toFixed(self.decimals);\n\t\tnum += '';\n\t\tx = num.split('.');\n\t\tx1 = x[0];\n\t\tx2 = x.length > 1 ? self.options.decimal + x[1] : '';\n\t\tif (self.options.useGrouping) {\n\t\t\tx3 = '';\n\t\t\tfor (i = 0, len = x1.length; i < len; ++i) {\n\t\t\t\tif (i !== 0 && ((i % 3) === 0)) {\n\t\t\t\t\tx3 = self.options.separator + x3;\n\t\t\t\t}\n\t\t\t\tx3 = x1[len - i - 1] + x3;\n\t\t\t}\n\t\t\tx1 = x3;\n\t\t}\n\t\t// optional numeral substitution\n\t\tif (self.options.numerals.length) {\n\t\t\tx1 = x1.replace(/[0-9]/g, function(w) {\n\t\t\t\treturn self.options.numerals[+w];\n\t\t\t})\n\t\t\tx2 = x2.replace(/[0-9]/g, function(w) {\n\t\t\t\treturn self.options.numerals[+w];\n\t\t\t})\n\t\t}\n\t\treturn (neg ? '-' : '') + self.options.prefix + x1 + x2 + self.options.suffix;\n\t}\n\t// Robert Penner's easeOutExpo\n\tfunction easeOutExpo(t, b, c, d) {\n\t\treturn c * (-Math.pow(2, -10 * t / d) + 1) * 1024 / 1023 + b;\n\t}\n\tfunction ensureNumber(n) {\n\t\treturn (typeof n === 'number' && !isNaN(n));\n\t}\n\n\tself.initialize = function() { \n\t\tif (self.initialized) return true;\n\t\t\n\t\tself.error = '';\n\t\tself.d = (typeof target === 'string') ? document.getElementById(target) : target;\n\t\tif (!self.d) { \n\t\t\tself.error = '[CountUp] target is null or undefined'\n\t\t\treturn false;\n\t\t}\n\t\tself.startVal = Number(startVal);\n\t\tself.endVal = Number(endVal);\n\t\t// error checks\n\t\tif (ensureNumber(self.startVal) && ensureNumber(self.endVal)) {\n\t\t\tself.decimals = Math.max(0, decimals || 0);\n\t\t\tself.dec = Math.pow(10, self.decimals);\n\t\t\tself.duration = Number(duration) * 1000 || 2000;\n\t\t\tself.countDown = (self.startVal > self.endVal);\n\t\t\tself.frameVal = self.startVal;\n\t\t\tself.initialized = true;\n\t\t\treturn true;\n\t\t}\n\t\telse {\n\t\t\tself.error = '[CountUp] startVal ('+startVal+') or endVal ('+endVal+') is not a number';\n\t\t\treturn false;\n\t\t}\n\t};\n\n\t// Print value to target\n\tself.printValue = function(value) {\n\t\tvar result = self.options.formattingFn(value);\n\n\t\tif (self.d.tagName === 'INPUT') {\n\t\t\tthis.d.value = result;\n\t\t}\n\t\telse if (self.d.tagName === 'text' || self.d.tagName === 'tspan') {\n\t\t\tthis.d.textContent = result;\n\t\t}\n\t\telse {\n\t\t\tthis.d.innerHTML = result;\n\t\t}\n\t};\n\n\tself.count = function(timestamp) {\n\n\t\tif (!self.startTime) { self.startTime = timestamp; }\n\n\t\tself.timestamp = timestamp;\n\t\tvar progress = timestamp - self.startTime;\n\t\tself.remaining = self.duration - progress;\n\n\t\t// to ease or not to ease\n\t\tif (self.options.useEasing) {\n\t\t\tif (self.countDown) {\n\t\t\t\tself.frameVal = self.startVal - self.options.easingFn(progress, 0, self.startVal - self.endVal, self.duration);\n\t\t\t} else {\n\t\t\t\tself.frameVal = self.options.easingFn(progress, self.startVal, self.endVal - self.startVal, self.duration);\n\t\t\t}\n\t\t} else {\n\t\t\tif (self.countDown) {\n\t\t\t\tself.frameVal = self.startVal - ((self.startVal - self.endVal) * (progress / self.duration));\n\t\t\t} else {\n\t\t\t\tself.frameVal = self.startVal + (self.endVal - self.startVal) * (progress / self.duration);\n\t\t\t}\n\t\t}\n\n\t\t// don't go past endVal since progress can exceed duration in the last frame\n\t\tif (self.countDown) {\n\t\t\tself.frameVal = (self.frameVal < self.endVal) ? self.endVal : self.frameVal;\n\t\t} else {\n\t\t\tself.frameVal = (self.frameVal > self.endVal) ? self.endVal : self.frameVal;\n\t\t}\n\n\t\t// decimal\n\t\tself.frameVal = Math.round(self.frameVal*self.dec)/self.dec;\n\n\t\t// format and print value\n\t\tself.printValue(self.frameVal);\n\n\t\t// whether to continue\n\t\tif (progress < self.duration) {\n\t\t\tself.rAF = requestAnimationFrame(self.count);\n\t\t} else {\n\t\t\tif (self.callback) self.callback();\n\t\t}\n\t};\n\t// start your animation\n\tself.start = function(callback) {\n\t\tif (!self.initialize()) return;\n\t\tself.callback = callback;\n\t\tself.rAF = requestAnimationFrame(self.count);\n\t};\n\t// toggles pause/resume animation\n\tself.pauseResume = function() {\n\t\tif (!self.paused) {\n\t\t\tself.paused = true;\n\t\t\tcancelAnimationFrame(self.rAF);\n\t\t} else {\n\t\t\tself.paused = false;\n\t\t\tdelete self.startTime;\n\t\t\tself.duration = self.remaining;\n\t\t\tself.startVal = self.frameVal;\n\t\t\trequestAnimationFrame(self.count);\n\t\t}\n\t};\n\t// reset to startVal so animation can be run again\n\tself.reset = function() {\n\t\tself.paused = false;\n\t\tdelete self.startTime;\n\t\tself.initialized = false;\n\t\tif (self.initialize()) {\n\t\t\tcancelAnimationFrame(self.rAF);\n\t\t\tself.printValue(self.startVal);\n\t\t}\n\t};\n\t// pass a new endVal and start animation\n\tself.update = function (newEndVal) {\n\t\tif (!self.initialize()) return;\n\t\tnewEndVal = Number(newEndVal);\n\t\tif (!ensureNumber(newEndVal)) {\n\t\t\tself.error = '[CountUp] update() - new endVal is not a number: '+newEndVal;\n\t\t\treturn;\n\t\t}\n\t\tself.error = '';\n\t\tif (newEndVal === self.frameVal) return;\n\t\tcancelAnimationFrame(self.rAF);\n\t\tself.paused = false;\n\t\tdelete self.startTime;\n\t\tself.startVal = self.frameVal;\n\t\tself.endVal = newEndVal;\n\t\tself.countDown = (self.startVal > self.endVal);\n\t\tself.rAF = requestAnimationFrame(self.count);\n\t};\n\n\t// format startVal on initialization\n\tif (self.initialize()) self.printValue(self.startVal);\n};\n\nreturn CountUp;\n\n}));\n"]}