{"version":3,"file":"themes/parachute/assets/js/dist/modernizr.min.js","sources":["node_modules/@babel/runtime/helpers/esm/typeof.js","themes/parachute/assets/js/src/modernizr.js"],"sourcesContent":["export default function _typeof(o) {\n \"@babel/helpers - typeof\";\n\n return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n return typeof o;\n } : function (o) {\n return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n }, _typeof(o);\n}","/*!\n * modernizr v3.6.0\n * Build https://modernizr.com/download?-cssgrid_cssgridlegacy-csstransforms-flexbox-ie8compat-objectfit-svg-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\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 `` 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': \"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{\n \"name\": \"IE8 compat mode\",\n \"property\": \"ie8compat\",\n \"authors\": [\"Erich Ocean\"]\n}\n!*/\n/* DOC\nDetects whether or not the current browser is IE8 in compatibility mode (i.e. acting as IE7).\n*/\n\n // In this case, IE8 will be acting as IE7. You may choose to remove features in this case.\n\n // related:\n // james.padolsey.com/javascript/detect-ie-in-js-using-conditional-comments/\n\n Modernizr.addTest('ie8compat', (!window.addEventListener && !!document.documentMode && document.documentMode === 7));\n\n/*!\n{\n \"name\": \"SVG\",\n \"property\": \"svg\",\n \"caniuse\": \"svg\",\n \"tags\": [\"svg\"],\n \"authors\": [\"Erik Dahlstrom\"],\n \"polyfills\": [\n \"svgweb\",\n \"raphael\",\n \"amplesdk\",\n \"canvg\",\n \"svg-boilerplate\",\n \"sie\",\n \"dojogfx\",\n \"fabricjs\"\n ]\n}\n!*/\n/* DOC\nDetects support for SVG in `` or `` elements.\n*/\n\n Modernizr.addTest('svg', !!document.createElementNS && !!document.createElementNS('http://www.w3.org/2000/svg', 'svg').createSVGRect);\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 * 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 * 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 * 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.} 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 * 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 * 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 * 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 * @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\n function testAllProps(prop, value, skipValueTest) {\n return testPropsAll(prop, undefined, undefined, value, skipValueTest);\n }\n ModernizrProto.testAllProps = testAllProps;\n\n/*!\n{\n \"name\": \"CSS Grid (old & new)\",\n \"property\": [\"cssgrid\", \"cssgridlegacy\"],\n \"authors\": [\"Faruk Ates\"],\n \"tags\": [\"css\"],\n \"notes\": [{\n \"name\": \"The new, standardized CSS Grid\",\n \"href\": \"https://www.w3.org/TR/css3-grid-layout/\"\n }, {\n \"name\": \"The _old_ CSS Grid (legacy)\",\n \"href\": \"https://www.w3.org/TR/2011/WD-css3-grid-layout-20110407/\"\n }]\n}\n!*/\n\n // `grid-columns` is only in the old syntax, `grid-column` exists in both and so `grid-template-rows` is used for the new syntax.\n Modernizr.addTest('cssgridlegacy', testAllProps('grid-columns', '10px', true));\n Modernizr.addTest('cssgrid', testAllProps('grid-template-rows', 'none', true));\n\n/*!\n{\n \"name\": \"Flexbox\",\n \"property\": \"flexbox\",\n \"caniuse\": \"flexbox\",\n \"tags\": [\"css\"],\n \"notes\": [{\n \"name\": \"The _new_ flexbox\",\n \"href\": \"http://dev.w3.org/csswg/css3-flexbox\"\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 \"name\": \"CSS Transforms\",\n \"property\": \"csstransforms\",\n \"caniuse\": \"transforms2d\",\n \"tags\": [\"css\"]\n}\n!*/\n\n Modernizr.addTest('csstransforms', function() {\n // Android < 3.0 is buggy, so we sniff and blacklist\n // http://git.io/hHzL7w\n return navigator.userAgent.indexOf('Android 2.') === -1 &&\n testAllProps('transform', 'scale(1)', true);\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"],"names":["_typeof","o","Symbol","iterator","constructor","prototype","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","addEventListener","documentMode","createElementNS","createSVGRect","docElement","documentElement","isSVG","nodeName","toLowerCase","cssToDOM","replace","str","m1","m2","toUpperCase","omPrefixes","cssomPrefixes","split","_cssomPrefixes","atRule","prop","rule","length","prefixes","cssrule","CSSRule","i","prefix","domPrefixes","createElement","arguments","call","apply","fnBind","that","_domPrefixes","modElem","elem","mStyle","style","domToCSS","injectElementWithStyles","callback","nodes","testnames","ret","node","docOverflow","mod","div","body","fake","getBody","parseInt","id","appendChild","styleSheet","cssText","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","nativeTestProps","props","value","CSS","supports","conditionText","join","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","testAllProps","unshift","navigator","userAgent","aliases","featureNames","feature","aliasIdx","nameIdx","featureNameSplit","featureIdx","hasOwnProperty","Boolean","testRunner","className","baseVal","reJS","RegExp","setClasses"],"mappings":"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","x_google_ignoreList":[0]}