{"version":3,"sources":["../js/src/head/_modernizr.custom.js","../js/src/head/classList.js","../js/src/head/head.js","../js/src/head/picturefill.js","../js/src/head/stickyfill.js"],"names":["window","document","undefined","is","obj","type","testRunner","featureNames","feature","aliasIdx","result","nameIdx","featureName","featureNameSplit","featureIdx","tests","hasOwnProperty","name","push","toLowerCase","options","aliases","length","fn","split","Modernizr","Boolean","classes","join","setClasses","className","docElement","classPrefix","_config","isSVG","baseVal","enableJSClass","reJS","RegExp","replace","enableClasses","createElement","arguments","createElementNS","call","apply","getBody","body","fake","injectElementWithStyles","rule","callback","nodes","testnames","style","ret","node","docOverflow","mod","div","parseInt","id","appendChild","styleSheet","cssText","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","contains","str","substr","indexOf","domToCSS","m1","nativeTestProps","props","value","i","CSS","supports","conditionText","getComputedStyle","position","cssToDOM","m2","toUpperCase","testProps","prefixed","skipValueTest","cleanElems","afterInit","mStyle","modElem","propsLength","prop","before","elems","shift","e","fnBind","that","testDOMProps","elem","item","testPropsAll","ucProp","charAt","slice","cssomPrefixes","testAllProps","addTest","test","key","hasOwnProp","last","_trigger","ModernizrProto","_version","usePrefixes","_q","on","cb","self","this","setTimeout","addAsyncTest","prototype","documentElement","nodeName","mq","matchMedia","msMatchMedia","mql","matches","bool","currentStyle","omPrefixes","_cssomPrefixes","unshift","domPrefixes","_domPrefixes","atRule","prefixes","cssrule","CSSRule","prefix","thisRule","_hasOwnProperty","object","property","constructor","_l","res","cbs","width1","width2","image","isSizes","width","onload","onerror","setAttribute","srcset","src","_prefixes","testStyles","DocumentTouch","query","offsetTop","el","String","createSVGRect","testElement","classList","add","createMethod","method","original","DOMTokenList","token","len","toggle","_toggle","force","view","classListProp","protoProp","elemCtrProto","Element","objCtr","Object","strTrim","trim","arrIndexOf","Array","DOMEx","message","code","DOMException","checkTokenAndGetIndex","ClassList","trimmedClasses","getAttribute","_updateClassName","toString","classListProto","classListGetter","Error","tokens","l","updated","remove","index","splice","defineProperty","classListPropDesc","get","enumerable","configurable","ex","number","__defineGetter__","html","querySelector","ua","navigator","userAgent","HTMLPictureElement","match","$1","addEventListener","timer","dummySrc","fixRespimg","img","source","sizes","picture","cloneNode","insertBefore","firstElementChild","_pfLastSize","offsetWidth","findPictureImgs","imgs","querySelectorAll","onResize","clearTimeout","init","addListener","readyState","isSpace","c","detectTypeSupport","typeUri","Image","types","picturefill","updateMetrics","isVwDirty","DPR","devicePixelRatio","cssCache","sizeLengthCache","pf","units","Math","max","innerWidth","docElem","clientWidth","height","innerHeight","clientHeight","vw","vh","evalId","em","getEmValue","rem","chooseLowRes","lowerValue","higherValue","dprValue","isCached","bonusFactor","tooMuch","bonus","meanDensity","cfg","algorithm","pow","sqrt","applyBestCandidate","srcSetCandidates","matchingSet","getSet","evaluated","setRes","applySetCandidate","ns","evaled","ascendingSort","a","b","setSrcToCur","set","candidate","sets","getCandidateForSrc","makeUrl","curSrc","curCan","setResolution","candidates","parseSet","url","getAllSourceElements","sources","getElementsByTagName","media","parseSrcset","input","collectCharacters","regEx","chars","exec","substring","pos","parseDescriptors","w","d","h","desc","lastChar","intVal","floatVal","pError","descriptors","parseFloat","regexNonNegativeInteger","regexFloatingPoint","has1x","tokenize","regexLeadingSpaces","currentDescriptor","state","inputLength","regexLeadingCommasOrSpaces","regexLeadingNotSpaces","regexTrailingCommas","parseSizes","strValue","parseComponentValues","pushComponent","component","componentArray","pushComponentArray","listArray","chrctr","parenDepth","inComment","isValidNonNegativeSourceSizeValue","s","regexCssLengthWithUnits","regexCssCalc","unparsedSizesList","unparsedSizesListLength","unparsedSize","lastComponentValue","size","pop","matchesMedia","warn","eminpx","alwaysCheckWDescriptor","noop","getImgAttr","setImgAttr","removeImgAttr","removeAttribute","srcAttr","srcsetAttr","supportAbort","curSrcProp","regWDesc","regSize","setOptions","picturefillCFG","baseStyle","fsCss","px","in","anchor","alreadyRun","evt","capture","attachEvent","memoize","cache","evalCSS","regLength","args","string","buildStr","css","parsedLength","Function","sizesattr","cWidth","calcListLength","opt","elements","plen","nodeType","context","qsa","reevaluate","reselect","sel","selShort","setupRun","fillImg","teardownRun","console","implementation","hasFeature","Date","getTime","supSrcset","supSizes","supPicture","image2","complete","u","setSize","href","mMQ","calcLength","sourceSizeValue","supportsType","parseSize","sourceSizeStr","cands","originalHTMLCSS","originalBodyCSS","sourceSizeListStr","uT","winningLength","j","bestCandidate","candidateSrc","abortCurSrc","imageData","dpr","cached","sort","setSrc","origWidth","parseSets","element","parent","srcsetAttribute","imageSet","isWDescripor","srcsetParsed","hasPicture","pic","supported","parsed","extreme","isDomReady","regReady","run","timerId","fillImgs","debounce","func","wait","timeout","timestamp","later","lastClientWidth","_","module","exports","define","amd","doc","win","seppuku","rebuild","pause","stop","kill","mergeObjects","targetObj","sourceObject","parseNumeric","val","updateScrollPos","scroll","top","pageYOffset","left","pageXOffset","onScroll","recalcAllPos","onWheel","event","watchArray","recalcElementPos","inited","currentMode","limit","start","end","mode","switchElementMode","fastCheck","deltaTop","abs","getDocOffsetTop","clone","docOffsetTop","deltaHeight","initElement","isNaN","computed","isCell","display","deinitElement","deinitParent","killClone","initAll","deinitAll","nodeStyle","offset","right","bottom","marginLeft","marginRight","marginTop","box","refElement","nextSibling","cloneStyle","marginBottom","padding","border","borderSpacing","fontSize","cssFloat","getElementParams","computedStyle","parentComputedStyle","cachedPosition","numeric","paddingLeft","paddingRight","borderLeftWidth","borderRightWidth","nodeOffset","getElementOffset","parentOffset","borderTopWidth","borderBottomWidth","offsetParent","getBoundingClientRect","startFastCheckTimer","checkTimer","setInterval","stopFastCheckTimer","clearInterval","handlePageVisibilityChange","initialized","hiddenPropertyName","visibilityChangeEventName","removeEventListener","webkitHidden","block","Stickyfill","stickies","jQuery","$","each"],"mappings":"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","file":"head.js","sourcesContent":["/*!\n * modernizr v3.3.1\n * Build http://modernizr.com/download?-contains-csscolumns-csspositionsticky-flexbox-flexboxlegacy-flexboxtweener-sizes-srcset-svg-touchevents-mq-prefixed-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 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.3.1',\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  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}\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            /* jshint -W053 */\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      isSVG ? docElement.className.baseVal = className : 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\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      docElement.offsetHeight;\n    } else {\n      div.parentNode.removeChild(div);\n    }\n\n    return !!ret;\n\n  }\n\n  ;\n\n  /**\n   * Modernizr.mq tests a given media query, live against the current state of the window\n   * adapted from matchMedia polyfill by Scott Jehl and Paul Irish\n   * gist.github.com/786768\n   *\n   * @memberof Modernizr\n   * @name Modernizr.mq\n   * @optionName Modernizr.mq()\n   * @optionProp mq\n   * @access public\n   * @function mq\n   * @param {string} mq - String of the media query we want to test\n   * @returns {boolean}\n   * @example\n   * Modernizr.mq allows for you to programmatically check if the current browser\n   * window state matches a media query.\n   *\n   * ```js\n   *  var query = Modernizr.mq('(min-width: 900px)');\n   *\n   *  if (query) {\n   *    // the browser window is larger than 900px\n   *  }\n   * ```\n   *\n   * Only valid media queries are supported, therefore you must always include values\n   * with your media query\n   *\n   * ```js\n   * // good\n   *  Modernizr.mq('(min-width: 900px)');\n   *\n   * // bad\n   *  Modernizr.mq('min-width');\n   * ```\n   *\n   * If you would just like to test that media queries are supported in general, use\n   *\n   * ```js\n   *  Modernizr.mq('only all'); // true if MQ are supported, false if not\n   * ```\n   *\n   *\n   * Note that if the browser does not support media queries (e.g. old IE) mq will\n   * always return false.\n   */\n\n  var mq = (function() {\n    var matchMedia = window.matchMedia || window.msMatchMedia;\n    if (matchMedia) {\n      return function(mq) {\n        var mql = matchMedia(mq);\n        return mql && mql.matches || false;\n      };\n    }\n\n    return function(mq) {\n      var bool = false;\n\n      injectElementWithStyles('@media ' + mq + ' { #modernizr { position: absolute; } }', function(node) {\n        bool = (window.getComputedStyle ?\n                window.getComputedStyle(node, null) :\n                node.currentStyle).position == 'absolute';\n      });\n\n      return bool;\n    };\n  })();\n\n\n  ModernizrProto.mq = mq;\n\n  \n\n  /**\n   * If the browsers follow the spec, then they would expose vendor-specific style as:\n   *   elem.style.WebkitBorderRadius\n   * instead of something like the following, which would be 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  /**\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   * 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   * 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 getComputedStyle(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\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  // 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    var elems = ['modernizr', 'tspan'];\n    while (!mStyle.style) {\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\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\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   */\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   * 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   */\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   * 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   * 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   * 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\": \"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\": \"Flexbox (legacy)\",\n  \"property\": \"flexboxlegacy\",\n  \"tags\": [\"css\"],\n  \"polyfills\": [\"flexie\"],\n  \"notes\": [{\n    \"name\": \"The _old_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('flexboxlegacy', testAllProps('boxDirection', 'reverse', true));\n\n/*!\n{\n  \"name\": \"Flexbox (tweener)\",\n  \"property\": \"flexboxtweener\",\n  \"tags\": [\"css\"],\n  \"polyfills\": [\"flexie\"],\n  \"notes\": [{\n    \"name\": \"The _inbetween_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/2011/WD-css3-flexbox-20111129/\"\n  }],\n  \"warnings\": [\"This represents an old syntax, not the latest standard syntax.\"]\n}\n!*/\n\n  Modernizr.addTest('flexboxtweener', testAllProps('flexAlign', 'end', true));\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   * @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\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   */\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)). Just like the offical 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   * @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\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        /* jshint -W053 */\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      /* jshint -W041 */\n      setClasses([(!!test && test != false ? '' : 'no-') + featureNameSplit.join('-')]);\n      /* jshint +W041 */\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\": \"sizes attribute\",\n  \"async\": true,\n  \"property\": \"sizes\",\n  \"tags\": [\"image\"],\n  \"authors\": [\"Mat Marquis\"],\n  \"notes\": [{\n    \"name\": \"Spec\",\n    \"href\": \"http://picture.responsiveimages.org/#parse-sizes-attr\"\n    },{\n    \"name\": \"Usage Details\",\n    \"href\": \"http://ericportis.com/posts/2014/srcset-sizes/\"\n    }]\n}\n!*/\n/* DOC\nTest for the `sizes` attribute on images\n*/\n\n  Modernizr.addAsyncTest(function() {\n    var width1, width2, test;\n    var image = createElement('img');\n    // in a perfect world this would be the test...\n    var isSizes = 'sizes' in image;\n\n    // ... but we need to deal with Safari 9...\n    if (!isSizes && ('srcset' in  image)) {\n      width2 = 'data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==';\n      width1 = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';\n\n      test = function() {\n        addTest('sizes', image.width == 2);\n      };\n\n      image.onload = test;\n      image.onerror = test;\n      image.setAttribute('sizes', '9px');\n\n      image.srcset = width1 + ' 1w,' + width2 + ' 8w';\n      image.src = width1;\n    } else {\n      addTest('sizes', isSizes);\n    }\n  });\n\n/*!\n{\n  \"name\": \"srcset attribute\",\n  \"property\": \"srcset\",\n  \"tags\": [\"image\"],\n  \"notes\": [{\n    \"name\": \"Smashing Magazine Article\",\n    \"href\": \"https://en.wikipedia.org/wiki/APNG\"\n    },{\n    \"name\": \"Generate multi-resolution images for srcset with Grunt\",\n    \"href\": \"https://addyosmani.com/blog/generate-multi-resolution-images-for-srcset-with-grunt/\"\n    }]\n}\n!*/\n/* DOC\nTest for the srcset attribute of images\n*/\n\n  Modernizr.addTest('srcset', 'srcset' in createElement('img'));\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  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   * 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  \"name\": \"CSS position: sticky\",\n  \"property\": \"csspositionsticky\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_positionsticky\"],\n  \"notes\": [{\n    \"name\": \"Chrome bug report\",\n    \"href\":\"https://code.google.com/p/chromium/issues/detail?id=322972\"\n  }],\n  \"warnings\": [ \"using position:sticky on anything but top aligned elements is buggy in Chrome < 37 and iOS <=7+\" ]\n}\n!*/\n\n  // Sticky positioning - constrains an element to be positioned inside the\n  // intersection of its container box, and the viewport.\n  Modernizr.addTest('csspositionsticky', function() {\n    var prop = 'position:';\n    var value = 'sticky';\n    var el = createElement('a');\n    var mStyle = el.style;\n\n    mStyle.cssText = prop + prefixes.join(value + ';' + prop).slice(0, -prop.length);\n\n    return mStyle.position.indexOf(value) !== -1;\n  });\n\n/*!\n{\n  \"name\": \"ES5 String.prototype.contains\",\n  \"property\": \"contains\",\n  \"authors\": [\"Robert Kowalski\"],\n  \"tags\": [\"es6\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 6 `String.prototype.contains` per specification.\n*/\n\n  Modernizr.addTest('contains', is(String.prototype.contains, 'function'));\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 `<embed>` or `<object>` elements.\n*/\n\n  Modernizr.addTest('svg', !!document.createElementNS && !!document.createElementNS('http://www.w3.org/2000/svg', 'svg').createSVGRect);\n\n/*!\n{\n  \"name\": \"CSS Columns\",\n  \"property\": \"csscolumns\",\n  \"caniuse\": \"multicolumn\",\n  \"polyfills\": [\"css3multicolumnjs\"],\n  \"tags\": [\"css\"]\n}\n!*/\n\n\n  (function() {\n\n    /* jshint -W053 */\n    Modernizr.addTest('csscolumns', function() {\n      var bool = false;\n      var test = testAllProps('columnCount');\n      try {\n        if (bool = !!test) {\n          bool = new Boolean(bool);\n        }\n      } catch (e) {}\n\n      return bool;\n    });\n\n    var props = ['Width', 'Span', 'Fill', 'Gap', 'Rule', 'RuleColor', 'RuleStyle', 'RuleWidth', 'BreakBefore', 'BreakAfter', 'BreakInside'];\n    var name, test;\n\n    for (var i = 0; i < props.length; i++) {\n      name = props[i].toLowerCase();\n      test = testAllProps('column' + props[i]);\n\n      // break-before, break-after & break-inside are not \"column\"-prefixed in spec\n      if (name === 'breakbefore' || name === 'breakafter' || name == 'breakinside') {\n        test = test || testAllProps(props[i]);\n      }\n\n      Modernizr.addTest('csscolumns.' + name, test);\n    }\n\n\n  })();\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 * classList.js: Cross-browser full element.classList implementation.\n * 1.1.20150312\n *\n * By Eli Grey, http://eligrey.com\n * License: Dedicated to the public domain.\n *   See https://github.com/eligrey/classList.js/blob/master/LICENSE.md\n */\n\n/*global self, document, DOMException */\n\n/*! @source http://purl.eligrey.com/github/classList.js/blob/master/classList.js */\n\nif (\"document\" in self) {\n\n// Full polyfill for browsers with no classList support\n// Including IE < Edge missing SVGElement.classList\nif (!(\"classList\" in document.createElement(\"_\"))\n\t|| document.createElementNS && !(\"classList\" in document.createElementNS(\"http://www.w3.org/2000/svg\",\"g\"))) {\n\n(function (view) {\n\n\"use strict\";\n\nif (!('Element' in view)) return;\n\nvar\n\t  classListProp = \"classList\"\n\t, protoProp = \"prototype\"\n\t, elemCtrProto = view.Element[protoProp]\n\t, objCtr = Object\n\t, strTrim = String[protoProp].trim || function () {\n\t\treturn this.replace(/^\\s+|\\s+$/g, \"\");\n\t}\n\t, arrIndexOf = Array[protoProp].indexOf || function (item) {\n\t\tvar\n\t\t\t  i = 0\n\t\t\t, len = this.length\n\t\t;\n\t\tfor (; i < len; i++) {\n\t\t\tif (i in this && this[i] === item) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t}\n\t// Vendors: please allow content code to instantiate DOMExceptions\n\t, DOMEx = function (type, message) {\n\t\tthis.name = type;\n\t\tthis.code = DOMException[type];\n\t\tthis.message = message;\n\t}\n\t, checkTokenAndGetIndex = function (classList, token) {\n\t\tif (token === \"\") {\n\t\t\tthrow new DOMEx(\n\t\t\t\t  \"SYNTAX_ERR\"\n\t\t\t\t, \"An invalid or illegal string was specified\"\n\t\t\t);\n\t\t}\n\t\tif (/\\s/.test(token)) {\n\t\t\tthrow new DOMEx(\n\t\t\t\t  \"INVALID_CHARACTER_ERR\"\n\t\t\t\t, \"String contains an invalid character\"\n\t\t\t);\n\t\t}\n\t\treturn arrIndexOf.call(classList, token);\n\t}\n\t, ClassList = function (elem) {\n\t\tvar\n\t\t\t  trimmedClasses = strTrim.call(elem.getAttribute(\"class\") || \"\")\n\t\t\t, classes = trimmedClasses ? trimmedClasses.split(/\\s+/) : []\n\t\t\t, i = 0\n\t\t\t, len = classes.length\n\t\t;\n\t\tfor (; i < len; i++) {\n\t\t\tthis.push(classes[i]);\n\t\t}\n\t\tthis._updateClassName = function () {\n\t\t\telem.setAttribute(\"class\", this.toString());\n\t\t};\n\t}\n\t, classListProto = ClassList[protoProp] = []\n\t, classListGetter = function () {\n\t\treturn new ClassList(this);\n\t}\n;\n// Most DOMException implementations don't allow calling DOMException's toString()\n// on non-DOMExceptions. Error's toString() is sufficient here.\nDOMEx[protoProp] = Error[protoProp];\nclassListProto.item = function (i) {\n\treturn this[i] || null;\n};\nclassListProto.contains = function (token) {\n\ttoken += \"\";\n\treturn checkTokenAndGetIndex(this, token) !== -1;\n};\nclassListProto.add = function () {\n\tvar\n\t\t  tokens = arguments\n\t\t, i = 0\n\t\t, l = tokens.length\n\t\t, token\n\t\t, updated = false\n\t;\n\tdo {\n\t\ttoken = tokens[i] + \"\";\n\t\tif (checkTokenAndGetIndex(this, token) === -1) {\n\t\t\tthis.push(token);\n\t\t\tupdated = true;\n\t\t}\n\t}\n\twhile (++i < l);\n\n\tif (updated) {\n\t\tthis._updateClassName();\n\t}\n};\nclassListProto.remove = function () {\n\tvar\n\t\t  tokens = arguments\n\t\t, i = 0\n\t\t, l = tokens.length\n\t\t, token\n\t\t, updated = false\n\t\t, index\n\t;\n\tdo {\n\t\ttoken = tokens[i] + \"\";\n\t\tindex = checkTokenAndGetIndex(this, token);\n\t\twhile (index !== -1) {\n\t\t\tthis.splice(index, 1);\n\t\t\tupdated = true;\n\t\t\tindex = checkTokenAndGetIndex(this, token);\n\t\t}\n\t}\n\twhile (++i < l);\n\n\tif (updated) {\n\t\tthis._updateClassName();\n\t}\n};\nclassListProto.toggle = function (token, force) {\n\ttoken += \"\";\n\n\tvar\n\t\t  result = this.contains(token)\n\t\t, method = result ?\n\t\t\tforce !== true && \"remove\"\n\t\t:\n\t\t\tforce !== false && \"add\"\n\t;\n\n\tif (method) {\n\t\tthis[method](token);\n\t}\n\n\tif (force === true || force === false) {\n\t\treturn force;\n\t} else {\n\t\treturn !result;\n\t}\n};\nclassListProto.toString = function () {\n\treturn this.join(\" \");\n};\n\nif (objCtr.defineProperty) {\n\tvar classListPropDesc = {\n\t\t  get: classListGetter\n\t\t, enumerable: true\n\t\t, configurable: true\n\t};\n\ttry {\n\t\tobjCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);\n\t} catch (ex) { // IE 8 doesn't support enumerable:true\n\t\tif (ex.number === -0x7FF5EC54) {\n\t\t\tclassListPropDesc.enumerable = false;\n\t\t\tobjCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);\n\t\t}\n\t}\n} else if (objCtr[protoProp].__defineGetter__) {\n\telemCtrProto.__defineGetter__(classListProp, classListGetter);\n}\n\n}(self));\n\n} else {\n// There is full or partial native classList support, so just check if we need\n// to normalize the add/remove and toggle APIs.\n\n(function () {\n\t\"use strict\";\n\n\tvar testElement = document.createElement(\"_\");\n\n\ttestElement.classList.add(\"c1\", \"c2\");\n\n\t// Polyfill for IE 10/11 and Firefox <26, where classList.add and\n\t// classList.remove exist but support only one argument at a time.\n\tif (!testElement.classList.contains(\"c2\")) {\n\t\tvar createMethod = function(method) {\n\t\t\tvar original = DOMTokenList.prototype[method];\n\n\t\t\tDOMTokenList.prototype[method] = function(token) {\n\t\t\t\tvar i, len = arguments.length;\n\n\t\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\t\ttoken = arguments[i];\n\t\t\t\t\toriginal.call(this, token);\n\t\t\t\t}\n\t\t\t};\n\t\t};\n\t\tcreateMethod('add');\n\t\tcreateMethod('remove');\n\t}\n\n\ttestElement.classList.toggle(\"c3\", false);\n\n\t// Polyfill for IE 10 and Firefox <24, where classList.toggle does not\n\t// support the second argument.\n\tif (testElement.classList.contains(\"c3\")) {\n\t\tvar _toggle = DOMTokenList.prototype.toggle;\n\n\t\tDOMTokenList.prototype.toggle = function(token, force) {\n\t\t\tif (1 in arguments && !this.contains(token) === !force) {\n\t\t\t\treturn force;\n\t\t\t} else {\n\t\t\t\treturn _toggle.call(this, token);\n\t\t\t}\n\t\t};\n\n\t}\n\n\ttestElement = null;\n}());\n\n}\n\n}\n","/**\n* Wild Salmon Center\n* http://wildsalmoncenter.org\n*\n* Copyright (c) 2015 Nate Bedortha @ Substance\n*/\n\n ( function( window, undefined ) {\n  'use strict';\n\n  if ( Modernizr ) {\n\n    var html = document.querySelector( 'html' );\n\n    if( Modernizr.mq( 'only all' ) ) {\n      html.classList.add( 'mq' );\n    } else {\n      html.classList.add( 'no-mq' );\n    }\n  }\n\n } )( this );\n","/*! Picturefill - v3.0.1 - 2015-09-30\n * http://scottjehl.github.io/picturefill\n * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT\n */\n/*! Gecko-Picture - v1.0\n * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture\n * Firefox's early picture implementation (prior to FF41) is static and does\n * not react to viewport changes. This tiny module fixes this.\n */\n(function(window) {\n\t/*jshint eqnull:true */\n\tvar ua = navigator.userAgent;\n\n\tif ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 < 41) ) {\n\t\taddEventListener(\"resize\", (function() {\n\t\t\tvar timer;\n\n\t\t\tvar dummySrc = document.createElement(\"source\");\n\n\t\t\tvar fixRespimg = function(img) {\n\t\t\t\tvar source, sizes;\n\t\t\t\tvar picture = img.parentNode;\n\n\t\t\t\tif (picture.nodeName.toUpperCase() === \"PICTURE\") {\n\t\t\t\t\tsource = dummySrc.cloneNode();\n\n\t\t\t\t\tpicture.insertBefore(source, picture.firstElementChild);\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tpicture.removeChild(source);\n\t\t\t\t\t});\n\t\t\t\t} else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {\n\t\t\t\t\timg._pfLastSize = img.offsetWidth;\n\t\t\t\t\tsizes = img.sizes;\n\t\t\t\t\timg.sizes += \",100vw\";\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\timg.sizes = sizes;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar findPictureImgs = function() {\n\t\t\t\tvar i;\n\t\t\t\tvar imgs = document.querySelectorAll(\"picture > img, img[srcset][sizes]\");\n\t\t\t\tfor (i = 0; i < imgs.length; i++) {\n\t\t\t\t\tfixRespimg(imgs[i]);\n\t\t\t\t}\n\t\t\t};\n\t\t\tvar onResize = function() {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\ttimer = setTimeout(findPictureImgs, 99);\n\t\t\t};\n\t\t\tvar mq = window.matchMedia && matchMedia(\"(orientation: landscape)\");\n\t\t\tvar init = function() {\n\t\t\t\tonResize();\n\n\t\t\t\tif (mq && mq.addListener) {\n\t\t\t\t\tmq.addListener(onResize);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tdummySrc.srcset = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\n\t\t\tif (/^[c|i]|d$/.test(document.readyState || \"\")) {\n\t\t\t\tinit();\n\t\t\t} else {\n\t\t\t\tdocument.addEventListener(\"DOMContentLoaded\", init);\n\t\t\t}\n\n\t\t\treturn onResize;\n\t\t})());\n\t}\n})(window);\n\n/*! Picturefill - v3.0.1\n * http://scottjehl.github.io/picturefill\n * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;\n *  License: MIT\n */\n\n(function( window, document, undefined ) {\n\t// Enable strict mode\n\t\"use strict\";\n\n\t// HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)\n\tdocument.createElement( \"picture\" );\n\n\tvar warn, eminpx, alwaysCheckWDescriptor, evalId;\n\t// local object for method references and testing exposure\n\tvar pf = {};\n\tvar noop = function() {};\n\tvar image = document.createElement( \"img\" );\n\tvar getImgAttr = image.getAttribute;\n\tvar setImgAttr = image.setAttribute;\n\tvar removeImgAttr = image.removeAttribute;\n\tvar docElem = document.documentElement;\n\tvar types = {};\n\tvar cfg = {\n\t\t//resource selection:\n\t\talgorithm: \"\"\n\t};\n\tvar srcAttr = \"data-pfsrc\";\n\tvar srcsetAttr = srcAttr + \"set\";\n\t// ua sniffing is done for undetectable img loading features,\n\t// to do some non crucial perf optimizations\n\tvar ua = navigator.userAgent;\n\tvar supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 > 35 );\n\tvar curSrcProp = \"currentSrc\";\n\tvar regWDesc = /\\s+\\+?\\d+(e\\d+)?w/;\n\tvar regSize = /(\\([^)]+\\))?\\s*(.+)/;\n\tvar setOptions = window.picturefillCFG;\n\t/**\n\t * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )\n\t */\n\t// baseStyle also used by getEmValue (i.e.: width: 1em is important)\n\tvar baseStyle = \"position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)\";\n\tvar fsCss = \"font-size:100%!important;\";\n\tvar isVwDirty = true;\n\n\tvar cssCache = {};\n\tvar sizeLengthCache = {};\n\tvar DPR = window.devicePixelRatio;\n\tvar units = {\n\t\tpx: 1,\n\t\t\"in\": 96\n\t};\n\tvar anchor = document.createElement( \"a\" );\n\t/**\n\t * alreadyRun flag used for setOptions. is it true setOptions will reevaluate\n\t * @type {boolean}\n\t */\n\tvar alreadyRun = false;\n\n\t// Reusable, non-\"g\" Regexes\n\n\t// (Don't use \\s, to avoid matching non-breaking space.)\n\tvar regexLeadingSpaces = /^[ \\t\\n\\r\\u000c]+/,\n\t    regexLeadingCommasOrSpaces = /^[, \\t\\n\\r\\u000c]+/,\n\t    regexLeadingNotSpaces = /^[^ \\t\\n\\r\\u000c]+/,\n\t    regexTrailingCommas = /[,]+$/,\n\t    regexNonNegativeInteger = /^\\d+$/,\n\n\t    // ( Positive or negative or unsigned integers or decimals, without or without exponents.\n\t    // Must include at least one digit.\n\t    // According to spec tests any decimal point must be followed by a digit.\n\t    // No leading plus sign is allowed.)\n\t    // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number\n\t    regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;\n\n\tvar on = function(obj, evt, fn, capture) {\n\t\tif ( obj.addEventListener ) {\n\t\t\tobj.addEventListener(evt, fn, capture || false);\n\t\t} else if ( obj.attachEvent ) {\n\t\t\tobj.attachEvent( \"on\" + evt, fn);\n\t\t}\n\t};\n\n\t/**\n\t * simple memoize function:\n\t */\n\n\tvar memoize = function(fn) {\n\t\tvar cache = {};\n\t\treturn function(input) {\n\t\t\tif ( !(input in cache) ) {\n\t\t\t\tcache[ input ] = fn(input);\n\t\t\t}\n\t\t\treturn cache[ input ];\n\t\t};\n\t};\n\n\t// UTILITY FUNCTIONS\n\n\t// Manual is faster than RegEx\n\t// http://jsperf.com/whitespace-character/5\n\tfunction isSpace(c) {\n\t\treturn (c === \"\\u0020\" || // space\n\t\t        c === \"\\u0009\" || // horizontal tab\n\t\t        c === \"\\u000A\" || // new line\n\t\t        c === \"\\u000C\" || // form feed\n\t\t        c === \"\\u000D\");  // carriage return\n\t}\n\n\t/**\n\t * gets a mediaquery and returns a boolean or gets a css length and returns a number\n\t * @param css mediaqueries or css length\n\t * @returns {boolean|number}\n\t *\n\t * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738\n\t */\n\tvar evalCSS = (function() {\n\n\t\tvar regLength = /^([\\d\\.]+)(em|vw|px)$/;\n\t\tvar replace = function() {\n\t\t\tvar args = arguments, index = 0, string = args[0];\n\t\t\twhile (++index in args) {\n\t\t\t\tstring = string.replace(args[index], args[++index]);\n\t\t\t}\n\t\t\treturn string;\n\t\t};\n\n\t\tvar buildStr = memoize(function(css) {\n\n\t\t\treturn \"return \" + replace((css || \"\").toLowerCase(),\n\t\t\t\t// interpret `and`\n\t\t\t\t/\\band\\b/g, \"&&\",\n\n\t\t\t\t// interpret `,`\n\t\t\t\t/,/g, \"||\",\n\n\t\t\t\t// interpret `min-` as >=\n\t\t\t\t/min-([a-z-\\s]+):/g, \"e.$1>=\",\n\n\t\t\t\t// interpret `max-` as <=\n\t\t\t\t/max-([a-z-\\s]+):/g, \"e.$1<=\",\n\n\t\t\t\t//calc value\n\t\t\t\t/calc([^)]+)/g, \"($1)\",\n\n\t\t\t\t// interpret css values\n\t\t\t\t/(\\d+[\\.]*[\\d]*)([a-z]+)/g, \"($1 * e.$2)\",\n\t\t\t\t//make eval less evil\n\t\t\t\t/^(?!(e.[a-z]|[0-9\\.&=|><\\+\\-\\*\\(\\)\\/])).*/ig, \"\"\n\t\t\t) + \";\";\n\t\t});\n\n\t\treturn function(css, length) {\n\t\t\tvar parsedLength;\n\t\t\tif (!(css in cssCache)) {\n\t\t\t\tcssCache[css] = false;\n\t\t\t\tif (length && (parsedLength = css.match( regLength ))) {\n\t\t\t\t\tcssCache[css] = parsedLength[ 1 ] * units[parsedLength[ 2 ]];\n\t\t\t\t} else {\n\t\t\t\t\t/*jshint evil:true */\n\t\t\t\t\ttry{\n\t\t\t\t\t\tcssCache[css] = new Function(\"e\", buildStr(css))(units);\n\t\t\t\t\t} catch(e) {}\n\t\t\t\t\t/*jshint evil:false */\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn cssCache[css];\n\t\t};\n\t})();\n\n\tvar setResolution = function( candidate, sizesattr ) {\n\t\tif ( candidate.w ) { // h = means height: || descriptor.type === 'h' do not handle yet...\n\t\t\tcandidate.cWidth = pf.calcListLength( sizesattr || \"100vw\" );\n\t\t\tcandidate.res = candidate.w / candidate.cWidth ;\n\t\t} else {\n\t\t\tcandidate.res = candidate.d;\n\t\t}\n\t\treturn candidate;\n\t};\n\n\t/**\n\t *\n\t * @param opt\n\t */\n\tvar picturefill = function( opt ) {\n\t\tvar elements, i, plen;\n\n\t\tvar options = opt || {};\n\n\t\tif ( options.elements && options.elements.nodeType === 1 ) {\n\t\t\tif ( options.elements.nodeName.toUpperCase() === \"IMG\" ) {\n\t\t\t\toptions.elements =  [ options.elements ];\n\t\t\t} else {\n\t\t\t\toptions.context = options.elements;\n\t\t\t\toptions.elements =  null;\n\t\t\t}\n\t\t}\n\n\t\telements = options.elements || pf.qsa( (options.context || document), ( options.reevaluate || options.reselect ) ? pf.sel : pf.selShort );\n\n\t\tif ( (plen = elements.length) ) {\n\n\t\t\tpf.setupRun( options );\n\t\t\talreadyRun = true;\n\n\t\t\t// Loop through all elements\n\t\t\tfor ( i = 0; i < plen; i++ ) {\n\t\t\t\tpf.fillImg(elements[ i ], options);\n\t\t\t}\n\n\t\t\tpf.teardownRun( options );\n\t\t}\n\t};\n\n\t/**\n\t * outputs a warning for the developer\n\t * @param {message}\n\t * @type {Function}\n\t */\n\twarn = ( window.console && console.warn ) ?\n\t\tfunction( message ) {\n\t\t\tconsole.warn( message );\n\t\t} :\n\t\tnoop\n\t;\n\n\tif ( !(curSrcProp in image) ) {\n\t\tcurSrcProp = \"src\";\n\t}\n\n\t// Add support for standard mime types.\n\ttypes[ \"image/jpeg\" ] = true;\n\ttypes[ \"image/gif\" ] = true;\n\ttypes[ \"image/png\" ] = true;\n\n\tfunction detectTypeSupport( type, typeUri ) {\n\t\t// based on Modernizr's lossless img-webp test\n\t\t// note: asynchronous\n\t\tvar image = new window.Image();\n\t\timage.onerror = function() {\n\t\t\ttypes[ type ] = false;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.onload = function() {\n\t\t\ttypes[ type ] = image.width === 1;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.src = typeUri;\n\t\treturn \"pending\";\n\t}\n\n\t// test svg support\n\ttypes[ \"image/svg+xml\" ] = document.implementation.hasFeature( \"http://wwwindow.w3.org/TR/SVG11/feature#Image\", \"1.1\" );\n\n\t/**\n\t * updates the internal vW property with the current viewport width in px\n\t */\n\tfunction updateMetrics() {\n\n\t\tisVwDirty = false;\n\t\tDPR = window.devicePixelRatio;\n\t\tcssCache = {};\n\t\tsizeLengthCache = {};\n\n\t\tpf.DPR = DPR || 1;\n\n\t\tunits.width = Math.max(window.innerWidth || 0, docElem.clientWidth);\n\t\tunits.height = Math.max(window.innerHeight || 0, docElem.clientHeight);\n\n\t\tunits.vw = units.width / 100;\n\t\tunits.vh = units.height / 100;\n\n\t\tevalId = [ units.height, units.width, DPR ].join(\"-\");\n\n\t\tunits.em = pf.getEmValue();\n\t\tunits.rem = units.em;\n\t}\n\n\tfunction chooseLowRes( lowerValue, higherValue, dprValue, isCached ) {\n\t\tvar bonusFactor, tooMuch, bonus, meanDensity;\n\n\t\t//experimental\n\t\tif (cfg.algorithm === \"saveData\" ){\n\t\t\tif ( lowerValue > 2.7 ) {\n\t\t\t\tmeanDensity = dprValue + 1;\n\t\t\t} else {\n\t\t\t\ttooMuch = higherValue - dprValue;\n\t\t\t\tbonusFactor = Math.pow(lowerValue - 0.6, 1.5);\n\n\t\t\t\tbonus = tooMuch * bonusFactor;\n\n\t\t\t\tif (isCached) {\n\t\t\t\t\tbonus += 0.1 * bonusFactor;\n\t\t\t\t}\n\n\t\t\t\tmeanDensity = lowerValue + bonus;\n\t\t\t}\n\t\t} else {\n\t\t\tmeanDensity = (dprValue > 1) ?\n\t\t\t\tMath.sqrt(lowerValue * higherValue) :\n\t\t\t\tlowerValue;\n\t\t}\n\n\t\treturn meanDensity > dprValue;\n\t}\n\n\tfunction applyBestCandidate( img ) {\n\t\tvar srcSetCandidates;\n\t\tvar matchingSet = pf.getSet( img );\n\t\tvar evaluated = false;\n\t\tif ( matchingSet !== \"pending\" ) {\n\t\t\tevaluated = evalId;\n\t\t\tif ( matchingSet ) {\n\t\t\t\tsrcSetCandidates = pf.setRes( matchingSet );\n\t\t\t\tpf.applySetCandidate( srcSetCandidates, img );\n\t\t\t}\n\t\t}\n\t\timg[ pf.ns ].evaled = evaluated;\n\t}\n\n\tfunction ascendingSort( a, b ) {\n\t\treturn a.res - b.res;\n\t}\n\n\tfunction setSrcToCur( img, src, set ) {\n\t\tvar candidate;\n\t\tif ( !set && src ) {\n\t\t\tset = img[ pf.ns ].sets;\n\t\t\tset = set && set[set.length - 1];\n\t\t}\n\n\t\tcandidate = getCandidateForSrc(src, set);\n\n\t\tif ( candidate ) {\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\timg[ pf.ns ].curSrc = src;\n\t\t\timg[ pf.ns ].curCan = candidate;\n\n\t\t\tif ( !candidate.res ) {\n\t\t\t\tsetResolution( candidate, candidate.set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getCandidateForSrc( src, set ) {\n\t\tvar i, candidate, candidates;\n\t\tif ( src && set ) {\n\t\t\tcandidates = pf.parseSet( set );\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\tfor ( i = 0; i < candidates.length; i++ ) {\n\t\t\t\tif ( src === pf.makeUrl(candidates[ i ].url) ) {\n\t\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getAllSourceElements( picture, candidates ) {\n\t\tvar i, len, source, srcset;\n\n\t\t// SPEC mismatch intended for size and perf:\n\t\t// actually only source elements preceding the img should be used\n\t\t// also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector\n\t\tvar sources = picture.getElementsByTagName( \"source\" );\n\n\t\tfor ( i = 0, len = sources.length; i < len; i++ ) {\n\t\t\tsource = sources[ i ];\n\t\t\tsource[ pf.ns ] = true;\n\t\t\tsrcset = source.getAttribute( \"srcset\" );\n\n\t\t\t// if source does not have a srcset attribute, skip\n\t\t\tif ( srcset ) {\n\t\t\t\tcandidates.push( {\n\t\t\t\t\tsrcset: srcset,\n\t\t\t\t\tmedia: source.getAttribute( \"media\" ),\n\t\t\t\t\ttype: source.getAttribute( \"type\" ),\n\t\t\t\t\tsizes: source.getAttribute( \"sizes\" )\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Srcset Parser\n\t * By Alex Bell |  MIT License\n\t *\n\t * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]\n\t *\n\t * Based super duper closely on the reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute\n\t */\n\n\t// 1. Let input be the value passed to this algorithm.\n\t// (TO-DO : Explain what \"set\" argument is here. Maybe choose a more\n\t// descriptive & more searchable name.  Since passing the \"set\" in really has\n\t// nothing to do with parsing proper, I would prefer this assignment eventually\n\t// go in an external fn.)\n\tfunction parseSrcset(input, set) {\n\n\t\tfunction collectCharacters(regEx) {\n\t\t\tvar chars,\n\t\t\t    match = regEx.exec(input.substring(pos));\n\t\t\tif (match) {\n\t\t\t\tchars = match[ 0 ];\n\t\t\t\tpos += chars.length;\n\t\t\t\treturn chars;\n\t\t\t}\n\t\t}\n\n\t\tvar inputLength = input.length,\n\t\t    url,\n\t\t    descriptors,\n\t\t    currentDescriptor,\n\t\t    state,\n\t\t    c,\n\n\t\t    // 2. Let position be a pointer into input, initially pointing at the start\n\t\t    //    of the string.\n\t\t    pos = 0,\n\n\t\t    // 3. Let candidates be an initially empty source set.\n\t\t    candidates = [];\n\n\t\t/**\n\t\t* Adds descriptor properties to a candidate, pushes to the candidates array\n\t\t* @return undefined\n\t\t*/\n\t\t// (Declared outside of the while loop so that it's only created once.\n\t\t// (This fn is defined before it is used, in order to pass JSHINT.\n\t\t// Unfortunately this breaks the sequencing of the spec comments. :/ )\n\t\tfunction parseDescriptors() {\n\n\t\t\t// 9. Descriptor parser: Let error be no.\n\t\t\tvar pError = false,\n\n\t\t\t// 10. Let width be absent.\n\t\t\t// 11. Let density be absent.\n\t\t\t// 12. Let future-compat-h be absent. (We're implementing it now as h)\n\t\t\t    w, d, h, i,\n\t\t\t    candidate = {},\n\t\t\t    desc, lastChar, value, intVal, floatVal;\n\n\t\t\t// 13. For each descriptor in descriptors, run the appropriate set of steps\n\t\t\t// from the following list:\n\t\t\tfor (i = 0 ; i < descriptors.length; i++) {\n\t\t\t\tdesc = descriptors[ i ];\n\n\t\t\t\tlastChar = desc[ desc.length - 1 ];\n\t\t\t\tvalue = desc.substring(0, desc.length - 1);\n\t\t\t\tintVal = parseInt(value, 10);\n\t\t\t\tfloatVal = parseFloat(value);\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0077 LATIN SMALL LETTER W character\n\t\t\t\tif (regexNonNegativeInteger.test(value) && (lastChar === \"w\")) {\n\n\t\t\t\t\t// If width and density are not both absent, then let error be yes.\n\t\t\t\t\tif (w || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes.\n\t\t\t\t\t// Otherwise, let width be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {w = intVal;}\n\n\t\t\t\t// If the descriptor consists of a valid floating-point number followed by\n\t\t\t\t// a U+0078 LATIN SMALL LETTER X character\n\t\t\t\t} else if (regexFloatingPoint.test(value) && (lastChar === \"x\")) {\n\n\t\t\t\t\t// If width, density and future-compat-h are not all absent, then let error\n\t\t\t\t\t// be yes.\n\t\t\t\t\tif (w || d || h) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing floating-point number values to the descriptor.\n\t\t\t\t\t// If the result is less than zero, let error be yes. Otherwise, let density\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (floatVal < 0) {pError = true;} else {d = floatVal;}\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0068 LATIN SMALL LETTER H character\n\t\t\t\t} else if (regexNonNegativeInteger.test(value) && (lastChar === \"h\")) {\n\n\t\t\t\t\t// If height and density are not both absent, then let error be yes.\n\t\t\t\t\tif (h || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes. Otherwise, let future-compat-h\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {h = intVal;}\n\n\t\t\t\t// Anything else, Let error be yes.\n\t\t\t\t} else {pError = true;}\n\t\t\t} // (close step 13 for loop)\n\n\t\t\t// 15. If error is still no, then append a new image source to candidates whose\n\t\t\t// URL is url, associated with a width width if not absent and a pixel\n\t\t\t// density density if not absent. Otherwise, there is a parse error.\n\t\t\tif (!pError) {\n\t\t\t\tcandidate.url = url;\n\n\t\t\t\tif (w) { candidate.w = w;}\n\t\t\t\tif (d) { candidate.d = d;}\n\t\t\t\tif (h) { candidate.h = h;}\n\t\t\t\tif (!h && !d && !w) {candidate.d = 1;}\n\t\t\t\tif (candidate.d === 1) {set.has1x = true;}\n\t\t\t\tcandidate.set = set;\n\n\t\t\t\tcandidates.push(candidate);\n\t\t\t}\n\t\t} // (close parseDescriptors fn)\n\n\t\t/**\n\t\t* Tokenizes descriptor properties prior to parsing\n\t\t* Returns undefined.\n\t\t* (Again, this fn is defined before it is used, in order to pass JSHINT.\n\t\t* Unfortunately this breaks the logical sequencing of the spec comments. :/ )\n\t\t*/\n\t\tfunction tokenize() {\n\n\t\t\t// 8.1. Descriptor tokeniser: Skip whitespace\n\t\t\tcollectCharacters(regexLeadingSpaces);\n\n\t\t\t// 8.2. Let current descriptor be the empty string.\n\t\t\tcurrentDescriptor = \"\";\n\n\t\t\t// 8.3. Let state be in descriptor.\n\t\t\tstate = \"in descriptor\";\n\n\t\t\twhile (true) {\n\n\t\t\t\t// 8.4. Let c be the character at position.\n\t\t\t\tc = input.charAt(pos);\n\n\t\t\t\t//  Do the following depending on the value of state.\n\t\t\t\t//  For the purpose of this step, \"EOF\" is a special character representing\n\t\t\t\t//  that position is past the end of input.\n\n\t\t\t\t// In descriptor\n\t\t\t\tif (state === \"in descriptor\") {\n\t\t\t\t\t// Do the following, depending on the value of c:\n\n\t\t\t\t  // Space character\n\t\t\t\t  // If current descriptor is not empty, append current descriptor to\n\t\t\t\t  // descriptors and let current descriptor be the empty string.\n\t\t\t\t  // Set state to after descriptor.\n\t\t\t\t\tif (isSpace(c)) {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t\tcurrentDescriptor = \"\";\n\t\t\t\t\t\t\tstate = \"after descriptor\";\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// U+002C COMMA (,)\n\t\t\t\t\t// Advance position to the next character in input. If current descriptor\n\t\t\t\t\t// is not empty, append current descriptor to descriptors. Jump to the step\n\t\t\t\t\t// labeled descriptor parser.\n\t\t\t\t\t} else if (c === \",\") {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// U+0028 LEFT PARENTHESIS (()\n\t\t\t\t\t// Append c to current descriptor. Set state to in parens.\n\t\t\t\t\t} else if (c === \"\\u0028\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in parens\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t// descriptors. Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\t\t\t\t// (end \"in descriptor\"\n\n\t\t\t\t// In parens\n\t\t\t\t} else if (state === \"in parens\") {\n\n\t\t\t\t\t// U+0029 RIGHT PARENTHESIS ())\n\t\t\t\t\t// Append c to current descriptor. Set state to in descriptor.\n\t\t\t\t\tif (c === \")\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in descriptor\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// Append current descriptor to descriptors. Jump to the step labeled\n\t\t\t\t\t// descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\n\t\t\t\t// After descriptor\n\t\t\t\t} else if (state === \"after descriptor\") {\n\n\t\t\t\t\t// Do the following, depending on the value of c:\n\t\t\t\t\t// Space character: Stay in this state.\n\t\t\t\t\tif (isSpace(c)) {\n\n\t\t\t\t\t// EOF: Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Set state to in descriptor. Set position to the previous character in input.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = \"in descriptor\";\n\t\t\t\t\t\tpos -= 1;\n\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Advance position to the next character in input.\n\t\t\t\tpos += 1;\n\n\t\t\t// Repeat this step.\n\t\t\t} // (close while true loop)\n\t\t}\n\n\t\t// 4. Splitting loop: Collect a sequence of characters that are space\n\t\t//    characters or U+002C COMMA characters. If any U+002C COMMA characters\n\t\t//    were collected, that is a parse error.\n\t\twhile (true) {\n\t\t\tcollectCharacters(regexLeadingCommasOrSpaces);\n\n\t\t\t// 5. If position is past the end of input, return candidates and abort these steps.\n\t\t\tif (pos >= inputLength) {\n\t\t\t\treturn candidates; // (we're done, this is the sole return path)\n\t\t\t}\n\n\t\t\t// 6. Collect a sequence of characters that are not space characters,\n\t\t\t//    and let that be url.\n\t\t\turl = collectCharacters(regexLeadingNotSpaces);\n\n\t\t\t// 7. Let descriptors be a new empty list.\n\t\t\tdescriptors = [];\n\n\t\t\t// 8. If url ends with a U+002C COMMA character (,), follow these substeps:\n\t\t\t//\t\t(1). Remove all trailing U+002C COMMA characters from url. If this removed\n\t\t\t//         more than one character, that is a parse error.\n\t\t\tif (url.slice(-1) === \",\") {\n\t\t\t\turl = url.replace(regexTrailingCommas, \"\");\n\t\t\t\t// (Jump ahead to step 9 to skip tokenization and just push the candidate).\n\t\t\t\tparseDescriptors();\n\n\t\t\t//\tOtherwise, follow these substeps:\n\t\t\t} else {\n\t\t\t\ttokenize();\n\t\t\t} // (close else of step 8)\n\n\t\t// 16. Return to the step labeled splitting loop.\n\t\t} // (Close of big while loop.)\n\t}\n\n\t/*\n\t * Sizes Parser\n\t *\n\t * By Alex Bell |  MIT License\n\t *\n\t * Non-strict but accurate and lightweight JS Parser for the string value <img sizes=\"here\">\n\t *\n\t * Reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute\n\t *\n\t * Most comments are copied in directly from the spec\n\t * (except for comments in parens).\n\t *\n\t * Grammar is:\n\t * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>\n\t * <source-size> = <media-condition> <source-size-value>\n\t * <source-size-value> = <length>\n\t * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes\n\t *\n\t * E.g. \"(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw\"\n\t * or \"(min-width: 30em), calc(30vw - 15px)\" or just \"30vw\"\n\t *\n\t * Returns the first valid <css-length> with a media condition that evaluates to true,\n\t * or \"100vw\" if all valid media conditions evaluate to false.\n\t *\n\t */\n\n\tfunction parseSizes(strValue) {\n\n\t\t// (Percentage CSS lengths are not allowed in this case, to avoid confusion:\n\t\t// https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list\n\t\t// CSS allows a single optional plus or minus sign:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#numbers\n\t\t// CSS is ASCII case-insensitive:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#characters )\n\t\t// Spec allows exponential notation for <number> type:\n\t\t// http://dev.w3.org/csswg/css-values/#numbers\n\t\tvar regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i;\n\n\t\t// (This is a quick and lenient test. Because of optional unlimited-depth internal\n\t\t// grouping parens and strict spacing rules, this could get very complicated.)\n\t\tvar regexCssCalc = /^calc\\((?:[0-9a-z \\.\\+\\-\\*\\/\\(\\)]+)\\)$/i;\n\n\t\tvar i;\n\t\tvar unparsedSizesList;\n\t\tvar unparsedSizesListLength;\n\t\tvar unparsedSize;\n\t\tvar lastComponentValue;\n\t\tvar size;\n\n\t\t// UTILITY FUNCTIONS\n\n\t\t//  (Toy CSS parser. The goals here are:\n\t\t//  1) expansive test coverage without the weight of a full CSS parser.\n\t\t//  2) Avoiding regex wherever convenient.\n\t\t//  Quick tests: http://jsfiddle.net/gtntL4gr/3/\n\t\t//  Returns an array of arrays.)\n\t\tfunction parseComponentValues(str) {\n\t\t\tvar chrctr;\n\t\t\tvar component = \"\";\n\t\t\tvar componentArray = [];\n\t\t\tvar listArray = [];\n\t\t\tvar parenDepth = 0;\n\t\t\tvar pos = 0;\n\t\t\tvar inComment = false;\n\n\t\t\tfunction pushComponent() {\n\t\t\t\tif (component) {\n\t\t\t\t\tcomponentArray.push(component);\n\t\t\t\t\tcomponent = \"\";\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction pushComponentArray() {\n\t\t\t\tif (componentArray[0]) {\n\t\t\t\t\tlistArray.push(componentArray);\n\t\t\t\t\tcomponentArray = [];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// (Loop forwards from the beginning of the string.)\n\t\t\twhile (true) {\n\t\t\t\tchrctr = str.charAt(pos);\n\n\t\t\t\tif (chrctr === \"\") { // ( End of string reached.)\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\treturn listArray;\n\t\t\t\t} else if (inComment) {\n\t\t\t\t\tif ((chrctr === \"*\") && (str[pos + 1] === \"/\")) { // (At end of a comment.)\n\t\t\t\t\t\tinComment = false;\n\t\t\t\t\t\tpos += 2;\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpos += 1; // (Skip all characters inside comments.)\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t} else if (isSpace(chrctr)) {\n\t\t\t\t\t// (If previous character in loop was also a space, or if\n\t\t\t\t\t// at the beginning of the string, do not add space char to\n\t\t\t\t\t// component.)\n\t\t\t\t\tif ( (str.charAt(pos - 1) && isSpace( str.charAt(pos - 1) ) ) || !component ) {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (parenDepth === 0) {\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tpos +=1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// (Replace any space character with a plain space for legibility.)\n\t\t\t\t\t\tchrctr = \" \";\n\t\t\t\t\t}\n\t\t\t\t} else if (chrctr === \"(\") {\n\t\t\t\t\tparenDepth += 1;\n\t\t\t\t} else if (chrctr === \")\") {\n\t\t\t\t\tparenDepth -= 1;\n\t\t\t\t} else if (chrctr === \",\") {\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\tpos += 1;\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if ( (chrctr === \"/\") && (str.charAt(pos + 1) === \"*\") ) {\n\t\t\t\t\tinComment = true;\n\t\t\t\t\tpos += 2;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tcomponent = component + chrctr;\n\t\t\t\tpos += 1;\n\t\t\t}\n\t\t}\n\n\t\tfunction isValidNonNegativeSourceSizeValue(s) {\n\t\t\tif (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {return true;}\n\t\t\tif (regexCssCalc.test(s)) {return true;}\n\t\t\t// ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:\n\t\t\t// \"-0 is equivalent to 0 and is not a negative number.\" which means that\n\t\t\t// unitless zero and unitless negative zero must be accepted as special cases.)\n\t\t\tif ((s === \"0\") || (s === \"-0\") || (s === \"+0\")) {return true;}\n\t\t\treturn false;\n\t\t}\n\n\t\t// When asked to parse a sizes attribute from an element, parse a\n\t\t// comma-separated list of component values from the value of the element's\n\t\t// sizes attribute (or the empty string, if the attribute is absent), and let\n\t\t// unparsed sizes list be the result.\n\t\t// http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values\n\n\t\tunparsedSizesList = parseComponentValues(strValue);\n\t\tunparsedSizesListLength = unparsedSizesList.length;\n\n\t\t// For each unparsed size in unparsed sizes list:\n\t\tfor (i = 0; i < unparsedSizesListLength; i++) {\n\t\t\tunparsedSize = unparsedSizesList[i];\n\n\t\t\t// 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.\n\t\t\t// ( parseComponentValues() already omits spaces outside of parens. )\n\n\t\t\t// If unparsed size is now empty, that is a parse error; continue to the next\n\t\t\t// iteration of this algorithm.\n\t\t\t// ( parseComponentValues() won't push an empty array. )\n\n\t\t\t// 2. If the last component value in unparsed size is a valid non-negative\n\t\t\t// <source-size-value>, let size be its value and remove the component value\n\t\t\t// from unparsed size. Any CSS function other than the calc() function is\n\t\t\t// invalid. Otherwise, there is a parse error; continue to the next iteration\n\t\t\t// of this algorithm.\n\t\t\t// http://dev.w3.org/csswg/css-syntax/#parse-component-value\n\t\t\tlastComponentValue = unparsedSize[unparsedSize.length - 1];\n\n\t\t\tif (isValidNonNegativeSourceSizeValue(lastComponentValue)) {\n\t\t\t\tsize = lastComponentValue;\n\t\t\t\tunparsedSize.pop();\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 3. Remove all consecutive <whitespace-token>s from the end of unparsed\n\t\t\t// size. If unparsed size is now empty, return size and exit this algorithm.\n\t\t\t// If this was not the last item in unparsed sizes list, that is a parse error.\n\t\t\tif (unparsedSize.length === 0) {\n\t\t\t\treturn size;\n\t\t\t}\n\n\t\t\t// 4. Parse the remaining component values in unparsed size as a\n\t\t\t// <media-condition>. If it does not parse correctly, or it does parse\n\t\t\t// correctly but the <media-condition> evaluates to false, continue to the\n\t\t\t// next iteration of this algorithm.\n\t\t\t// (Parsing all possible compound media conditions in JS is heavy, complicated,\n\t\t\t// and the payoff is unclear. Is there ever an situation where the\n\t\t\t// media condition parses incorrectly but still somehow evaluates to true?\n\t\t\t// Can we just rely on the browser/polyfill to do it?)\n\t\t\tunparsedSize = unparsedSize.join(\" \");\n\t\t\tif (!(pf.matchesMedia( unparsedSize ) ) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 5. Return size and exit this algorithm.\n\t\t\treturn size;\n\t\t}\n\n\t\t// If the above algorithm exhausts unparsed sizes list without returning a\n\t\t// size value, return 100vw.\n\t\treturn \"100vw\";\n\t}\n\n\t// namespace\n\tpf.ns = (\"pf\" + new Date().getTime()).substr(0, 9);\n\n\t// srcset support test\n\tpf.supSrcset = \"srcset\" in image;\n\tpf.supSizes = \"sizes\" in image;\n\tpf.supPicture = !!window.HTMLPictureElement;\n\n\tif (pf.supSrcset && pf.supPicture && !pf.supSizes) {\n\t\t(function(image2) {\n\t\t\timage.srcset = \"data:,a\";\n\t\t\timage2.src = \"data:,a\";\n\t\t\tpf.supSrcset = image.complete === image2.complete;\n\t\t\tpf.supPicture = pf.supSrcset && pf.supPicture;\n\t\t})(document.createElement(\"img\"));\n\t}\n\n\t// using pf.qsa instead of dom traversing does scale much better,\n\t// especially on sites mixing responsive and non-responsive images\n\tpf.selShort = \"picture>img,img[srcset]\";\n\tpf.sel = pf.selShort;\n\tpf.cfg = cfg;\n\n\tif ( pf.supSrcset ) {\n\t\tpf.sel += \",img[\" + srcsetAttr + \"]\";\n\t}\n\n\t/**\n\t * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )\n\t */\n\tpf.DPR = (DPR  || 1 );\n\tpf.u = units;\n\n\t// container of supported mime types that one might need to qualify before using\n\tpf.types =  types;\n\n\talwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;\n\n\tpf.setSize = noop;\n\n\t/**\n\t * Gets a string and returns the absolute URL\n\t * @param src\n\t * @returns {String} absolute URL\n\t */\n\n\tpf.makeUrl = memoize(function(src) {\n\t\tanchor.href = src;\n\t\treturn anchor.href;\n\t});\n\n\t/**\n\t * Gets a DOM element or document and a selctor and returns the found matches\n\t * Can be extended with jQuery/Sizzle for IE7 support\n\t * @param context\n\t * @param sel\n\t * @returns {NodeList}\n\t */\n\tpf.qsa = function(context, sel) {\n\t\treturn context.querySelectorAll(sel);\n\t};\n\n\t/**\n\t * Shortcut method for matchMedia ( for easy overriding in tests )\n\t * wether native or pf.mMQ is used will be decided lazy on first call\n\t * @returns {boolean}\n\t */\n\tpf.matchesMedia = function() {\n\t\tif ( window.matchMedia && (matchMedia( \"(min-width: 0.1em)\" ) || {}).matches ) {\n\t\t\tpf.matchesMedia = function( media ) {\n\t\t\t\treturn !media || ( matchMedia( media ).matches );\n\t\t\t};\n\t\t} else {\n\t\t\tpf.matchesMedia = pf.mMQ;\n\t\t}\n\n\t\treturn pf.matchesMedia.apply( this, arguments );\n\t};\n\n\t/**\n\t * A simplified matchMedia implementation for IE8 and IE9\n\t * handles only min-width/max-width with px or em values\n\t * @param media\n\t * @returns {boolean}\n\t */\n\tpf.mMQ = function( media ) {\n\t\treturn media ? evalCSS(media) : true;\n\t};\n\n\t/**\n\t * Returns the calculated length in css pixel from the given sourceSizeValue\n\t * http://dev.w3.org/csswg/css-values-3/#length-value\n\t * intended Spec mismatches:\n\t * * Does not check for invalid use of CSS functions\n\t * * Does handle a computed length of 0 the same as a negative and therefore invalid value\n\t * @param sourceSizeValue\n\t * @returns {Number}\n\t */\n\tpf.calcLength = function( sourceSizeValue ) {\n\n\t\tvar value = evalCSS(sourceSizeValue, true) || false;\n\t\tif (value < 0) {\n\t\t\tvalue = false;\n\t\t}\n\n\t\treturn value;\n\t};\n\n\t/**\n\t * Takes a type string and checks if its supported\n\t */\n\n\tpf.supportsType = function( type ) {\n\t\treturn ( type ) ? types[ type ] : true;\n\t};\n\n\t/**\n\t * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)\n\t * @param sourceSizeStr\n\t * @returns {*}\n\t */\n\tpf.parseSize = memoize(function( sourceSizeStr ) {\n\t\tvar match = ( sourceSizeStr || \"\" ).match(regSize);\n\t\treturn {\n\t\t\tmedia: match && match[1],\n\t\t\tlength: match && match[2]\n\t\t};\n\t});\n\n\tpf.parseSet = function( set ) {\n\t\tif ( !set.cands ) {\n\t\t\tset.cands = parseSrcset(set.srcset, set);\n\t\t}\n\t\treturn set.cands;\n\t};\n\n\t/**\n\t * returns 1em in css px for html/body default size\n\t * function taken from respondjs\n\t * @returns {*|number}\n\t */\n\tpf.getEmValue = function() {\n\t\tvar body;\n\t\tif ( !eminpx && (body = document.body) ) {\n\t\t\tvar div = document.createElement( \"div\" ),\n\t\t\t\toriginalHTMLCSS = docElem.style.cssText,\n\t\t\t\toriginalBodyCSS = body.style.cssText;\n\n\t\t\tdiv.style.cssText = baseStyle;\n\n\t\t\t// 1em in a media query is the value of the default font size of the browser\n\t\t\t// reset docElem and body to ensure the correct value is returned\n\t\t\tdocElem.style.cssText = fsCss;\n\t\t\tbody.style.cssText = fsCss;\n\n\t\t\tbody.appendChild( div );\n\t\t\teminpx = div.offsetWidth;\n\t\t\tbody.removeChild( div );\n\n\t\t\t//also update eminpx before returning\n\t\t\teminpx = parseFloat( eminpx, 10 );\n\n\t\t\t// restore the original values\n\t\t\tdocElem.style.cssText = originalHTMLCSS;\n\t\t\tbody.style.cssText = originalBodyCSS;\n\n\t\t}\n\t\treturn eminpx || 16;\n\t};\n\n\t/**\n\t * Takes a string of sizes and returns the width in pixels as a number\n\t */\n\tpf.calcListLength = function( sourceSizeListStr ) {\n\t\t// Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%\n\t\t//\n\t\t//                           or (min-width:30em) calc(30% - 15px)\n\t\tif ( !(sourceSizeListStr in sizeLengthCache) || cfg.uT ) {\n\t\t\tvar winningLength = pf.calcLength( parseSizes( sourceSizeListStr ) );\n\n\t\t\tsizeLengthCache[ sourceSizeListStr ] = !winningLength ? units.width : winningLength;\n\t\t}\n\n\t\treturn sizeLengthCache[ sourceSizeListStr ];\n\t};\n\n\t/**\n\t * Takes a candidate object with a srcset property in the form of url/\n\t * ex. \"images/pic-medium.png 1x, images/pic-medium-2x.png 2x\" or\n\t *     \"images/pic-medium.png 400w, images/pic-medium-2x.png 800w\" or\n\t *     \"images/pic-small.png\"\n\t * Get an array of image candidates in the form of\n\t *      {url: \"/foo/bar.png\", resolution: 1}\n\t * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value\n\t * If sizes is specified, res is calculated\n\t */\n\tpf.setRes = function( set ) {\n\t\tvar candidates;\n\t\tif ( set ) {\n\n\t\t\tcandidates = pf.parseSet( set );\n\n\t\t\tfor ( var i = 0, len = candidates.length; i < len; i++ ) {\n\t\t\t\tsetResolution( candidates[ i ], set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidates;\n\t};\n\n\tpf.setRes.res = setResolution;\n\n\tpf.applySetCandidate = function( candidates, img ) {\n\t\tif ( !candidates.length ) {return;}\n\t\tvar candidate,\n\t\t\ti,\n\t\t\tj,\n\t\t\tlength,\n\t\t\tbestCandidate,\n\t\t\tcurSrc,\n\t\t\tcurCan,\n\t\t\tcandidateSrc,\n\t\t\tabortCurSrc;\n\n\t\tvar imageData = img[ pf.ns ];\n\t\tvar dpr = pf.DPR;\n\n\t\tcurSrc = imageData.curSrc || img[curSrcProp];\n\n\t\tcurCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);\n\n\t\t// if we have a current source, we might either become lazy or give this source some advantage\n\t\tif ( curCan && curCan.set === candidates[ 0 ].set ) {\n\n\t\t\t// if browser can abort image request and the image has a higher pixel density than needed\n\t\t\t// and this image isn't downloaded yet, we skip next part and try to save bandwidth\n\t\t\tabortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);\n\n\t\t\tif ( !abortCurSrc ) {\n\t\t\t\tcurCan.cached = true;\n\n\t\t\t\t// if current candidate is \"best\", \"better\" or \"okay\",\n\t\t\t\t// set it to bestCandidate\n\t\t\t\tif ( curCan.res >= dpr ) {\n\t\t\t\t\tbestCandidate = curCan;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( !bestCandidate ) {\n\n\t\t\tcandidates.sort( ascendingSort );\n\n\t\t\tlength = candidates.length;\n\t\t\tbestCandidate = candidates[ length - 1 ];\n\n\t\t\tfor ( i = 0; i < length; i++ ) {\n\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\tif ( candidate.res >= dpr ) {\n\t\t\t\t\tj = i - 1;\n\n\t\t\t\t\t// we have found the perfect candidate,\n\t\t\t\t\t// but let's improve this a little bit with some assumptions ;-)\n\t\t\t\t\tif (candidates[ j ] &&\n\t\t\t\t\t\t(abortCurSrc || curSrc !== pf.makeUrl( candidate.url )) &&\n\t\t\t\t\t\tchooseLowRes(candidates[ j ].res, candidate.res, dpr, candidates[ j ].cached)) {\n\n\t\t\t\t\t\tbestCandidate = candidates[ j ];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbestCandidate = candidate;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( bestCandidate ) {\n\n\t\t\tcandidateSrc = pf.makeUrl( bestCandidate.url );\n\n\t\t\timageData.curSrc = candidateSrc;\n\t\t\timageData.curCan = bestCandidate;\n\n\t\t\tif ( candidateSrc !== curSrc ) {\n\t\t\t\tpf.setSrc( img, bestCandidate );\n\t\t\t}\n\t\t\tpf.setSize( img );\n\t\t}\n\t};\n\n\tpf.setSrc = function( img, bestCandidate ) {\n\t\tvar origWidth;\n\t\timg.src = bestCandidate.url;\n\n\t\t// although this is a specific Safari issue, we don't want to take too much different code paths\n\t\tif ( bestCandidate.set.type === \"image/svg+xml\" ) {\n\t\t\torigWidth = img.style.width;\n\t\t\timg.style.width = (img.offsetWidth + 1) + \"px\";\n\n\t\t\t// next line only should trigger a repaint\n\t\t\t// if... is only done to trick dead code removal\n\t\t\tif ( img.offsetWidth + 1 ) {\n\t\t\t\timg.style.width = origWidth;\n\t\t\t}\n\t\t}\n\t};\n\n\tpf.getSet = function( img ) {\n\t\tvar i, set, supportsType;\n\t\tvar match = false;\n\t\tvar sets = img [ pf.ns ].sets;\n\n\t\tfor ( i = 0; i < sets.length && !match; i++ ) {\n\t\t\tset = sets[i];\n\n\t\t\tif ( !set.srcset || !pf.matchesMedia( set.media ) || !(supportsType = pf.supportsType( set.type )) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( supportsType === \"pending\" ) {\n\t\t\t\tset = supportsType;\n\t\t\t}\n\n\t\t\tmatch = set;\n\t\t\tbreak;\n\t\t}\n\n\t\treturn match;\n\t};\n\n\tpf.parseSets = function( element, parent, options ) {\n\t\tvar srcsetAttribute, imageSet, isWDescripor, srcsetParsed;\n\n\t\tvar hasPicture = parent && parent.nodeName.toUpperCase() === \"PICTURE\";\n\t\tvar imageData = element[ pf.ns ];\n\n\t\tif ( imageData.src === undefined || options.src ) {\n\t\t\timageData.src = getImgAttr.call( element, \"src\" );\n\t\t\tif ( imageData.src ) {\n\t\t\t\tsetImgAttr.call( element, srcAttr, imageData.src );\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcAttr );\n\t\t\t}\n\t\t}\n\n\t\tif ( imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset ) {\n\t\t\tsrcsetAttribute = getImgAttr.call( element, \"srcset\" );\n\t\t\timageData.srcset = srcsetAttribute;\n\t\t\tsrcsetParsed = true;\n\t\t}\n\n\t\timageData.sets = [];\n\n\t\tif ( hasPicture ) {\n\t\t\timageData.pic = true;\n\t\t\tgetAllSourceElements( parent, imageData.sets );\n\t\t}\n\n\t\tif ( imageData.srcset ) {\n\t\t\timageSet = {\n\t\t\t\tsrcset: imageData.srcset,\n\t\t\t\tsizes: getImgAttr.call( element, \"sizes\" )\n\t\t\t};\n\n\t\t\timageData.sets.push( imageSet );\n\n\t\t\tisWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || \"\");\n\n\t\t\t// add normal src as candidate, if source has no w descriptor\n\t\t\tif ( !isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x ) {\n\t\t\t\timageSet.srcset += \", \" + imageData.src;\n\t\t\t\timageSet.cands.push({\n\t\t\t\t\turl: imageData.src,\n\t\t\t\t\td: 1,\n\t\t\t\t\tset: imageSet\n\t\t\t\t});\n\t\t\t}\n\n\t\t} else if ( imageData.src ) {\n\t\t\timageData.sets.push( {\n\t\t\t\tsrcset: imageData.src,\n\t\t\t\tsizes: null\n\t\t\t} );\n\t\t}\n\n\t\timageData.curCan = null;\n\t\timageData.curSrc = undefined;\n\n\t\t// if img has picture or the srcset was removed or has a srcset and does not support srcset at all\n\t\t// or has a w descriptor (and does not support sizes) set support to false to evaluate\n\t\timageData.supported = !( hasPicture || ( imageSet && !pf.supSrcset ) || isWDescripor );\n\n\t\tif ( srcsetParsed && pf.supSrcset && !imageData.supported ) {\n\t\t\tif ( srcsetAttribute ) {\n\t\t\t\tsetImgAttr.call( element, srcsetAttr, srcsetAttribute );\n\t\t\t\telement.srcset = \"\";\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcsetAttr );\n\t\t\t}\n\t\t}\n\n\t\tif (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) ||  element.src !== pf.makeUrl(imageData.src))) {\n\t\t\tif (imageData.src === null) {\n\t\t\t\telement.removeAttribute(\"src\");\n\t\t\t} else {\n\t\t\t\telement.src = imageData.src;\n\t\t\t}\n\t\t}\n\n\t\timageData.parsed = true;\n\t};\n\n\tpf.fillImg = function(element, options) {\n\t\tvar imageData;\n\t\tvar extreme = options.reselect || options.reevaluate;\n\n\t\t// expando for caching data on the img\n\t\tif ( !element[ pf.ns ] ) {\n\t\t\telement[ pf.ns ] = {};\n\t\t}\n\n\t\timageData = element[ pf.ns ];\n\n\t\t// if the element has already been evaluated, skip it\n\t\t// unless `options.reevaluate` is set to true ( this, for example,\n\t\t// is set to true when running `picturefill` on `resize` ).\n\t\tif ( !extreme && imageData.evaled === evalId ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( !imageData.parsed || options.reevaluate ) {\n\t\t\tpf.parseSets( element, element.parentNode, options );\n\t\t}\n\n\t\tif ( !imageData.supported ) {\n\t\t\tapplyBestCandidate( element );\n\t\t} else {\n\t\t\timageData.evaled = evalId;\n\t\t}\n\t};\n\n\tpf.setupRun = function() {\n\t\tif ( !alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio) ) {\n\t\t\tupdateMetrics();\n\t\t}\n\t};\n\n\t// If picture is supported, well, that's awesome.\n\tif ( pf.supPicture ) {\n\t\tpicturefill = noop;\n\t\tpf.fillImg = noop;\n\t} else {\n\n\t\t // Set up picture polyfill by polling the document\n\t\t(function() {\n\t\t\tvar isDomReady;\n\t\t\tvar regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;\n\n\t\t\tvar run = function() {\n\t\t\t\tvar readyState = document.readyState || \"\";\n\n\t\t\t\ttimerId = setTimeout(run, readyState === \"loading\" ? 200 :  999);\n\t\t\t\tif ( document.body ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t\tisDomReady = isDomReady || regReady.test(readyState);\n\t\t\t\t\tif ( isDomReady ) {\n\t\t\t\t\t\tclearTimeout( timerId );\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar timerId = setTimeout(run, document.body ? 9 : 99);\n\n\t\t\t// Also attach picturefill on resize and readystatechange\n\t\t\t// http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html\n\t\t\tvar debounce = function(func, wait) {\n\t\t\t\tvar timeout, timestamp;\n\t\t\t\tvar later = function() {\n\t\t\t\t\tvar last = (new Date()) - timestamp;\n\n\t\t\t\t\tif (last < wait) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait - last);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttimeout = null;\n\t\t\t\t\t\tfunc();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\treturn function() {\n\t\t\t\t\ttimestamp = new Date();\n\n\t\t\t\t\tif (!timeout) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t\tvar lastClientWidth = docElem.clientHeight;\n\t\t\tvar onResize = function() {\n\t\t\t\tisVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;\n\t\t\t\tlastClientWidth = docElem.clientHeight;\n\t\t\t\tif ( isVwDirty ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ton( window, \"resize\", debounce(onResize, 99 ) );\n\t\t\ton( document, \"readystatechange\", run );\n\t\t})();\n\t}\n\n\tpf.picturefill = picturefill;\n\t//use this internally for easy monkey patching/performance testing\n\tpf.fillImgs = picturefill;\n\tpf.teardownRun = noop;\n\n\t/* expose methods for testing */\n\tpicturefill._ = pf;\n\n\twindow.picturefillCFG = {\n\t\tpf: pf,\n\t\tpush: function(args) {\n\t\t\tvar name = args.shift();\n\t\t\tif (typeof pf[name] === \"function\") {\n\t\t\t\tpf[name].apply(pf, args);\n\t\t\t} else {\n\t\t\t\tcfg[name] = args[0];\n\t\t\t\tif (alreadyRun) {\n\t\t\t\t\tpf.fillImgs( { reselect: true } );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\twhile (setOptions && setOptions.length) {\n\t\twindow.picturefillCFG.push(setOptions.shift());\n\t}\n\n\t/* expose picturefill */\n\twindow.picturefill = picturefill;\n\n\t/* expose picturefill */\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// CommonJS, just export\n\t\tmodule.exports = picturefill;\n\t} else if ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD support\n\t\tdefine( \"picturefill\", function() { return picturefill; } );\n\t}\n\n\t// IE8 evals this sync, so it must be the last thing we do\n\tif ( !pf.supPicture ) {\n\t\ttypes[ \"image/webp\" ] = detectTypeSupport(\"image/webp\", \"data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==\" );\n\t}\n\n} )( window, document );\n","/*!\n * Stickyfill -- `position: sticky` polyfill\n * v. 1.1.3 | https://github.com/wilddeer/stickyfill\n * Copyright Oleg Korsunsky | http://wd.dizaina.net/\n *\n * MIT License\n */\n(function(doc, win) {\n    var watchArray = [],\n        scroll,\n        initialized = false,\n        html = doc.documentElement,\n        noop = function() {},\n        checkTimer,\n\n        //visibility API strings\n        hiddenPropertyName = 'hidden',\n        visibilityChangeEventName = 'visibilitychange';\n\n    //fallback to prefixed names in old webkit browsers\n    if (doc.webkitHidden !== undefined) {\n        hiddenPropertyName = 'webkitHidden';\n        visibilityChangeEventName = 'webkitvisibilitychange';\n    }\n\n    //test getComputedStyle\n    if (!win.getComputedStyle) {\n        seppuku();\n    }\n\n    //test for native support\n    var prefixes = ['', '-webkit-', '-moz-', '-ms-'],\n        block = document.createElement('div');\n\n    for (var i = prefixes.length - 1; i >= 0; i--) {\n        try {\n            block.style.position = prefixes[i] + 'sticky';\n        }\n        catch(e) {}\n        if (block.style.position != '') {\n            seppuku();\n        }\n    }\n\n    updateScrollPos();\n\n    //commit seppuku!\n    function seppuku() {\n        init = add = rebuild = pause = stop = kill = noop;\n    }\n\n    function mergeObjects(targetObj, sourceObject) {\n        for (var key in sourceObject) {\n            if (sourceObject.hasOwnProperty(key)) {\n                targetObj[key] = sourceObject[key];\n            }\n        }\n    }\n\n    function parseNumeric(val) {\n        return parseFloat(val) || 0;\n    }\n\n    function updateScrollPos() {\n        scroll = {\n            top: win.pageYOffset,\n            left: win.pageXOffset\n        };\n    }\n\n    function onScroll() {\n        if (win.pageXOffset != scroll.left) {\n            updateScrollPos();\n            rebuild();\n            return;\n        }\n\n        if (win.pageYOffset != scroll.top) {\n            updateScrollPos();\n            recalcAllPos();\n        }\n    }\n\n    //fixes flickering\n    function onWheel(event) {\n        setTimeout(function() {\n            if (win.pageYOffset != scroll.top) {\n                scroll.top = win.pageYOffset;\n                recalcAllPos();\n            }\n        }, 0);\n    }\n\n    function recalcAllPos() {\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            recalcElementPos(watchArray[i]);\n        }\n    }\n\n    function recalcElementPos(el) {\n        if (!el.inited) return;\n\n        var currentMode = (scroll.top <= el.limit.start? 0: scroll.top >= el.limit.end? 2: 1);\n\n        if (el.mode != currentMode) {\n            switchElementMode(el, currentMode);\n        }\n    }\n\n    //checks whether stickies start or stop positions have changed\n    function fastCheck() {\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            if (!watchArray[i].inited) continue;\n\n            var deltaTop = Math.abs(getDocOffsetTop(watchArray[i].clone) - watchArray[i].docOffsetTop),\n                deltaHeight = Math.abs(watchArray[i].parent.node.offsetHeight - watchArray[i].parent.height);\n\n            if (deltaTop >= 2 || deltaHeight >= 2) return false;\n        }\n        return true;\n    }\n\n    function initElement(el) {\n        if (isNaN(parseFloat(el.computed.top)) || el.isCell || el.computed.display == 'none') return;\n\n        el.inited = true;\n\n        if (!el.clone) clone(el);\n        if (el.parent.computed.position != 'absolute' &&\n            el.parent.computed.position != 'relative') el.parent.node.style.position = 'relative';\n\n        recalcElementPos(el);\n\n        el.parent.height = el.parent.node.offsetHeight;\n        el.docOffsetTop = getDocOffsetTop(el.clone);\n    }\n\n    function deinitElement(el) {\n        var deinitParent = true;\n\n        el.clone && killClone(el);\n        mergeObjects(el.node.style, el.css);\n\n        //check whether element's parent is used by other stickies\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            if (watchArray[i].node !== el.node && watchArray[i].parent.node === el.parent.node) {\n                deinitParent = false;\n                break;\n            }\n        };\n\n        if (deinitParent) el.parent.node.style.position = el.parent.css.position;\n        el.mode = -1;\n    }\n\n    function initAll() {\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            initElement(watchArray[i]);\n        }\n    }\n\n    function deinitAll() {\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            deinitElement(watchArray[i]);\n        }\n    }\n\n    function switchElementMode(el, mode) {\n        var nodeStyle = el.node.style;\n\n        switch (mode) {\n            case 0:\n                nodeStyle.position = 'absolute';\n                nodeStyle.left = el.offset.left + 'px';\n                nodeStyle.right = el.offset.right + 'px';\n                nodeStyle.top = el.offset.top + 'px';\n                nodeStyle.bottom = 'auto';\n                nodeStyle.width = 'auto';\n                nodeStyle.marginLeft = 0;\n                nodeStyle.marginRight = 0;\n                nodeStyle.marginTop = 0;\n                break;\n\n            case 1:\n                nodeStyle.position = 'fixed';\n                nodeStyle.left = el.box.left + 'px';\n                nodeStyle.right = el.box.right + 'px';\n                nodeStyle.top = el.css.top;\n                nodeStyle.bottom = 'auto';\n                nodeStyle.width = 'auto';\n                nodeStyle.marginLeft = 0;\n                nodeStyle.marginRight = 0;\n                nodeStyle.marginTop = 0;\n                break;\n\n            case 2:\n                nodeStyle.position = 'absolute';\n                nodeStyle.left = el.offset.left + 'px';\n                nodeStyle.right = el.offset.right + 'px';\n                nodeStyle.top = 'auto';\n                nodeStyle.bottom = 0;\n                nodeStyle.width = 'auto';\n                nodeStyle.marginLeft = 0;\n                nodeStyle.marginRight = 0;\n                break;\n        }\n\n        el.mode = mode;\n    }\n\n    function clone(el) {\n        el.clone = document.createElement('div');\n\n        var refElement = el.node.nextSibling || el.node,\n            cloneStyle = el.clone.style;\n\n        cloneStyle.height = el.height + 'px';\n        cloneStyle.width = el.width + 'px';\n        cloneStyle.marginTop = el.computed.marginTop;\n        cloneStyle.marginBottom = el.computed.marginBottom;\n        cloneStyle.marginLeft = el.computed.marginLeft;\n        cloneStyle.marginRight = el.computed.marginRight;\n        cloneStyle.padding = cloneStyle.border = cloneStyle.borderSpacing = 0;\n        cloneStyle.fontSize = '1em';\n        cloneStyle.position = 'static';\n        cloneStyle.cssFloat = el.computed.cssFloat;\n\n        el.node.parentNode.insertBefore(el.clone, refElement);\n    }\n\n    function killClone(el) {\n        el.clone.parentNode.removeChild(el.clone);\n        el.clone = undefined;\n    }\n\n    function getElementParams(node) {\n        var computedStyle = getComputedStyle(node),\n            parentNode = node.parentNode,\n            parentComputedStyle = getComputedStyle(parentNode),\n            cachedPosition = node.style.position;\n\n        node.style.position = 'relative';\n\n        var computed = {\n                top: computedStyle.top,\n                marginTop: computedStyle.marginTop,\n                marginBottom: computedStyle.marginBottom,\n                marginLeft: computedStyle.marginLeft,\n                marginRight: computedStyle.marginRight,\n                cssFloat: computedStyle.cssFloat,\n                display: computedStyle.display\n            },\n            numeric = {\n                top: parseNumeric(computedStyle.top),\n                marginBottom: parseNumeric(computedStyle.marginBottom),\n                paddingLeft: parseNumeric(computedStyle.paddingLeft),\n                paddingRight: parseNumeric(computedStyle.paddingRight),\n                borderLeftWidth: parseNumeric(computedStyle.borderLeftWidth),\n                borderRightWidth: parseNumeric(computedStyle.borderRightWidth)\n            };\n\n        node.style.position = cachedPosition;\n\n        var css = {\n                position: node.style.position,\n                top: node.style.top,\n                bottom: node.style.bottom,\n                left: node.style.left,\n                right: node.style.right,\n                width: node.style.width,\n                marginTop: node.style.marginTop,\n                marginLeft: node.style.marginLeft,\n                marginRight: node.style.marginRight\n            },\n            nodeOffset = getElementOffset(node),\n            parentOffset = getElementOffset(parentNode),\n\n            parent = {\n                node: parentNode,\n                css: {\n                    position: parentNode.style.position\n                },\n                computed: {\n                    position: parentComputedStyle.position\n                },\n                numeric: {\n                    borderLeftWidth: parseNumeric(parentComputedStyle.borderLeftWidth),\n                    borderRightWidth: parseNumeric(parentComputedStyle.borderRightWidth),\n                    borderTopWidth: parseNumeric(parentComputedStyle.borderTopWidth),\n                    borderBottomWidth: parseNumeric(parentComputedStyle.borderBottomWidth)\n                }\n            },\n\n            el = {\n                node: node,\n                box: {\n                    left: nodeOffset.win.left,\n                    right: html.clientWidth - nodeOffset.win.right\n                },\n                offset: {\n                    top: nodeOffset.win.top - parentOffset.win.top - parent.numeric.borderTopWidth,\n                    left: nodeOffset.win.left - parentOffset.win.left - parent.numeric.borderLeftWidth,\n                    right: -nodeOffset.win.right + parentOffset.win.right - parent.numeric.borderRightWidth\n                },\n                css: css,\n                isCell: computedStyle.display == 'table-cell',\n                computed: computed,\n                numeric: numeric,\n                width: nodeOffset.win.right - nodeOffset.win.left,\n                height: nodeOffset.win.bottom - nodeOffset.win.top,\n                mode: -1,\n                inited: false,\n                parent: parent,\n                limit: {\n                    start: nodeOffset.doc.top - numeric.top,\n                    end: parentOffset.doc.top + parentNode.offsetHeight - parent.numeric.borderBottomWidth -\n                        node.offsetHeight - numeric.top - numeric.marginBottom\n                }\n            };\n\n        return el;\n    }\n\n    function getDocOffsetTop(node) {\n        var docOffsetTop = 0;\n\n        while (node) {\n            docOffsetTop += node.offsetTop;\n            node = node.offsetParent;\n        }\n\n        return docOffsetTop;\n    }\n\n    function getElementOffset(node) {\n        var box = node.getBoundingClientRect();\n\n            return {\n                doc: {\n                    top: box.top + win.pageYOffset,\n                    left: box.left + win.pageXOffset\n                },\n                win: box\n            };\n    }\n\n    function startFastCheckTimer() {\n        checkTimer = setInterval(function() {\n            !fastCheck() && rebuild();\n        }, 500);\n    }\n\n    function stopFastCheckTimer() {\n        clearInterval(checkTimer);\n    }\n\n    function handlePageVisibilityChange() {\n        if (!initialized) return;\n\n        if (document[hiddenPropertyName]) {\n            stopFastCheckTimer();\n        }\n        else {\n            startFastCheckTimer();\n        }\n    }\n\n    function init() {\n        if (initialized) return;\n\n        updateScrollPos();\n        initAll();\n\n        win.addEventListener('scroll', onScroll);\n        win.addEventListener('wheel', onWheel);\n\n        //watch for width changes\n        win.addEventListener('resize', rebuild);\n        win.addEventListener('orientationchange', rebuild);\n\n        //watch for page visibility\n        doc.addEventListener(visibilityChangeEventName, handlePageVisibilityChange);\n\n        startFastCheckTimer();\n\n        initialized = true;\n    }\n\n    function rebuild() {\n        if (!initialized) return;\n\n        deinitAll();\n\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            watchArray[i] = getElementParams(watchArray[i].node);\n        }\n\n        initAll();\n    }\n\n    function pause() {\n        win.removeEventListener('scroll', onScroll);\n        win.removeEventListener('wheel', onWheel);\n        win.removeEventListener('resize', rebuild);\n        win.removeEventListener('orientationchange', rebuild);\n        doc.removeEventListener(visibilityChangeEventName, handlePageVisibilityChange);\n\n        stopFastCheckTimer();\n\n        initialized = false;\n    }\n\n    function stop() {\n        pause();\n        deinitAll();\n    }\n\n    function kill() {\n        stop();\n\n        //empty the array without loosing the references,\n        //the most performant method according to http://jsperf.com/empty-javascript-array\n        while (watchArray.length) {\n            watchArray.pop();\n        }\n    }\n\n    function add(node) {\n        //check if Stickyfill is already applied to the node\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            if (watchArray[i].node === node) return;\n        };\n\n        var el = getElementParams(node);\n\n        watchArray.push(el);\n\n        if (!initialized) {\n            init();\n        }\n        else {\n            initElement(el);\n        }\n    }\n\n    function remove(node) {\n        for (var i = watchArray.length - 1; i >= 0; i--) {\n            if (watchArray[i].node === node) {\n                deinitElement(watchArray[i]);\n                watchArray.splice(i, 1);\n            }\n        };\n    }\n\n    //expose Stickyfill\n    win.Stickyfill = {\n        stickies: watchArray,\n        add: add,\n        remove: remove,\n        init: init,\n        rebuild: rebuild,\n        pause: pause,\n        stop: stop,\n        kill: kill\n    };\n})(document, window);\n\n\n//if jQuery is available -- create a plugin\nif (window.jQuery) {\n    (function($) {\n        $.fn.Stickyfill = function(options) {\n            this.each(function() {\n                Stickyfill.add(this);\n            });\n\n            return this;\n        };\n    })(window.jQuery);\n}\n"]}