https://www.scania.com/etc.clientlibs/scania-clientlibs/clientlibs…-41660784e9d5fc42669e462417854383-lc.min.js

446/*! picturefill - v3.0.2 - 2016-02-12
447 * https://scottjehl.github.io/picturefill/
448 * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT
449 */
450/*! Gecko-Picture - v1.0
451 * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture
452 * Firefox's early picture implementation (prior to FF41) is static and does
453 * not react to viewport changes. This tiny module fixes this.
454 */
455(function(window) {
456	/*jshint eqnull:true */
457	var ua = navigator.userAgent;
458
459	if ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 < 45) ) {
460		addEventListener("resize", (function() {
461			var timer;
462
463			var dummySrc = document.createElement("source");
464
465			var fixRespimg = function(img) {
466				var source, sizes;
467				var picture = img.parentNode;
468
469				if (picture.nodeName.toUpperCase() === "PICTURE") {
470					source = dummySrc.cloneNode();
471
472					picture.insertBefore(source, picture.firstElementChild);
473					setTimeout(function() {
474						picture.removeChild(source);
475					});
476				} else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {
477					img._pfLastSize = img.offsetWidth;
478					sizes = img.sizes;
479					img.sizes += ",100vw";
480					setTimeout(function() {
481						img.sizes = sizes;
482					});
483				}
484			};
485
486			var findPictureImgs = function() {
487				var i;
488				var imgs = document.querySelectorAll("picture > img, img[srcset][sizes]");
489				for (i = 0; i < imgs.length; i++) {
490					fixRespimg(imgs[i]);
491				}
492			};
493			var onResize = function() {
494				clearTimeout(timer);
495				timer = setTimeout(findPictureImgs, 99);
496			};
497			var mq = window.matchMedia && matchMedia("(orientation: landscape)");
498			var init = function() {
499				onResize();
500
501				if (mq && mq.addListener) {
502					mq.addListener(onResize);
503				}
504			};
505
506			dummySrc.srcset = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
507
508			if (/^[c|i]|d$/.test(document.readyState || "")) {
509				init();
510			} else {
511				document.addEventListener("DOMContentLoaded", init);
512			}
513
514			return onResize;
515		})());
516	}
517})(window);
518
519/*! Picturefill - v3.0.2
520 * http://scottjehl.github.io/picturefill
521 * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;
522 *  License: MIT
523 */
524
525(function( window, document, undefined ) {
526	// Enable strict mode
527	"use strict";
528
529	// HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)
530	document.createElement( "picture" );
531
532	var warn, eminpx, alwaysCheckWDescriptor, evalId;
533	// local object for method references and testing exposure
534	var pf = {};
535	var isSupportTestReady = false;
536	var noop = function() {};
537	var image = document.createElement( "img" );
538	var getImgAttr = image.getAttribute;
539	var setImgAttr = image.setAttribute;
540	var removeImgAttr = image.removeAttribute;
541	var docElem = document.documentElement;
542	var types = {};
543	var cfg = {
544		//resource selection:
545		algorithm: ""
546	};
547	var srcAttr = "data-pfsrc";
548	var srcsetAttr = srcAttr + "set";
549	// ua sniffing is done for undetectable img loading features,
550	// to do some non crucial perf optimizations
551	var ua = navigator.userAgent;
552	var supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 > 35 );
553	var curSrcProp = "currentSrc";
554	var regWDesc = /\s+\+?\d+(e\d+)?w/;
555	var regSize = /(\([^)]+\))?\s*(.+)/;
556	var setOptions = window.picturefillCFG;
557	/**
558	 * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )
559	 */
560	// baseStyle also used by getEmValue (i.e.: width: 1em is important)
561	var 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)";
562	var fsCss = "font-size:100%!important;";
563	var isVwDirty = true;
564
565	var cssCache = {};
566	var sizeLengthCache = {};
567	var DPR = window.devicePixelRatio;
568	var units = {
569		px: 1,
570		"in": 96
571	};
572	var anchor = document.createElement( "a" );
573	/**
574	 * alreadyRun flag used for setOptions. is it true setOptions will reevaluate
575	 * @type {boolean}
576	 */
577	var alreadyRun = false;
578
579	// Reusable, non-"g" Regexes
580
581	// (Don't use \s, to avoid matching non-breaking space.)
582	var regexLeadingSpaces = /^[ \t\n\r\u000c]+/,
583	    regexLeadingCommasOrSpaces = /^[, \t\n\r\u000c]+/,
584	    regexLeadingNotSpaces = /^[^ \t\n\r\u000c]+/,
585	    regexTrailingCommas = /[,]+$/,
586	    regexNonNegativeInteger = /^\d+$/,
587
588	    // ( Positive or negative or unsigned integers or decimals, without or without exponents.
589	    // Must include at least one digit.
590	    // According to spec tests any decimal point must be followed by a digit.
591	    // No leading plus sign is allowed.)
592	    // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number
593	    regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;
594
595	var on = function(obj, evt, fn, capture) {
596		if ( obj.addEventListener ) {
597			obj.addEventListener(evt, fn, capture || false);
598		} else if ( obj.attachEvent ) {
599			obj.attachEvent( "on" + evt, fn);
600		}
601	};
602
603	/**
604	 * simple memoize function:
605	 */
606
607	var memoize = function(fn) {
608		var cache = {};
609		return function(input) {
610			if ( !(input in cache) ) {
611				cache[ input ] = fn(input);
612			}
613			return cache[ input ];
614		};
615	};
616
617	// UTILITY FUNCTIONS
618
619	// Manual is faster than RegEx
620	// http://jsperf.com/whitespace-character/5
621	function isSpace(c) {
622		return (c === "\u0020" || // space
623		        c === "\u0009" || // horizontal tab
624		        c === "\u000A" || // new line
625		        c === "\u000C" || // form feed
626		        c === "\u000D");  // carriage return
627	}
628
629	/**
630	 * gets a mediaquery and returns a boolean or gets a css length and returns a number
631	 * @param css mediaqueries or css length
632	 * @returns {boolean|number}
633	 *
634	 * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738
635	 */
636	var evalCSS = (function() {
637
638		var regLength = /^([\d\.]+)(em|vw|px)$/;
639		var replace = function() {
640			var args = arguments, index = 0, string = args[0];
641			while (++index in args) {
642				string = string.replace(args[index], args[++index]);
643			}
644			return string;
645		};
646
647		var buildStr = memoize(function(css) {
648
649			return "return " + replace((css || "").toLowerCase(),
650				// interpret `and`
651				/\band\b/g, "&&",
652
653				// interpret `,`
654				/,/g, "||",
655
656				// interpret `min-` as >=
657				/min-([a-z-\s]+):/g, "e.$1>=",
658
659				// interpret `max-` as <=
660				/max-([a-z-\s]+):/g, "e.$1<=",
661
662				//calc value
663				/calc([^)]+)/g, "($1)",
664
665				// interpret css values
666				/(\d+[\.]*[\d]*)([a-z]+)/g, "($1 * e.$2)",
667				//make eval less evil
668				/^(?!(e.[a-z]|[0-9\.&=|><\+\-\*\(\)\/])).*/ig, ""
669			) + ";";
670		});
671
672		return function(css, length) {
673			var parsedLength;
674			if (!(css in cssCache)) {
675				cssCache[css] = false;
676				if (length && (parsedLength = css.match( regLength ))) {
677					cssCache[css] = parsedLength[ 1 ] * units[parsedLength[ 2 ]];
678				} else {
679					/*jshint evil:true */
680					try{
681						cssCache[css] = new Function("e", buildStr(css))(units);
682					} catch(e) {}
683					/*jshint evil:false */
684				}
685			}
686			return cssCache[css];
687		};
688	})();
689
690	var setResolution = function( candidate, sizesattr ) {
691		if ( candidate.w ) { // h = means height: || descriptor.type === 'h' do not handle yet...
692			candidate.cWidth = pf.calcListLength( sizesattr || "100vw" );
693			candidate.res = candidate.w / candidate.cWidth ;
694		} else {
695			candidate.res = candidate.d;
696		}
697		return candidate;
698	};
699
700	/**
701	 *
702	 * @param opt
703	 */
704	var picturefill = function( opt ) {
705
706		if (!isSupportTestReady) {return;}
707
708		var elements, i, plen;
709
710		var options = opt || {};
711
712		if ( options.elements && options.elements.nodeType === 1 ) {
713			if ( options.elements.nodeName.toUpperCase() === "IMG" ) {
714				options.elements =  [ options.elements ];
715			} else {
716				options.context = options.elements;
717				options.elements =  null;
718			}
719		}
720
721		elements = options.elements || pf.qsa( (options.context || document), ( options.reevaluate || options.reselect ) ? pf.sel : pf.selShort );
722
723		if ( (plen = elements.length) ) {
724
725			pf.setupRun( options );
726			alreadyRun = true;
727
728			// Loop through all elements
729			for ( i = 0; i < plen; i++ ) {
730				pf.fillImg(elements[ i ], options);
731			}
732
733			pf.teardownRun( options );
734		}
735	};
736
737	/**
738	 * outputs a warning for the developer
739	 * @param {message}
740	 * @type {Function}
741	 */
742	warn = ( window.console && console.warn ) ?
743		function( message ) {
744			console.warn( message );
745		} :
746		noop
747	;
748
749	if ( !(curSrcProp in image) ) {
750		curSrcProp = "src";
751	}
752
753	// Add support for standard mime types.
754	types[ "image/jpeg" ] = true;
755	types[ "image/gif" ] = true;
756	types[ "image/png" ] = true;
757
758	function detectTypeSupport( type, typeUri ) {
759		// based on Modernizr's lossless img-webp test
760		// note: asynchronous
761		var image = new window.Image();
762		image.onerror = function() {
763			types[ type ] = false;
764			picturefill();
765		};
766		image.onload = function() {
767			types[ type ] = image.width === 1;
768			picturefill();
769		};
770		image.src = typeUri;
771		return "pending";
772	}
773
774	// test svg support
775	types[ "image/svg+xml" ] = document.implementation.hasFeature( "http://www.w3.org/TR/SVG11/feature#Image", "1.1" );
776
777	/**
778	 * updates the internal vW property with the current viewport width in px
779	 */
780	function updateMetrics() {
781
782		isVwDirty = false;
783		DPR = window.devicePixelRatio;
784		cssCache = {};
785		sizeLengthCache = {};
786
787		pf.DPR = DPR || 1;
788
789		units.width = Math.max(window.innerWidth || 0, docElem.clientWidth);
790		units.height = Math.max(window.innerHeight || 0, docElem.clientHeight);
791
792		units.vw = units.width / 100;
793		units.vh = units.height / 100;
794
795		evalId = [ units.height, units.width, DPR ].join("-");
796
797		units.em = pf.getEmValue();
798		units.rem = units.em;
799	}
800
801	function chooseLowRes( lowerValue, higherValue, dprValue, isCached ) {
802		var bonusFactor, tooMuch, bonus, meanDensity;
803
804		//experimental
805		if (cfg.algorithm === "saveData" ){
806			if ( lowerValue > 2.7 ) {
807				meanDensity = dprValue + 1;
808			} else {
809				tooMuch = higherValue - dprValue;
810				bonusFactor = Math.pow(lowerValue - 0.6, 1.5);
811
812				bonus = tooMuch * bonusFactor;
813
814				if (isCached) {
815					bonus += 0.1 * bonusFactor;
816				}
817
818				meanDensity = lowerValue + bonus;
819			}
820		} else {
821			meanDensity = (dprValue > 1) ?
822				Math.sqrt(lowerValue * higherValue) :
823				lowerValue;
824		}
825
826		return meanDensity > dprValue;
827	}
828
829	function applyBestCandidate( img ) {
830		var srcSetCandidates;
831		var matchingSet = pf.getSet( img );
832		var evaluated = false;
833		if ( matchingSet !== "pending" ) {
834			evaluated = evalId;
835			if ( matchingSet ) {
836				srcSetCandidates = pf.setRes( matchingSet );
837				pf.applySetCandidate( srcSetCandidates, img );
838			}
839		}
840		img[ pf.ns ].evaled = evaluated;
841	}
842
843	function ascendingSort( a, b ) {
844		return a.res - b.res;
845	}
846
847	function setSrcToCur( img, src, set ) {
848		var candidate;
849		if ( !set && src ) {
850			set = img[ pf.ns ].sets;
851			set = set && set[set.length - 1];
852		}
853
854		candidate = getCandidateForSrc(src, set);
855
856		if ( candidate ) {
857			src = pf.makeUrl(src);
858			img[ pf.ns ].curSrc = src;
859			img[ pf.ns ].curCan = candidate;
860
861			if ( !candidate.res ) {
862				setResolution( candidate, candidate.set.sizes );
863			}
864		}
865		return candidate;
866	}
867
868	function getCandidateForSrc( src, set ) {
869		var i, candidate, candidates;
870		if ( src && set ) {
871			candidates = pf.parseSet( set );
872			src = pf.makeUrl(src);
873			for ( i = 0; i < candidates.length; i++ ) {
874				if ( src === pf.makeUrl(candidates[ i ].url) ) {
875					candidate = candidates[ i ];
876					break;
877				}
878			}
879		}
880		return candidate;
881	}
882
883	function getAllSourceElements( picture, candidates ) {
884		var i, len, source, srcset;
885
886		// SPEC mismatch intended for size and perf:
887		// actually only source elements preceding the img should be used
888		// also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector
889		var sources = picture.getElementsByTagName( "source" );
890
891		for ( i = 0, len = sources.length; i < len; i++ ) {
892			source = sources[ i ];
893			source[ pf.ns ] = true;
894			srcset = source.getAttribute( "srcset" );
895
896			// if source does not have a srcset attribute, skip
897			if ( srcset ) {
898				candidates.push( {
899					srcset: srcset,
900					media: source.getAttribute( "media" ),
901					type: source.getAttribute( "type" ),
902					sizes: source.getAttribute( "sizes" )
903				} );
904			}
905		}
906	}
907
908	/**
909	 * Srcset Parser
910	 * By Alex Bell |  MIT License
911	 *
912	 * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]
913	 *
914	 * Based super duper closely on the reference algorithm at:
915	 * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute
916	 */
917
918	// 1. Let input be the value passed to this algorithm.
919	// (TO-DO : Explain what "set" argument is here. Maybe choose a more
920	// descriptive & more searchable name.  Since passing the "set" in really has
921	// nothing to do with parsing proper, I would prefer this assignment eventually
922	// go in an external fn.)
923	function parseSrcset(input, set) {
924
925		function collectCharacters(regEx) {
926			var chars,
927			    match = regEx.exec(input.substring(pos));
928			if (match) {
929				chars = match[ 0 ];
930				pos += chars.length;
931				return chars;
932			}
933		}
934
935		var inputLength = input.length,
936		    url,
937		    descriptors,
938		    currentDescriptor,
939		    state,
940		    c,
941
942		    // 2. Let position be a pointer into input, initially pointing at the start
943		    //    of the string.
944		    pos = 0,
945
946		    // 3. Let candidates be an initially empty source set.
947		    candidates = [];
948
949		/**
950		* Adds descriptor properties to a candidate, pushes to the candidates array
951		* @return undefined
952		*/
953		// (Declared outside of the while loop so that it's only created once.
954		// (This fn is defined before it is used, in order to pass JSHINT.
955		// Unfortunately this breaks the sequencing of the spec comments. :/ )
956		function parseDescriptors() {
957
958			// 9. Descriptor parser: Let error be no.
959			var pError = false,
960
961			// 10. Let width be absent.
962			// 11. Let density be absent.
963			// 12. Let future-compat-h be absent. (We're implementing it now as h)
964			    w, d, h, i,
965			    candidate = {},
966			    desc, lastChar, value, intVal, floatVal;
967
968			// 13. For each descriptor in descriptors, run the appropriate set of steps
969			// from the following list:
970			for (i = 0 ; i < descriptors.length; i++) {
971				desc = descriptors[ i ];
972
973				lastChar = desc[ desc.length - 1 ];
974				value = desc.substring(0, desc.length - 1);
975				intVal = parseInt(value, 10);
976				floatVal = parseFloat(value);
977
978				// If the descriptor consists of a valid non-negative integer followed by
979				// a U+0077 LATIN SMALL LETTER W character
980				if (regexNonNegativeInteger.test(value) && (lastChar === "w")) {
981
982					// If width and density are not both absent, then let error be yes.
983					if (w || d) {pError = true;}
984
985					// Apply the rules for parsing non-negative integers to the descriptor.
986					// If the result is zero, let error be yes.
987					// Otherwise, let width be the result.
988					if (intVal === 0) {pError = true;} else {w = intVal;}
989
990				// If the descriptor consists of a valid floating-point number followed by
991				// a U+0078 LATIN SMALL LETTER X character
992				} else if (regexFloatingPoint.test(value) && (lastChar === "x")) {
993
994					// If width, density and future-compat-h are not all absent, then let error
995					// be yes.
996					if (w || d || h) {pError = true;}
997
998					// Apply the rules for parsing floating-point number values to the descriptor.
999					// If the result is less than zero, let error be yes. Otherwise, let density
1000					// be the result.
1001					if (floatVal < 0) {pError = true;} else {d = floatVal;}
1002
1003				// If the descriptor consists of a valid non-negative integer followed by
1004				// a U+0068 LATIN SMALL LETTER H character
1005				} else if (regexNonNegativeInteger.test(value) && (lastChar === "h")) {
1006
1007					// If height and density are not both absent, then let error be yes.
1008					if (h || d) {pError = true;}
1009
1010					// Apply the rules for parsing non-negative integers to the descriptor.
1011					// If the result is zero, let error be yes. Otherwise, let future-compat-h
1012					// be the result.
1013					if (intVal === 0) {pError = true;} else {h = intVal;}
1014
1015				// Anything else, Let error be yes.
1016				} else {pError = true;}
1017			} // (close step 13 for loop)
1018
1019			// 15. If error is still no, then append a new image source to candidates whose
1020			// URL is url, associated with a width width if not absent and a pixel
1021			// density density if not absent. Otherwise, there is a parse error.
1022			if (!pError) {
1023				candidate.url = url;
1024
1025				if (w) { candidate.w = w;}
1026				if (d) { candidate.d = d;}
1027				if (h) { candidate.h = h;}
1028				if (!h && !d && !w) {candidate.d = 1;}
1029				if (candidate.d === 1) {set.has1x = true;}
1030				candidate.set = set;
1031
1032				candidates.push(candidate);
1033			}
1034		} // (close parseDescriptors fn)
1035
1036		/**
1037		* Tokenizes descriptor properties prior to parsing
1038		* Returns undefined.
1039		* (Again, this fn is defined before it is used, in order to pass JSHINT.
1040		* Unfortunately this breaks the logical sequencing of the spec comments. :/ )
1041		*/
1042		function tokenize() {
1043
1044			// 8.1. Descriptor tokeniser: Skip whitespace
1045			collectCharacters(regexLeadingSpaces);
1046
1047			// 8.2. Let current descriptor be the empty string.
1048			currentDescriptor = "";
1049
1050			// 8.3. Let state be in descriptor.
1051			state = "in descriptor";
1052
1053			while (true) {
1054
1055				// 8.4. Let c be the character at position.
1056				c = input.charAt(pos);
1057
1058				//  Do the following depending on the value of state.
1059				//  For the purpose of this step, "EOF" is a special character representing
1060				//  that position is past the end of input.
1061
1062				// In descriptor
1063				if (state === "in descriptor") {
1064					// Do the following, depending on the value of c:
1065
1066				  // Space character
1067				  // If current descriptor is not empty, append current descriptor to
1068				  // descriptors and let current descriptor be the empty string.
1069				  // Set state to after descriptor.
1070					if (isSpace(c)) {
1071						if (currentDescriptor) {
1072							descriptors.push(currentDescriptor);
1073							currentDescriptor = "";
1074							state = "after descriptor";
1075						}
1076
1077					// U+002C COMMA (,)
1078					// Advance position to the next character in input. If current descriptor
1079					// is not empty, append current descriptor to descriptors. Jump to the step
1080					// labeled descriptor parser.
1081					} else if (c === ",") {
1082						pos += 1;
1083						if (currentDescriptor) {
1084							descriptors.push(currentDescriptor);
1085						}
1086						parseDescriptors();
1087						return;
1088
1089					// U+0028 LEFT PARENTHESIS (()
1090					// Append c to current descriptor. Set state to in parens.
1091					} else if (c === "\u0028") {
1092						currentDescriptor = currentDescriptor + c;
1093						state = "in parens";
1094
1095					// EOF
1096					// If current descriptor is not empty, append current descriptor to
1097					// descriptors. Jump to the step labeled descriptor parser.
1098					} else if (c === "") {
1099						if (currentDescriptor) {
1100							descriptors.push(currentDescriptor);
1101						}
1102						parseDescriptors();
1103						return;
1104
1105					// Anything else
1106					// Append c to current descriptor.
1107					} else {
1108						currentDescriptor = currentDescriptor + c;
1109					}
1110				// (end "in descriptor"
1111
1112				// In parens
1113				} else if (state === "in parens") {
1114
1115					// U+0029 RIGHT PARENTHESIS ())
1116					// Append c to current descriptor. Set state to in descriptor.
1117					if (c === ")") {
1118						currentDescriptor = currentDescriptor + c;
1119						state = "in descriptor";
1120
1121					// EOF
1122					// Append current descriptor to descriptors. Jump to the step labeled
1123					// descriptor parser.
1124					} else if (c === "") {
1125						descriptors.push(currentDescriptor);
1126						parseDescriptors();
1127						return;
1128
1129					// Anything else
1130					// Append c to current descriptor.
1131					} else {
1132						currentDescriptor = currentDescriptor + c;
1133					}
1134
1135				// After descriptor
1136				} else if (state === "after descriptor") {
1137
1138					// Do the following, depending on the value of c:
1139					// Space character: Stay in this state.
1140					if (isSpace(c)) {
1141
1142					// EOF: Jump to the step labeled descriptor parser.
1143					} else if (c === "") {
1144						parseDescriptors();
1145						return;
1146
1147					// Anything else
1148					// Set state to in descriptor. Set position to the previous character in input.
1149					} else {
1150						state = "in descriptor";
1151						pos -= 1;
1152
1153					}
1154				}
1155
1156				// Advance position to the next character in input.
1157				pos += 1;
1158
1159			// Repeat this step.
1160			} // (close while true loop)
1161		}
1162
1163		// 4. Splitting loop: Collect a sequence of characters that are space
1164		//    characters or U+002C COMMA characters. If any U+002C COMMA characters
1165		//    were collected, that is a parse error.
1166		while (true) {
1167			collectCharacters(regexLeadingCommasOrSpaces);
1168
1169			// 5. If position is past the end of input, return candidates and abort these steps.
1170			if (pos >= inputLength) {
1171				return candidates; // (we're done, this is the sole return path)
1172			}
1173
1174			// 6. Collect a sequence of characters that are not space characters,
1175			//    and let that be url.
1176			url = collectCharacters(regexLeadingNotSpaces);
1177
1178			// 7. Let descriptors be a new empty list.
1179			descriptors = [];
1180
1181			// 8. If url ends with a U+002C COMMA character (,), follow these substeps:
1182			//		(1). Remove all trailing U+002C COMMA characters from url. If this removed
1183			//         more than one character, that is a parse error.
1184			if (url.slice(-1) === ",") {
1185				url = url.replace(regexTrailingCommas, "");
1186				// (Jump ahead to step 9 to skip tokenization and just push the candidate).
1187				parseDescriptors();
1188
1189			//	Otherwise, follow these substeps:
1190			} else {
1191				tokenize();
1192			} // (close else of step 8)
1193
1194		// 16. Return to the step labeled splitting loop.
1195		} // (Close of big while loop.)
1196	}
1197
1198	/*
1199	 * Sizes Parser
1200	 *
1201	 * By Alex Bell |  MIT License
1202	 *
1203	 * Non-strict but accurate and lightweight JS Parser for the string value <img sizes="here">
1204	 *
1205	 * Reference algorithm at:
1206	 * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute
1207	 *
1208	 * Most comments are copied in directly from the spec
1209	 * (except for comments in parens).
1210	 *
1211	 * Grammar is:
1212	 * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>
1213	 * <source-size> = <media-condition> <source-size-value>
1214	 * <source-size-value> = <length>
1215	 * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes
1216	 *
1217	 * E.g. "(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw"
1218	 * or "(min-width: 30em), calc(30vw - 15px)" or just "30vw"
1219	 *
1220	 * Returns the first valid <css-length> with a media condition that evaluates to true,
1221	 * or "100vw" if all valid media conditions evaluate to false.
1222	 *
1223	 */
1224
1225	function parseSizes(strValue) {
1226
1227		// (Percentage CSS lengths are not allowed in this case, to avoid confusion:
1228		// https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list
1229		// CSS allows a single optional plus or minus sign:
1230		// http://www.w3.org/TR/CSS2/syndata.html#numbers
1231		// CSS is ASCII case-insensitive:
1232		// http://www.w3.org/TR/CSS2/syndata.html#characters )
1233		// Spec allows exponential notation for <number> type:
1234		// http://dev.w3.org/csswg/css-values/#numbers
1235		var 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;
1236
1237		// (This is a quick and lenient test. Because of optional unlimited-depth internal
1238		// grouping parens and strict spacing rules, this could get very complicated.)
1239		var regexCssCalc = /^calc\((?:[0-9a-z \.\+\-\*\/\(\)]+)\)$/i;
1240
1241		var i;
1242		var unparsedSizesList;
1243		var unparsedSizesListLength;
1244		var unparsedSize;
1245		var lastComponentValue;
1246		var size;
1247
1248		// UTILITY FUNCTIONS
1249
1250		//  (Toy CSS parser. The goals here are:
1251		//  1) expansive test coverage without the weight of a full CSS parser.
1252		//  2) Avoiding regex wherever convenient.
1253		//  Quick tests: http://jsfiddle.net/gtntL4gr/3/
1254		//  Returns an array of arrays.)
1255		function parseComponentValues(str) {
1256			var chrctr;
1257			var component = "";
1258			var componentArray = [];
1259			var listArray = [];
1260			var parenDepth = 0;
1261			var pos = 0;
1262			var inComment = false;
1263
1264			function pushComponent() {
1265				if (component) {
1266					componentArray.push(component);
1267					component = "";
1268				}
1269			}
1270
1271			function pushComponentArray() {
1272				if (componentArray[0]) {
1273					listArray.push(componentArray);
1274					componentArray = [];
1275				}
1276			}
1277
1278			// (Loop forwards from the beginning of the string.)
1279			while (true) {
1280				chrctr = str.charAt(pos);
1281
1282				if (chrctr === "") { // ( End of string reached.)
1283					pushComponent();
1284					pushComponentArray();
1285					return listArray;
1286				} else if (inComment) {
1287					if ((chrctr === "*") && (str[pos + 1] === "/")) { // (At end of a comment.)
1288						inComment = false;
1289						pos += 2;
1290						pushComponent();
1291						continue;
1292					} else {
1293						pos += 1; // (Skip all characters inside comments.)
1294						continue;
1295					}
1296				} else if (isSpace(chrctr)) {
1297					// (If previous character in loop was also a space, or if
1298					// at the beginning of the string, do not add space char to
1299					// component.)
1300					if ( (str.charAt(pos - 1) && isSpace( str.charAt(pos - 1) ) ) || !component ) {
1301						pos += 1;
1302						continue;
1303					} else if (parenDepth === 0) {
1304						pushComponent();
1305						pos +=1;
1306						continue;
1307					} else {
1308						// (Replace any space character with a plain space for legibility.)
1309						chrctr = " ";
1310					}
1311				} else if (chrctr === "(") {
1312					parenDepth += 1;
1313				} else if (chrctr === ")") {
1314					parenDepth -= 1;
1315				} else if (chrctr === ",") {
1316					pushComponent();
1317					pushComponentArray();
1318					pos += 1;
1319					continue;
1320				} else if ( (chrctr === "/") && (str.charAt(pos + 1) === "*") ) {
1321					inComment = true;
1322					pos += 2;
1323					continue;
1324				}
1325
1326				component = component + chrctr;
1327				pos += 1;
1328			}
1329		}
1330
1331		function isValidNonNegativeSourceSizeValue(s) {
1332			if (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {return true;}
1333			if (regexCssCalc.test(s)) {return true;}
1334			// ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:
1335			// "-0 is equivalent to 0 and is not a negative number." which means that
1336			// unitless zero and unitless negative zero must be accepted as special cases.)
1337			if ((s === "0") || (s === "-0") || (s === "+0")) {return true;}
1338			return false;
1339		}
1340
1341		// When asked to parse a sizes attribute from an element, parse a
1342		// comma-separated list of component values from the value of the element's
1343		// sizes attribute (or the empty string, if the attribute is absent), and let
1344		// unparsed sizes list be the result.
1345		// http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values
1346
1347		unparsedSizesList = parseComponentValues(strValue);
1348		unparsedSizesListLength = unparsedSizesList.length;
1349
1350		// For each unparsed size in unparsed sizes list:
1351		for (i = 0; i < unparsedSizesListLength; i++) {
1352			unparsedSize = unparsedSizesList[i];
1353
1354			// 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.
1355			// ( parseComponentValues() already omits spaces outside of parens. )
1356
1357			// If unparsed size is now empty, that is a parse error; continue to the next
1358			// iteration of this algorithm.
1359			// ( parseComponentValues() won't push an empty array. )
1360
1361			// 2. If the last component value in unparsed size is a valid non-negative
1362			// <source-size-value>, let size be its value and remove the component value
1363			// from unparsed size. Any CSS function other than the calc() function is
1364			// invalid. Otherwise, there is a parse error; continue to the next iteration
1365			// of this algorithm.
1366			// http://dev.w3.org/csswg/css-syntax/#parse-component-value
1367			lastComponentValue = unparsedSize[unparsedSize.length - 1];
1368
1369			if (isValidNonNegativeSourceSizeValue(lastComponentValue)) {
1370				size = lastComponentValue;
1371				unparsedSize.pop();
1372			} else {
1373				continue;
1374			}
1375
1376			// 3. Remove all consecutive <whitespace-token>s from the end of unparsed
1377			// size. If unparsed size is now empty, return size and exit this algorithm.
1378			// If this was not the last item in unparsed sizes list, that is a parse error.
1379			if (unparsedSize.length === 0) {
1380				return size;
1381			}
1382
1383			// 4. Parse the remaining component values in unparsed size as a
1384			// <media-condition>. If it does not parse correctly, or it does parse
1385			// correctly but the <media-condition> evaluates to false, continue to the
1386			// next iteration of this algorithm.
1387			// (Parsing all possible compound media conditions in JS is heavy, complicated,
1388			// and the payoff is unclear. Is there ever an situation where the
1389			// media condition parses incorrectly but still somehow evaluates to true?
1390			// Can we just rely on the browser/polyfill to do it?)
1391			unparsedSize = unparsedSize.join(" ");
1392			if (!(pf.matchesMedia( unparsedSize ) ) ) {
1393				continue;
1394			}
1395
1396			// 5. Return size and exit this algorithm.
1397			return size;
1398		}
1399
1400		// If the above algorithm exhausts unparsed sizes list without returning a
1401		// size value, return 100vw.
1402		return "100vw";
1403	}
1404
1405	// namespace
1406	pf.ns = ("pf" + new Date().getTime()).substr(0, 9);
1407
1408	// srcset support test
1409	pf.supSrcset = "srcset" in image;
1410	pf.supSizes = "sizes" in image;
1411	pf.supPicture = !!window.HTMLPictureElement;
1412
1413	// UC browser does claim to support srcset and picture, but not sizes,
1414	// this extended test reveals the browser does support nothing
1415	if (pf.supSrcset && pf.supPicture && !pf.supSizes) {
1416		(function(image2) {
1417			image.srcset = "data:,a";
1418			image2.src = "data:,a";
1419			pf.supSrcset = image.complete === image2.complete;
1420			pf.supPicture = pf.supSrcset && pf.supPicture;
1421		})(document.createElement("img"));
1422	}
1423
1424	// Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute
1425	if (pf.supSrcset && !pf.supSizes) {
1426
1427		(function() {
1428			var width2 = "data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==";
1429			var width1 = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
1430			var img = document.createElement("img");
1431			var test = function() {
1432				var width = img.width;
1433
1434				if (width === 2) {
1435					pf.supSizes = true;
1436				}
1437
1438				alwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;
1439
1440				isSupportTestReady = true;
1441				// force async
1442				setTimeout(picturefill);
1443			};
1444
1445			img.onload = test;
1446			img.onerror = test;
1447			img.setAttribute("sizes", "9px");
1448
1449			img.srcset = width1 + " 1w," + width2 + " 9w";
1450			img.src = width1;
1451		})();
1452
1453	} else {
1454		isSupportTestReady = true;
1455	}
1456
1457	// using pf.qsa instead of dom traversing does scale much better,
1458	// especially on sites mixing responsive and non-responsive images
1459	pf.selShort = "picture>img,img[srcset]";
1460	pf.sel = pf.selShort;
1461	pf.cfg = cfg;
1462
1463	/**
1464	 * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )
1465	 */
1466	pf.DPR = (DPR  || 1 );
1467	pf.u = units;
1468
1469	// container of supported mime types that one might need to qualify before using
1470	pf.types =  types;
1471
1472	pf.setSize = noop;
1473
1474	/**
1475	 * Gets a string and returns the absolute URL
1476	 * @param src
1477	 * @returns {String} absolute URL
1478	 */
1479
1480	pf.makeUrl = memoize(function(src) {
1481		anchor.href = src;
1482		return anchor.href;
1483	});
1484
1485	/**
1486	 * Gets a DOM element or document and a selctor and returns the found matches
1487	 * Can be extended with jQuery/Sizzle for IE7 support
1488	 * @param context
1489	 * @param sel
1490	 * @returns {NodeList|Array}
1491	 */
1492	pf.qsa = function(context, sel) {
1493		return ( "querySelector" in context ) ? context.querySelectorAll(sel) : [];
1494	};
1495
1496	/**
1497	 * Shortcut method for matchMedia ( for easy overriding in tests )
1498	 * wether native or pf.mMQ is used will be decided lazy on first call
1499	 * @returns {boolean}
1500	 */
1501	pf.matchesMedia = function() {
1502		if ( window.matchMedia && (matchMedia( "(min-width: 0.1em)" ) || {}).matches ) {
1503			pf.matchesMedia = function( media ) {
1504				return !media || ( matchMedia( media ).matches );
1505			};
1506		} else {
1507			pf.matchesMedia = pf.mMQ;
1508		}
1509
1510		return pf.matchesMedia.apply( this, arguments );
1511	};
1512
1513	/**
1514	 * A simplified matchMedia implementation for IE8 and IE9
1515	 * handles only min-width/max-width with px or em values
1516	 * @param media
1517	 * @returns {boolean}
1518	 */
1519	pf.mMQ = function( media ) {
1520		return media ? evalCSS(media) : true;
1521	};
1522
1523	/**
1524	 * Returns the calculated length in css pixel from the given sourceSizeValue
1525	 * http://dev.w3.org/csswg/css-values-3/#length-value
1526	 * intended Spec mismatches:
1527	 * * Does not check for invalid use of CSS functions
1528	 * * Does handle a computed length of 0 the same as a negative and therefore invalid value
1529	 * @param sourceSizeValue
1530	 * @returns {Number}
1531	 */
1532	pf.calcLength = function( sourceSizeValue ) {
1533
1534		var value = evalCSS(sourceSizeValue, true) || false;
1535		if (value < 0) {
1536			value = false;
1537		}
1538
1539		return value;
1540	};
1541
1542	/**
1543	 * Takes a type string and checks if its supported
1544	 */
1545
1546	pf.supportsType = function( type ) {
1547		return ( type ) ? types[ type ] : true;
1548	};
1549
1550	/**
1551	 * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)
1552	 * @param sourceSizeStr
1553	 * @returns {*}
1554	 */
1555	pf.parseSize = memoize(function( sourceSizeStr ) {
1556		var match = ( sourceSizeStr || "" ).match(regSize);
1557		return {
1558			media: match && match[1],
1559			length: match && match[2]
1560		};
1561	});
1562
1563	pf.parseSet = function( set ) {
1564		if ( !set.cands ) {
1565			set.cands = parseSrcset(set.srcset, set);
1566		}
1567		return set.cands;
1568	};
1569
1570	/**
1571	 * returns 1em in css px for html/body default size
1572	 * function taken from respondjs
1573	 * @returns {*|number}
1574	 */
1575	pf.getEmValue = function() {
1576		var body;
1577		if ( !eminpx && (body = document.body) ) {
1578			var div = document.createElement( "div" ),
1579				originalHTMLCSS = docElem.style.cssText,
1580				originalBodyCSS = body.style.cssText;
1581
1582			div.style.cssText = baseStyle;
1583
1584			// 1em in a media query is the value of the default font size of the browser
1585			// reset docElem and body to ensure the correct value is returned
1586			docElem.style.cssText = fsCss;
1587			body.style.cssText = fsCss;
1588
1589			body.appendChild( div );
1590			eminpx = div.offsetWidth;
1591			body.removeChild( div );
1592
1593			//also update eminpx before returning
1594			eminpx = parseFloat( eminpx, 10 );
1595
1596			// restore the original values
1597			docElem.style.cssText = originalHTMLCSS;
1598			body.style.cssText = originalBodyCSS;
1599
1600		}
1601		return eminpx || 16;
1602	};
1603
1604	/**
1605	 * Takes a string of sizes and returns the width in pixels as a number
1606	 */
1607	pf.calcListLength = function( sourceSizeListStr ) {
1608		// Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%
1609		//
1610		//                           or (min-width:30em) calc(30% - 15px)
1611		if ( !(sourceSizeListStr in sizeLengthCache) || cfg.uT ) {
1612			var winningLength = pf.calcLength( parseSizes( sourceSizeListStr ) );
1613
1614			sizeLengthCache[ sourceSizeListStr ] = !winningLength ? units.width : winningLength;
1615		}
1616
1617		return sizeLengthCache[ sourceSizeListStr ];
1618	};
1619
1620	/**
1621	 * Takes a candidate object with a srcset property in the form of url/
1622	 * ex. "images/pic-medium.png 1x, images/pic-medium-2x.png 2x" or
1623	 *     "images/pic-medium.png 400w, images/pic-medium-2x.png 800w" or
1624	 *     "images/pic-small.png"
1625	 * Get an array of image candidates in the form of
1626	 *      {url: "/foo/bar.png", resolution: 1}
1627	 * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value
1628	 * If sizes is specified, res is calculated
1629	 */
1630	pf.setRes = function( set ) {
1631		var candidates;
1632		if ( set ) {
1633
1634			candidates = pf.parseSet( set );
1635
1636			for ( var i = 0, len = candidates.length; i < len; i++ ) {
1637				setResolution( candidates[ i ], set.sizes );
1638			}
1639		}
1640		return candidates;
1641	};
1642
1643	pf.setRes.res = setResolution;
1644
1645	pf.applySetCandidate = function( candidates, img ) {
1646		if ( !candidates.length ) {return;}
1647		var candidate,
1648			i,
1649			j,
1650			length,
1651			bestCandidate,
1652			curSrc,
1653			curCan,
1654			candidateSrc,
1655			abortCurSrc;
1656
1657		var imageData = img[ pf.ns ];
1658		var dpr = pf.DPR;
1659
1660		curSrc = imageData.curSrc || img[curSrcProp];
1661
1662		curCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);
1663
1664		// if we have a current source, we might either become lazy or give this source some advantage
1665		if ( curCan && curCan.set === candidates[ 0 ].set ) {
1666
1667			// if browser can abort image request and the image has a higher pixel density than needed
1668			// and this image isn't downloaded yet, we skip next part and try to save bandwidth
1669			abortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);
1670
1671			if ( !abortCurSrc ) {
1672				curCan.cached = true;
1673
1674				// if current candidate is "best", "better" or "okay",
1675				// set it to bestCandidate
1676				if ( curCan.res >= dpr ) {
1677					bestCandidate = curCan;
1678				}
1679			}
1680		}
1681
1682		if ( !bestCandidate ) {
1683
1684			candidates.sort( ascendingSort );
1685
1686			length = candidates.length;
1687			bestCandidate = candidates[ length - 1 ];
1688
1689			for ( i = 0; i < length; i++ ) {
1690				candidate = candidates[ i ];
1691				if ( candidate.res >= dpr ) {
1692					j = i - 1;
1693
1694					// we have found the perfect candidate,
1695					// but let's improve this a little bit with some assumptions ;-)
1696					if (candidates[ j ] &&
1697						(abortCurSrc || curSrc !== pf.makeUrl( candidate.url )) &&
1698						chooseLowRes(candidates[ j ].res, candidate.res, dpr, candidates[ j ].cached)) {
1699
1700						bestCandidate = candidates[ j ];
1701
1702					} else {
1703						bestCandidate = candidate;
1704					}
1705					break;
1706				}
1707			}
1708		}
1709
1710		if ( bestCandidate ) {
1711
1712			candidateSrc = pf.makeUrl( bestCandidate.url );
1713
1714			imageData.curSrc = candidateSrc;
1715			imageData.curCan = bestCandidate;
1716
1717			if ( candidateSrc !== curSrc ) {
1718				pf.setSrc( img, bestCandidate );
1719			}
1720			pf.setSize( img );
1721		}
1722	};
1723
1724	pf.setSrc = function( img, bestCandidate ) {
1725		var origWidth;
1726		img.src = bestCandidate.url;
1727
1728		// although this is a specific Safari issue, we don't want to take too much different code paths
1729		if ( bestCandidate.set.type === "image/svg+xml" ) {
1730			origWidth = img.style.width;
1731			img.style.width = (img.offsetWidth + 1) + "px";
1732
1733			// next line only should trigger a repaint
1734			// if... is only done to trick dead code removal
1735			if ( img.offsetWidth + 1 ) {
1736				img.style.width = origWidth;
1737			}
1738		}
1739	};
1740
1741	pf.getSet = function( img ) {
1742		var i, set, supportsType;
1743		var match = false;
1744		var sets = img [ pf.ns ].sets;
1745
1746		for ( i = 0; i < sets.length && !match; i++ ) {
1747			set = sets[i];
1748
1749			if ( !set.srcset || !pf.matchesMedia( set.media ) || !(supportsType = pf.supportsType( set.type )) ) {
1750				continue;
1751			}
1752
1753			if ( supportsType === "pending" ) {
1754				set = supportsType;
1755			}
1756
1757			match = set;
1758			break;
1759		}
1760
1761		return match;
1762	};
1763
1764	pf.parseSets = function( element, parent, options ) {
1765		var srcsetAttribute, imageSet, isWDescripor, srcsetParsed;
1766
1767		var hasPicture = parent && parent.nodeName.toUpperCase() === "PICTURE";
1768		var imageData = element[ pf.ns ];
1769
1770		if ( imageData.src === undefined || options.src ) {
1771			imageData.src = getImgAttr.call( element, "src" );
1772			if ( imageData.src ) {
1773				setImgAttr.call( element, srcAttr, imageData.src );
1774			} else {
1775				removeImgAttr.call( element, srcAttr );
1776			}
1777		}
1778
1779		if ( imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset ) {
1780			srcsetAttribute = getImgAttr.call( element, "srcset" );
1781			imageData.srcset = srcsetAttribute;
1782			srcsetParsed = true;
1783		}
1784
1785		imageData.sets = [];
1786
1787		if ( hasPicture ) {
1788			imageData.pic = true;
1789			getAllSourceElements( parent, imageData.sets );
1790		}
1791
1792		if ( imageData.srcset ) {
1793			imageSet = {
1794				srcset: imageData.srcset,
1795				sizes: getImgAttr.call( element, "sizes" )
1796			};
1797
1798			imageData.sets.push( imageSet );
1799
1800			isWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || "");
1801
1802			// add normal src as candidate, if source has no w descriptor
1803			if ( !isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x ) {
1804				imageSet.srcset += ", " + imageData.src;
1805				imageSet.cands.push({
1806					url: imageData.src,
1807					d: 1,
1808					set: imageSet
1809				});
1810			}
1811
1812		} else if ( imageData.src ) {
1813			imageData.sets.push( {
1814				srcset: imageData.src,
1815				sizes: null
1816			} );
1817		}
1818
1819		imageData.curCan = null;
1820		imageData.curSrc = undefined;
1821
1822		// if img has picture or the srcset was removed or has a srcset and does not support srcset at all
1823		// or has a w descriptor (and does not support sizes) set support to false to evaluate
1824		imageData.supported = !( hasPicture || ( imageSet && !pf.supSrcset ) || (isWDescripor && !pf.supSizes) );
1825
1826		if ( srcsetParsed && pf.supSrcset && !imageData.supported ) {
1827			if ( srcsetAttribute ) {
1828				setImgAttr.call( element, srcsetAttr, srcsetAttribute );
1829				element.srcset = "";
1830			} else {
1831				removeImgAttr.call( element, srcsetAttr );
1832			}
1833		}
1834
1835		if (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) ||  element.src !== pf.makeUrl(imageData.src))) {
1836			if (imageData.src === null) {
1837				element.removeAttribute("src");
1838			} else {
1839				element.src = imageData.src;
1840			}
1841		}
1842
1843		imageData.parsed = true;
1844	};
1845
1846	pf.fillImg = function(element, options) {
1847		var imageData;
1848		var extreme = options.reselect || options.reevaluate;
1849
1850		// expando for caching data on the img
1851		if ( !element[ pf.ns ] ) {
1852			element[ pf.ns ] = {};
1853		}
1854
1855		imageData = element[ pf.ns ];
1856
1857		// if the element has already been evaluated, skip it
1858		// unless `options.reevaluate` is set to true ( this, for example,
1859		// is set to true when running `picturefill` on `resize` ).
1860		if ( !extreme && imageData.evaled === evalId ) {
1861			return;
1862		}
1863
1864		if ( !imageData.parsed || options.reevaluate ) {
1865			pf.parseSets( element, element.parentNode, options );
1866		}
1867
1868		if ( !imageData.supported ) {
1869			applyBestCandidate( element );
1870		} else {
1871			imageData.evaled = evalId;
1872		}
1873	};
1874
1875	pf.setupRun = function() {
1876		if ( !alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio) ) {
1877			updateMetrics();
1878		}
1879	};
1880
1881	// If picture is supported, well, that's awesome.
1882	if ( pf.supPicture ) {
1883		picturefill = noop;
1884		pf.fillImg = noop;
1885	} else {
1886
1887		 // Set up picture polyfill by polling the document
1888		(function() {
1889			var isDomReady;
1890			var regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;
1891
1892			var run = function() {
1893				var readyState = document.readyState || "";
1894
1895				timerId = setTimeout(run, readyState === "loading" ? 200 :  999);
1896				if ( document.body ) {
1897					pf.fillImgs();
1898					isDomReady = isDomReady || regReady.test(readyState);
1899					if ( isDomReady ) {
1900						clearTimeout( timerId );
1901					}
1902
1903				}
1904			};
1905
1906			var timerId = setTimeout(run, document.body ? 9 : 99);
1907
1908			// Also attach picturefill on resize and readystatechange
1909			// http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html
1910			var debounce = function(func, wait) {
1911				var timeout, timestamp;
1912				var later = function() {
1913					var last = (new Date()) - timestamp;
1914
1915					if (last < wait) {
1916						timeout = setTimeout(later, wait - last);
1917					} else {
1918						timeout = null;
1919						func();
1920					}
1921				};
1922
1923				return function() {
1924					timestamp = new Date();
1925
1926					if (!timeout) {
1927						timeout = setTimeout(later, wait);
1928					}
1929				};
1930			};
1931			var lastClientWidth = docElem.clientHeight;
1932			var onResize = function() {
1933				isVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;
1934				lastClientWidth = docElem.clientHeight;
1935				if ( isVwDirty ) {
1936					pf.fillImgs();
1937				}
1938			};
1939
1940			on( window, "resize", debounce(onResize, 99 ) );
1941			on( document, "readystatechange", run );
1942		})();
1943	}
1944
1945	pf.picturefill = picturefill;
1946	//use this internally for easy monkey patching/performance testing
1947	pf.fillImgs = picturefill;
1948	pf.teardownRun = noop;
1949
1950	/* expose methods for testing */
1951	picturefill._ = pf;
1952
1953	window.picturefillCFG = {
1954		pf: pf,
1955		push: function(args) {
1956			var name = args.shift();
1957			if (typeof pf[name] === "function") {
1958				pf[name].apply(pf, args);
1959			} else {
1960				cfg[name] = args[0];
1961				if (alreadyRun) {
1962					pf.fillImgs( { reselect: true } );
1963				}
1964			}
1965		}
1966	};
1967
1968	while (setOptions && setOptions.length) {
1969		window.picturefillCFG.push(setOptions.shift());
1970	}
1971
1972	/* expose picturefill */
1973	window.picturefill = picturefill;
1974
1975	/* expose picturefill */
1976	if ( typeof module === "object" && typeof module.exports === "object" ) {
1977		// CommonJS, just export
1978		module.exports = picturefill;
1979	} else if ( typeof define === "function" && define.amd ) {
1980		// AMD support
1981		define( "picturefill", function() { return picturefill; } );
1982	}
1983
1984	// IE8 evals this sync, so it must be the last thing we do
1985	if ( !pf.supPicture ) {
1986		types[ "image/webp" ] = detectTypeSupport("image/webp", "data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==" );
1987	}
1988
1989} )( window, document );