{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./assets/js/modernizr.js","webpack:///./.modernizrrc"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","window","hadGlobal","oldGlobal","Modernizr","document","undefined","tests","ModernizrProto","_version","_config","_q","on","test","cb","self","this","setTimeout","addTest","fn","options","push","addAsyncTest","classes","is","obj","type","docElement","documentElement","isSVG","nodeName","toLowerCase","setClasses","className","classPrefix","baseVal","enableJSClass","reJS","RegExp","replace","enableClasses","length","join","createElement","arguments","createElementNS","apply","prefixes","usePrefixes","split","_prefixes","el","style","cssText","cssomPrefixes","_cssomPrefixes","modElem","elem","mStyle","injectElementWithStyles","rule","callback","nodes","testnames","ret","node","docOverflow","mod","div","body","fake","getBody","parseInt","id","appendChild","styleSheet","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","domToCSS","str","m1","computedStyle","pseudo","prop","result","getComputedStyle","console","getPropertyValue","error","currentStyle","testProps","props","prefixed","skipValueTest","CSS","supports","conditionText","nativeTestProps","afterInit","propsLength","before","elems","shift","cleanElems","indexOf","m2","toUpperCase","e","unshift","domPrefixes","fnBind","that","testPropsAll","ucProp","charAt","slice","item","testDOMProps","testAllProps","_domPrefixes","testStyles","hasOwnProp","_hasOwnProperty","newSyntax","oldSyntax","roundedEquals","a","b","feature","featureNameSplit","last","Boolean","_trigger","height","innerHeight","compStyle","childNodes","scroller","fullSizeElem","scrollbarWidth","offsetWidth","clientWidth","one_vw","one_vh","clientHeight","expectedWidth","Math","max","compWidth","min","width","innerWidth","constructor","_l","res","cbs","implementation","hasFeature","innerHTML","SVGRect","firstChild","namespaceURI","featureNames","aliasIdx","nameIdx","featureIdx","aliases","testRunner"],"mappings":"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","file":"/js/modernizr.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1);\n","import Modernizr from 'modernizr';\n\n",";(function(window){\nvar hadGlobal = 'Modernizr' in window;\nvar oldGlobal = window.Modernizr;\n/*!\n * modernizr v3.7.1\n * Build https://modernizr.com/download?-csscalc-csstransforms3d-cssvhunit-cssvmaxunit-cssvminunit-cssvwunit-flexbox-hairline-inlinesvg-svgasimg-setclasses-dontmin-cssclassprefix:supports-\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 *  Veeck\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\n  var tests = [];\n  \n\n  /**\n   * ModernizrProto is the constructor for Modernizr\n   *\n   * @class\n   * @access public\n   */\n  var ModernizrProto = {\n    // The current version, dummy\n    _version: '3.7.1',\n\n    // Any settings that don't work as separate modules\n    // can go in here as configuration.\n    _config: {\n      'classPrefix': 'supports-',\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  var classes = [];\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} true if the typeof the first parameter is exactly the specified type, false otherwise\n   */\n  function is(obj, type) {\n    return typeof obj === type;\n  }\n\n  ;\n\n  /**\n   * Run through all tests and detect their support in the current UA.\n   *\n   * @access private\n   * @returns {void}\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        // 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  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  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\n\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  // 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      if (classes.length > 0) {\n        className += ' ' + classPrefix + classes.join(' ' + classPrefix);\n      }\n      if (isSVG) {\n        docElement.className.baseVal = className;\n      } else {\n        docElement.className = className;\n      }\n    }\n  }\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  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   * List of property values to set for css tests. See ticket #21\n   * https://github.com/modernizr/modernizr/issues/21\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  // 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  \"name\": \"CSS Calc\",\n  \"property\": \"csscalc\",\n  \"caniuse\": \"calc\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_calc\"],\n  \"authors\": [\"@calvein\"]\n}\n!*/\n/* DOC\nMethod of allowing calculated values for length units. For example:\n\n```css\n//lem {\n  width: calc(100% - 3em);\n}\n```\n*/\n\n  Modernizr.addTest('csscalc', function() {\n    var prop = 'width:';\n    var value = 'calc(10px);';\n    var el = createElement('a');\n\n    el.style.cssText = prop + prefixes.join(value + prop);\n\n    return !!el.style.length;\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  var omPrefixes = 'Moz O ms Webkit';\n  \n\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\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} true if and only if the first string 'str' contains the second string 'substr'\n   */\n  function contains(str, substr) {\n    return !!~('' + str).indexOf(substr);\n  }\n\n  ;\n\n  /**\n   * Create our \"modernizr\" element that we do most feature tests on.\n   *\n   * @access private\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   * 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  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} the result of the specified callback test\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   * 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  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  /**\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} elem - The element we want to find the computed styles of\n   * @param {string|null} [pseudo] - An optional pseudo element selector (e.g. :before), of null if none\n   * @param {string} prop - A CSS property\n   * @returns {CSSStyleDeclaration} the value of the specified CSS property\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  // 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: https://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  /**\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  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  // 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   * 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  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\n  ModernizrProto._domPrefixes = domPrefixes;\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  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 overridden\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   * 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   * testAllProps determines whether a given CSS property is supported in the browser\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.testAllProps\n   * @optionName Modernizr.testAllProps()\n   * @optionProp testAllProps\n   * @access public\n   * @function testAllProps\n   * @param {string} prop - String naming the property to test (either camelCase or kebab-case)\n   * @param {string} [value] - String of the value to test\n   * @param {boolean} [skipValueTest=false] - Whether to skip testing that the value is supported when using non-native detection\n   * @returns {false|string} returns the string version of the property, or false if it is unsupported\n   * @example\n   *\n   * testAllProps determines whether a given CSS property, in some prefixed form,\n   * is supported by the browser.\n   *\n   * ```js\n   * testAllProps('boxSizing')  // true\n   * ```\n   *\n   * It can optionally be given a CSS value in string form to test if a property\n   * value is valid\n   *\n   * ```js\n   * testAllProps('display', 'block') // true\n   * testAllProps('display', 'penguin') // false\n   * ```\n   *\n   * A boolean can be passed as a third parameter to skip the value check when\n   * native detection (@supports) isn't available.\n   *\n   * ```js\n   * testAllProps('shapeOutside', 'content-box', true);\n   * ```\n   */\n  function testAllProps(prop, value, skipValueTest) {\n    return testPropsAll(prop, undefined, undefined, value, skipValueTest);\n  }\n\n  ModernizrProto.testAllProps = testAllProps;\n\n  \n/*!\n{\n  \"name\": \"Flexbox\",\n  \"property\": \"flexbox\",\n  \"caniuse\": \"flexbox\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"The _new_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/css-flexbox-1/\"\n  }],\n  \"warnings\": [\n    \"A `true` result for this detect does not imply that the `flex-wrap` property is supported; see the `flexwrap` detect.\"\n  ]\n}\n!*/\n/* DOC\nDetects support for the Flexible Box Layout model, a.k.a. Flexbox, which allows easy manipulation of layout order and sizing within a container.\n*/\n\n  Modernizr.addTest('flexbox', testAllProps('flexBasis', '1px', true));\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  var testStyles = ModernizrProto.testStyles = injectElementWithStyles;\n  \n/*! {\n  \"name\": \"CSS Hairline\",\n  \"property\": \"hairline\",\n  \"tags\": [\"css\"],\n  \"authors\": [\"strarsis\"],\n  \"notes\": [{\n    \"name\": \"Blog post about CSS retina hairlines\",\n    \"href\": \"http://dieulot.net/css-retina-hairline\"\n  },{\n    \"name\": \"Derived from\",\n    \"href\": \"https://gist.github.com/dieulot/520a49463f6058fbc8d1\"\n  }]\n}\n!*/\n/* DOC\nDetects support for hidpi/retina hairlines, which are CSS borders with less than 1px in width, for being physically 1px on hidpi screens.\n*/\n\n  Modernizr.addTest('hairline', function() {\n    return testStyles('#modernizr {border:.5px solid transparent}', function(elem) {\n      return elem.offsetHeight === 1;\n    });\n  });\n\n/*!\n{\n  \"name\": \"CSS Supports\",\n  \"property\": \"supports\",\n  \"caniuse\": \"css-featurequeries\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_supports\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://dev.w3.org/csswg/css3-conditional/#at-supports\"\n  },{\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/648\"\n  },{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://dev.w3.org/csswg/css3-conditional/#the-csssupportsrule-interface\"\n  }]\n}\n!*/\n\n  var newSyntax = 'CSS' in window && 'supports' in window.CSS;\n  var oldSyntax = 'supportsCSS' in window;\n  Modernizr.addTest('supports', newSyntax || oldSyntax);\n\n/*!\n{\n  \"name\": \"CSS Transforms 3D\",\n  \"property\": \"csstransforms3d\",\n  \"caniuse\": \"transforms3d\",\n  \"tags\": [\"css\"],\n  \"warnings\": [\n    \"Chrome may occasionally fail this test on some systems; more info: https://bugs.chromium.org/p/chromium/issues/detail?id=129004\"\n  ]\n}\n!*/\n\n  Modernizr.addTest('csstransforms3d', function() {\n    return !!testAllProps('perspective', '1px', true);\n  });\n\n\n  /**\n   * roundedEquals takes two integers and checks if the first is within 1 of the second\n   *\n   * @access private\n   * @function roundedEquals\n   * @param {number} a - first integer\n   * @param {number} b - second integer\n   * @returns {boolean} true if the first integer is within 1 of the second, false otherwise\n   */\n  function roundedEquals(a, b) {\n    return a - 1 === b || a === b || a + 1 === b;\n  }\n\n  ;\n/*!\n{\n  \"name\": \"CSS vh unit\",\n  \"property\": \"cssvhunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vhunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  },{\n    \"name\": \"Similar JSFiddle\",\n    \"href\": \"https://jsfiddle.net/FWeinb/etnYC/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr { height: 50vh; }', function(elem) {\n    var height = parseInt(window.innerHeight / 2, 10);\n    var compStyle = parseInt(computedStyle(elem, null, 'height'), 10);\n\n    Modernizr.addTest('cssvhunit', roundedEquals(compStyle, height));\n  });\n\n/*!\n{\n  \"name\": \"CSS vmax unit\",\n  \"property\": \"cssvmaxunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vmaxunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  },{\n    \"name\": \"JSFiddle Example\",\n    \"href\": \"https://jsfiddle.net/glsee/JDsWQ/4/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr1{width: 50vmax}#modernizr2{width:50px;height:50px;overflow:scroll}#modernizr3{position:fixed;top:0;left:0;bottom:0;right:0}', function(node) {\n    var elem = node.childNodes[2];\n    var scroller = node.childNodes[1];\n    var fullSizeElem = node.childNodes[0];\n    var scrollbarWidth = parseInt((scroller.offsetWidth - scroller.clientWidth) / 2, 10);\n\n    var one_vw = fullSizeElem.clientWidth / 100;\n    var one_vh = fullSizeElem.clientHeight / 100;\n    var expectedWidth = parseInt(Math.max(one_vw, one_vh) * 50, 10);\n    var compWidth = parseInt(computedStyle(elem, null, 'width'), 10);\n\n    Modernizr.addTest('cssvmaxunit', roundedEquals(expectedWidth, compWidth) || roundedEquals(expectedWidth, compWidth - scrollbarWidth));\n  }, 3);\n\n/*!\n{\n  \"name\": \"CSS vmin unit\",\n  \"property\": \"cssvminunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vminunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  },{\n    \"name\": \"JSFiddle Example\",\n    \"href\": \"https://jsfiddle.net/glsee/JRmdq/8/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr1{width: 50vm;width:50vmin}#modernizr2{width:50px;height:50px;overflow:scroll}#modernizr3{position:fixed;top:0;left:0;bottom:0;right:0}', function(node) {\n    var elem = node.childNodes[2];\n    var scroller = node.childNodes[1];\n    var fullSizeElem = node.childNodes[0];\n    var scrollbarWidth = parseInt((scroller.offsetWidth - scroller.clientWidth) / 2, 10);\n\n    var one_vw = fullSizeElem.clientWidth / 100;\n    var one_vh = fullSizeElem.clientHeight / 100;\n    var expectedWidth = parseInt(Math.min(one_vw, one_vh) * 50, 10);\n    var compWidth = parseInt(computedStyle(elem, null, 'width'), 10);\n\n    Modernizr.addTest('cssvminunit', roundedEquals(expectedWidth, compWidth) || roundedEquals(expectedWidth, compWidth - scrollbarWidth));\n  }, 3);\n\n/*!\n{\n  \"name\": \"CSS vw unit\",\n  \"property\": \"cssvwunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vwunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  },{\n    \"name\": \"JSFiddle Example\",\n    \"href\": \"https://jsfiddle.net/FWeinb/etnYC/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr { width: 50vw; }', function(elem) {\n    var width = parseInt(window.innerWidth / 2, 10);\n    var compStyle = parseInt(computedStyle(elem, null, 'width'), 10);\n\n    Modernizr.addTest('cssvwunit', roundedEquals(compStyle, width));\n  });\n\n\n  /**\n   * hasOwnProp is a shim for hasOwnProperty that is needed for Safari 2.0 support\n   *\n   * @author kangax\n   * @access private\n   * @function hasOwnProp\n   * @param {object} object - The object to check for a property\n   * @param {string} property - The property to check for\n   * @returns {boolean}\n   */\n\n  // hasOwnProperty shim by kangax needed for Safari 2.0 support\n  var hasOwnProp;\n\n  (function() {\n    var _hasOwnProperty = ({}).hasOwnProperty;\n    /* istanbul ignore else */\n    /* we have no way of testing IE 5.5 or safari 2,\n     * so just assume the else gets hit */\n    if (!is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined')) {\n      hasOwnProp = function(object, property) {\n        return _hasOwnProperty.call(object, property);\n      };\n    }\n    else {\n      hasOwnProp = function(object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */\n        return ((property in object) && is(object.constructor.prototype[property], 'undefined'));\n      };\n    }\n  })();\n\n  \n\n\n  // _l tracks listeners for async tests, as well as tests that execute after the initial run\n  ModernizrProto._l = {};\n\n  /**\n   * Modernizr.on is a way to listen for the completion of async tests. Being\n   * asynchronous, they may not finish before your scripts run. As a result you\n   * will get a possibly false negative `undefined` value.\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.on\n   * @access public\n   * @function on\n   * @param {string} feature - String name of the feature detect\n   * @param {Function} cb - Callback function returning a Boolean - true if feature is supported, false if not\n   * @returns {void}\n   * @example\n   *\n   * ```js\n   * Modernizr.on('flash', function( result ) {\n   *   if (result) {\n   *    // the browser has flash\n   *   } else {\n   *     // the browser does not have flash\n   *   }\n   * });\n   * ```\n   */\n  ModernizrProto.on = function(feature, cb) {\n    // Create the list of listeners if it doesn't exist\n    if (!this._l[feature]) {\n      this._l[feature] = [];\n    }\n\n    // Push this test on to the listener list\n    this._l[feature].push(cb);\n\n    // If it's already been resolved, trigger it on next tick\n    if (Modernizr.hasOwnProperty(feature)) {\n      // Next Tick\n      setTimeout(function() {\n        Modernizr._trigger(feature, Modernizr[feature]);\n      }, 0);\n    }\n  };\n\n  /**\n   * _trigger is the private function used to signal test completion and run any\n   * callbacks registered through [Modernizr.on](#modernizr-on)\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._trigger\n   * @access private\n   * @function _trigger\n   * @param {string} feature - string name of the feature detect\n   * @param {Function|boolean} [res] - A feature detection function, or the boolean =\n   * result of a feature detection function\n   * @returns {void}\n   */\n  ModernizrProto._trigger = function(feature, res) {\n    if (!this._l[feature]) {\n      return;\n    }\n\n    var cbs = this._l[feature];\n\n    // Force async\n    setTimeout(function() {\n      var i, cb;\n      for (i = 0; i < cbs.length; i++) {\n        cb = cbs[i];\n        cb(res);\n      }\n    }, 0);\n\n    // Don't trigger these again\n    delete this._l[feature];\n  };\n\n  /**\n   * addTest allows you to define your own feature detects that are not currently\n   * included in Modernizr (under the covers it's the exact same code Modernizr\n   * uses for its own [feature detections](https://github.com/Modernizr/Modernizr/tree/master/feature-detects)).\n   * Just like the official detects, the result\n   * will be added onto the Modernizr object, as well as an appropriate className set on\n   * the html element when configured to do so\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.addTest\n   * @optionName Modernizr.addTest()\n   * @optionProp addTest\n   * @access public\n   * @function addTest\n   * @param {string|Object} feature - The string name of the feature detect, or an\n   * object of feature detect names and test\n   * @param {Function|boolean} test - Function returning true if feature is supported,\n   * false if not. Otherwise a boolean representing the results of a feature detection\n   * @returns {Object} the Modernizr object to allow chaining\n   * @example\n   *\n   * The most common way of creating your own feature detects is by calling\n   * `Modernizr.addTest` with a string (preferably just lowercase, without any\n   * punctuation), and a function you want executed that will return a boolean result\n   *\n   * ```js\n   * Modernizr.addTest('itsTuesday', function() {\n   *  var d = new Date();\n   *  return d.getDay() === 2;\n   * });\n   * ```\n   *\n   * When the above is run, it will set Modernizr.itstuesday to `true` when it is tuesday,\n   * and to `false` every other day of the week. One thing to notice is that the names of\n   * feature detect functions are always lowercased when added to the Modernizr object. That\n   * means that `Modernizr.itsTuesday` will not exist, but `Modernizr.itstuesday` will.\n   *\n   *\n   *  Since we only look at the returned value from any feature detection function,\n   *  you do not need to actually use a function. For simple detections, just passing\n   *  in a statement that will return a boolean value works just fine.\n   *\n   * ```js\n   * Modernizr.addTest('hasjquery', 'jQuery' in window);\n   * ```\n   *\n   * Just like before, when the above runs `Modernizr.hasjquery` will be true if\n   * jQuery has been included on the page. Not using a function saves a small amount\n   * of overhead for the browser, as well as making your code much more readable.\n   *\n   * Finally, you also have the ability to pass in an object of feature names and\n   * their tests. This is handy if you want to add multiple detections in one go.\n   * The keys should always be a string, and the value can be either a boolean or\n   * function that returns a boolean.\n   *\n   * ```js\n   * var detects = {\n   *  'hasjquery': 'jQuery' in window,\n   *  'itstuesday': function() {\n   *    var d = new Date();\n   *    return d.getDay() === 2;\n   *  }\n   * }\n   *\n   * Modernizr.addTest(detects);\n   * ```\n   *\n   * There is really no difference between the first methods and this one, it is\n   * just a convenience to let you write more readable code.\n   */\n  function addTest(feature, test) {\n\n    if (typeof feature === 'object') {\n      for (var key in feature) {\n        if (hasOwnProp(feature, key)) {\n          addTest(key, feature[ key ]);\n        }\n      }\n    } else {\n\n      feature = feature.toLowerCase();\n      var featureNameSplit = feature.split('.');\n      var last = Modernizr[featureNameSplit[0]];\n\n      // Again, we don't check for parent test existence. Get that right, though.\n      if (featureNameSplit.length === 2) {\n        last = last[featureNameSplit[1]];\n      }\n\n      if (typeof last !== 'undefined') {\n        // we're going to quit if you're trying to overwrite an existing test\n        // if we were to allow it, we'd do this:\n        //   var re = new RegExp(\"\\\\b(no-)?\" + feature + \"\\\\b\");\n        //   docElement.className = docElement.className.replace( re, '' );\n        // but, no rly, stuff 'em.\n        return Modernizr;\n      }\n\n      test = typeof test === 'function' ? test() : test;\n\n      // Set the value (this is the magic, right here).\n      if (featureNameSplit.length === 1) {\n        Modernizr[featureNameSplit[0]] = test;\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]] = test;\n      }\n\n      // Set a single class (either `feature` or `no-feature`)\n      setClasses([(!!test && test !== false ? '' : 'no-') + featureNameSplit.join('-')]);\n\n      // Trigger the event\n      Modernizr._trigger(feature, test);\n    }\n\n    return Modernizr; // allow chaining.\n  }\n\n  // After all the tests are run, add self to the Modernizr prototype\n  Modernizr._q.push(function() {\n    ModernizrProto.addTest = addTest;\n  });\n\n  \n\n/*!\n{\n  \"name\": \"SVG as an <img> tag source\",\n  \"property\": \"svgasimg\",\n  \"caniuse\": \"svg-img\",\n  \"tags\": [\"svg\"],\n  \"aliases\": [\"svgincss\"],\n  \"authors\": [\"Chris Coyier\"],\n  \"notes\": [{\n    \"name\": \"HTML5 Spec\",\n    \"href\": \"https://www.w3.org/TR/html5/embedded-content-0.html#the-img-element\"\n  }]\n}\n!*/\n\n\n  // Original Async test by Stu Cox\n  // https://gist.github.com/chriscoyier/8774501\n\n  // Now a Sync test based on good results here\n  // https://codepen.io/chriscoyier/pen/bADFx\n\n  // Note http://www.w3.org/TR/SVG11/feature#Image is *supposed* to represent\n  // support for the `<image>` tag in SVG, not an SVG file linked from an `<img>`\n  // tag in HTML – but it’s a heuristic which works\n  Modernizr.addTest('svgasimg', document.implementation.hasFeature('http://www.w3.org/TR/SVG11/feature#Image', '1.1'));\n\n/*!\n{\n  \"name\": \"Inline SVG\",\n  \"property\": \"inlinesvg\",\n  \"caniuse\": \"svg-html5\",\n  \"tags\": [\"svg\"],\n  \"notes\": [{\n    \"name\": \"Test page\",\n    \"href\": \"https://paulirish.com/demo/inline-svg\"\n  }, {\n    \"name\": \"Test page and results\",\n    \"href\": \"https://codepen.io/eltonmesquita/full/GgXbvo/\"\n  }],\n  \"polyfills\": [\"inline-svg-polyfill\"],\n  \"knownBugs\": [\"False negative on some Chromia browsers.\"]\n}\n!*/\n/* DOC\nDetects support for inline SVG in HTML (not within XHTML).\n*/\n\n  Modernizr.addTest('inlinesvg', function() {\n    var div = createElement('div');\n    div.innerHTML = '<svg/>';\n    return (typeof SVGRect !== 'undefined' && div.firstChild && div.firstChild.namespaceURI) === 'http://www.w3.org/2000/svg';\n  });\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\nmodule.exports = window.Modernizr;\nif (hadGlobal) { window.Modernizr = oldGlobal; }\nelse { delete window.Modernizr; }\n})(window);"],"sourceRoot":""}