function parseSrcset(input, set) {

		function collectCharacters(regEx) {
			var chars,
			    match = regEx.exec(input.substring(pos));
			if (match) {
				chars = match[ 0 ];
				pos += chars.length;
				return chars;
			}
		}

		var inputLength = input.length,
		    url,
		    descriptors,
		    currentDescriptor,
		    state,
		    c,

		    // 2. Let position be a pointer into input, initially pointing at the start
		    //    of the string.
		    pos = 0,

		    // 3. Let candidates be an initially empty source set.
		    candidates = [];

		/**
		* Adds descriptor properties to a candidate, pushes to the candidates array
		* @return undefined
		*/
		// (Declared outside of the while loop so that it's only created once.
		// (This fn is defined before it is used, in order to pass JSHINT.
		// Unfortunately this breaks the sequencing of the spec comments. :/ )
		function parseDescriptors() {

			// 9. Descriptor parser: Let error be no.
			var pError = false,

			// 10. Let width be absent.
			// 11. Let density be absent.
			// 12. Let future-compat-h be absent. (We're implementing it now as h)
			    w, d, h, i,
			    candidate = {},
			    desc, lastChar, value, intVal, floatVal;

			// 13. For each descriptor in descriptors, run the appropriate set of steps
			// from the following list:
			for (i = 0 ; i < descriptors.length; i++) {
				desc = descriptors[ i ];

				lastChar = desc[ desc.length - 1 ];
				value = desc.substring(0, desc.length - 1);
				intVal = parseInt(value, 10);
				floatVal = parseFloat(value);

				// If the descriptor consists of a valid non-negative integer followed by
				// a U+0077 LATIN SMALL LETTER W character
				if (regexNonNegativeInteger.test(value) && (lastChar === "w")) {

					// If width and density are not both absent, then let error be yes.
					if (w || d) {pError = true;}

					// Apply the rules for parsing non-negative integers to the descriptor.
					// If the result is zero, let error be yes.
					// Otherwise, let width be the result.
					if (intVal === 0) {pError = true;} else {w = intVal;}

				// If the descriptor consists of a valid floating-point number followed by
				// a U+0078 LATIN SMALL LETTER X character
				} else if (regexFloatingPoint.test(value) && (lastChar === "x")) {

					// If width, density and future-compat-h are not all absent, then let error
					// be yes.
					if (w || d || h) {pError = true;}

					// Apply the rules for parsing floating-point number values to the descriptor.
					// If the result is less than zero, let error be yes. Otherwise, let density
					// be the result.
					if (floatVal < 0) {pError = true;} else {d = floatVal;}

				// If the descriptor consists of a valid non-negative integer followed by
				// a U+0068 LATIN SMALL LETTER H character
				} else if (regexNonNegativeInteger.test(value) && (lastChar === "h")) {

					// If height and density are not both absent, then let error be yes.
					if (h || d) {pError = true;}

					// Apply the rules for parsing non-negative integers to the descriptor.
					// If the result is zero, let error be yes. Otherwise, let future-compat-h
					// be the result.
					if (intVal === 0) {pError = true;} else {h = intVal;}

				// Anything else, Let error be yes.
				} else {pError = true;}
			} // (close step 13 for loop)

			// 15. If error is still no, then append a new image source to candidates whose
			// URL is url, associated with a width width if not absent and a pixel
			// density density if not absent. Otherwise, there is a parse error.
			if (!pError) {
				candidate.url = url;

				if (w) { candidate.w = w;}
				if (d) { candidate.d = d;}
				if (h) { candidate.h = h;}
				if (!h && !d && !w) {candidate.d = 1;}
				if (candidate.d === 1) {set.has1x = true;}
				candidate.set = set;

				candidates.push(candidate);
			}
		} // (close parseDescriptors fn)

		/**
		* Tokenizes descriptor properties prior to parsing
		* Returns undefined.
		* (Again, this fn is defined before it is used, in order to pass JSHINT.
		* Unfortunately this breaks the logical sequencing of the spec comments. :/ )
		*/
		function tokenize() {

			// 8.1. Descriptor tokeniser: Skip whitespace
			collectCharacters(regexLeadingSpaces);

			// 8.2. Let current descriptor be the empty string.
			currentDescriptor = "";

			// 8.3. Let state be in descriptor.
			state = "in descriptor";

			while (true) {

				// 8.4. Let c be the character at position.
				c = input.charAt(pos);

				//  Do the following depending on the value of state.
				//  For the purpose of this step, "EOF" is a special character representing
				//  that position is past the end of input.

				// In descriptor
				if (state === "in descriptor") {
					// Do the following, depending on the value of c:

				  // Space character
				  // If current descriptor is not empty, append current descriptor to
				  // descriptors and let current descriptor be the empty string.
				  // Set state to after descriptor.
					if (isSpace(c)) {
						if (currentDescriptor) {
							descriptors.push(currentDescriptor);
							currentDescriptor = "";
							state = "after descriptor";
						}

					// U+002C COMMA (,)
					// Advance position to the next character in input. If current descriptor
					// is not empty, append current descriptor to descriptors. Jump to the step
					// labeled descriptor parser.
					} else if (c === ",") {
						pos += 1;
						if (currentDescriptor) {
							descriptors.push(currentDescriptor);
						}
						parseDescriptors();
						return;

					// U+0028 LEFT PARENTHESIS (()
					// Append c to current descriptor. Set state to in parens.
					} else if (c === "\u0028") {
						currentDescriptor = currentDescriptor + c;
						state = "in parens";

					// EOF
					// If current descriptor is not empty, append current descriptor to
					// descriptors. Jump to the step labeled descriptor parser.
					} else if (c === "") {
						if (currentDescriptor) {
							descriptors.push(currentDescriptor);
						}
						parseDescriptors();
						return;

					// Anything else
					// Append c to current descriptor.
					} else {
						currentDescriptor = currentDescriptor + c;
					}
				// (end "in descriptor"

				// In parens
				} else if (state === "in parens") {

					// U+0029 RIGHT PARENTHESIS ())
					// Append c to current descriptor. Set state to in descriptor.
					if (c === ")") {
						currentDescriptor = currentDescriptor + c;
						state = "in descriptor";

					// EOF
					// Append current descriptor to descriptors. Jump to the step labeled
					// descriptor parser.
					} else if (c === "") {
						descriptors.push(currentDescriptor);
						parseDescriptors();
						return;

					// Anything else
					// Append c to current descriptor.
					} else {
						currentDescriptor = currentDescriptor + c;
					}

				// After descriptor
				} else if (state === "after descriptor") {

					// Do the following, depending on the value of c:
					// Space character: Stay in this state.
					if (isSpace(c)) {

					// EOF: Jump to the step labeled descriptor parser.
					} else if (c === "") {
						parseDescriptors();
						return;

					// Anything else
					// Set state to in descriptor. Set position to the previous character in input.
					} else {
						state = "in descriptor";
						pos -= 1;

					}
				}

				// Advance position to the next character in input.
				pos += 1;

			// Repeat this step.
			} // (close while true loop)
		}

		// 4. Splitting loop: Collect a sequence of characters that are space
		//    characters or U+002C COMMA characters. If any U+002C COMMA characters
		//    were collected, that is a parse error.
		while (true) {
			collectCharacters(regexLeadingCommasOrSpaces);

			// 5. If position is past the end of input, return candidates and abort these steps.
			if (pos >= inputLength) {
				return candidates; // (we're done, this is the sole return path)
			}

			// 6. Collect a sequence of characters that are not space characters,
			//    and let that be url.
			url = collectCharacters(regexLeadingNotSpaces);

			// 7. Let descriptors be a new empty list.
			descriptors = [];

			// 8. If url ends with a U+002C COMMA character (,), follow these substeps:
			//		(1). Remove all trailing U+002C COMMA characters from url. If this removed
			//         more than one character, that is a parse error.
			if (url.slice(-1) === ",") {
				url = url.replace(regexTrailingCommas, "");
				// (Jump ahead to step 9 to skip tokenization and just push the candidate).
				parseDescriptors();

			//	Otherwise, follow these substeps:
			} else {
				tokenize();
			} // (close else of step 8)

		// 16. Return to the step labeled splitting loop.
		} // (Close of big while loop.)
	}
function parseSrcset(input, set) {

		function collectCharacters(regEx) {
			var chars,
			    match = regEx.exec(input.substring(pos));
			if (match) {
				chars = match[ 0 ];
				pos += chars.length;
				return chars;
			}
		}

		var inputLength = input.length,
		    url,
		    descriptors,
		    currentDescriptor,
		    state,
		    c,

		    
		    
		    pos = 0,

		    
		    candidates = [];

		
		
		
		
		function parseDescriptors() {

			
			var pError = false,

			
			
			
			    w, d, h, i,
			    candidate = {},
			    desc, lastChar, value, intVal, floatVal;

			
			
			for (i = 0 ; i < descriptors.length; i++) {
				desc = descriptors[ i ];

				lastChar = desc[ desc.length - 1 ];
				value = desc.substring(0, desc.length - 1);
				intVal = parseInt(value, 10);
				floatVal = parseFloat(value);

				
				
				if (regexNonNegativeInteger.test(value) && (lastChar === "w")) {

					
					if (w || d) {pError = true;}

					
					
					
					if (intVal === 0) {pError = true;} else {w = intVal;}

				
				
				} else if (regexFloatingPoint.test(value) && (lastChar === "x")) {

					
					
					if (w || d || h) {pError = true;}

					
					
					
					if (floatVal < 0) {pError = true;} else {d = floatVal;}

				
				
				} else if (regexNonNegativeInteger.test(value) && (lastChar === "h")) {

					
					if (h || d) {pError = true;}

					
					
					
					if (intVal === 0) {pError = true;} else {h = intVal;}

				
				} else {pError = true;}
			} 

			
			
			
			if (!pError) {
				candidate.url = url;

				if (w) { candidate.w = w;}
				if (d) { candidate.d = d;}
				if (h) { candidate.h = h;}
				if (!h && !d && !w) {candidate.d = 1;}
				if (candidate.d === 1) {set.has1x = true;}
				candidate.set = set;

				candidates.push(candidate);
			}
		} 

		
		function tokenize() {

			
			collectCharacters(regexLeadingSpaces);

			
			currentDescriptor = "";

			
			state = "in descriptor";

			while (true) {

				
				c = input.charAt(pos);

				
				
				

				
				if (state === "in descriptor") {
					

				  
				  
				  
				  
					if (isSpace(c)) {
						if (currentDescriptor) {
							descriptors.push(currentDescriptor);
							currentDescriptor = "";
							state = "after descriptor";
						}

					
					
					
					
					} else if (c === ",") {
						pos += 1;
						if (currentDescriptor) {
							descriptors.push(currentDescriptor);
						}
						parseDescriptors();
						return;

					
					
					} else if (c === "\u0028") {
						currentDescriptor = currentDescriptor + c;
						state = "in parens";

					
					
					
					} else if (c === "") {
						if (currentDescriptor) {
							descriptors.push(currentDescriptor);
						}
						parseDescriptors();
						return;

					
					
					} else {
						currentDescriptor = currentDescriptor + c;
					}
				

				
				} else if (state === "in parens") {

					
					
					if (c === ")") {
						currentDescriptor = currentDescriptor + c;
						state = "in descriptor";

					
					
					
					} else if (c === "") {
						descriptors.push(currentDescriptor);
						parseDescriptors();
						return;

					
					
					} else {
						currentDescriptor = currentDescriptor + c;
					}

				
				} else if (state === "after descriptor") {

					
					
					if (isSpace(c)) {

					
					} else if (c === "") {
						parseDescriptors();
						return;

					
					
					} else {
						state = "in descriptor";
						pos -= 1;

					}
				}

				
				pos += 1;

			
			} 
		}

		
		
		
		while (true) {
			collectCharacters(regexLeadingCommasOrSpaces);

			
			if (pos >= inputLength) {
				return candidates; 
			}

			
			
			url = collectCharacters(regexLeadingNotSpaces);

			
			descriptors = [];

			
			
			
			if (url.slice(-1) === ",") {
				url = url.replace(regexTrailingCommas, "");
				
				parseDescriptors();

			
			} else {
				tokenize();
			} 

		
		} 
	}
function parseSrcset ( input , set ) { function collectCharacters ( regEx ) { var chars , match = regEx . exec ( input . substring ( pos ) ) ; if ( match ) { chars = match [ 0 ] ; pos += chars . length ; return chars ; } } var inputLength = input . length , url , descriptors , currentDescriptor , state , c , // 2. Let position be a pointer into input, initially pointing at the start //    of the string. pos = 0 , // 3. Let candidates be an initially empty source set. candidates = [ ] ; /**
		* Adds descriptor properties to a candidate, pushes to the candidates array
		* @return undefined
		*/ // (Declared outside of the while loop so that it's only created once. // (This fn is defined before it is used, in order to pass JSHINT. // Unfortunately this breaks the sequencing of the spec comments. :/ ) function parseDescriptors ( ) { // 9. Descriptor parser: Let error be no. var pError = false , // 10. Let width be absent. // 11. Let density be absent. // 12. Let future-compat-h be absent. (We're implementing it now as h) w , d , h , i , candidate = { } , desc , lastChar , value , intVal , floatVal ; // 13. For each descriptor in descriptors, run the appropriate set of steps // from the following list: for ( i = 0 ; i < descriptors . length ; i ++ ) { desc = descriptors [ i ] ; lastChar = desc [ desc . length - 1 ] ; value = desc . substring ( 0 , desc . length - 1 ) ; intVal = parseInt ( value , 10 ) ; floatVal = parseFloat ( value ) ; // If the descriptor consists of a valid non-negative integer followed by // a U+0077 LATIN SMALL LETTER W character if ( regexNonNegativeInteger . test ( value ) && ( lastChar === "w" ) ) { // If width and density are not both absent, then let error be yes. if ( w || d ) { pError = true ; } // Apply the rules for parsing non-negative integers to the descriptor. // If the result is zero, let error be yes. // Otherwise, let width be the result. if ( intVal === 0 ) { pError = true ; } else { w = intVal ; } // If the descriptor consists of a valid floating-point number followed by // a U+0078 LATIN SMALL LETTER X character } else if ( regexFloatingPoint . test ( value ) && ( lastChar === "x" ) ) { // If width, density and future-compat-h are not all absent, then let error // be yes. if ( w || d || h ) { pError = true ; } // Apply the rules for parsing floating-point number values to the descriptor. // If the result is less than zero, let error be yes. Otherwise, let density // be the result. if ( floatVal < 0 ) { pError = true ; } else { d = floatVal ; } // If the descriptor consists of a valid non-negative integer followed by // a U+0068 LATIN SMALL LETTER H character } else if ( regexNonNegativeInteger . test ( value ) && ( lastChar === "h" ) ) { // If height and density are not both absent, then let error be yes. if ( h || d ) { pError = true ; } // Apply the rules for parsing non-negative integers to the descriptor. // If the result is zero, let error be yes. Otherwise, let future-compat-h // be the result. if ( intVal === 0 ) { pError = true ; } else { h = intVal ; } // Anything else, Let error be yes. } else { pError = true ; } } // (close step 13 for loop) // 15. If error is still no, then append a new image source to candidates whose // URL is url, associated with a width width if not absent and a pixel // density density if not absent. Otherwise, there is a parse error. if ( ! pError ) { candidate . url = url ; if ( w ) { candidate . w = w ; } if ( d ) { candidate . d = d ; } if ( h ) { candidate . h = h ; } if ( ! h && ! d && ! w ) { candidate . d = 1 ; } if ( candidate . d === 1 ) { set . has1x = true ; } candidate . set = set ; candidates . push ( candidate ) ; } } // (close parseDescriptors fn) /**
		* Tokenizes descriptor properties prior to parsing
		* Returns undefined.
		* (Again, this fn is defined before it is used, in order to pass JSHINT.
		* Unfortunately this breaks the logical sequencing of the spec comments. :/ )
		*/ function tokenize ( ) { // 8.1. Descriptor tokeniser: Skip whitespace collectCharacters ( regexLeadingSpaces ) ; // 8.2. Let current descriptor be the empty string. currentDescriptor = "" ; // 8.3. Let state be in descriptor. state = "in descriptor" ; while ( true ) { // 8.4. Let c be the character at position. c = input . charAt ( pos ) ; //  Do the following depending on the value of state. //  For the purpose of this step, "EOF" is a special character representing //  that position is past the end of input. // In descriptor if ( state === "in descriptor" ) { // Do the following, depending on the value of c: // Space character // If current descriptor is not empty, append current descriptor to // descriptors and let current descriptor be the empty string. // Set state to after descriptor. if ( isSpace ( c ) ) { if ( currentDescriptor ) { descriptors . push ( currentDescriptor ) ; currentDescriptor = "" ; state = "after descriptor" ; } // U+002C COMMA (,) // Advance position to the next character in input. If current descriptor // is not empty, append current descriptor to descriptors. Jump to the step // labeled descriptor parser. } else if ( c === "," ) { pos += 1 ; if ( currentDescriptor ) { descriptors . push ( currentDescriptor ) ; } parseDescriptors ( ) ; return ; // U+0028 LEFT PARENTHESIS (() // Append c to current descriptor. Set state to in parens. } else if ( c === "\u0028" ) { currentDescriptor = currentDescriptor + c ; state = "in parens" ; // EOF // If current descriptor is not empty, append current descriptor to // descriptors. Jump to the step labeled descriptor parser. } else if ( c === "" ) { if ( currentDescriptor ) { descriptors . push ( currentDescriptor ) ; } parseDescriptors ( ) ; return ; // Anything else // Append c to current descriptor. } else { currentDescriptor = currentDescriptor + c ; } // (end "in descriptor" // In parens } else if ( state === "in parens" ) { // U+0029 RIGHT PARENTHESIS ()) // Append c to current descriptor. Set state to in descriptor. if ( c === ")" ) { currentDescriptor = currentDescriptor + c ; state = "in descriptor" ; // EOF // Append current descriptor to descriptors. Jump to the step labeled // descriptor parser. } else if ( c === "" ) { descriptors . push ( currentDescriptor ) ; parseDescriptors ( ) ; return ; // Anything else // Append c to current descriptor. } else { currentDescriptor = currentDescriptor + c ; } // After descriptor } else if ( state === "after descriptor" ) { // Do the following, depending on the value of c: // Space character: Stay in this state. if ( isSpace ( c ) ) { // EOF: Jump to the step labeled descriptor parser. } else if ( c === "" ) { parseDescriptors ( ) ; return ; // Anything else // Set state to in descriptor. Set position to the previous character in input. } else { state = "in descriptor" ; pos -= 1 ; } } // Advance position to the next character in input. pos += 1 ; // Repeat this step. } // (close while true loop) } // 4. Splitting loop: Collect a sequence of characters that are space //    characters or U+002C COMMA characters. If any U+002C COMMA characters //    were collected, that is a parse error. while ( true ) { collectCharacters ( regexLeadingCommasOrSpaces ) ; // 5. If position is past the end of input, return candidates and abort these steps. if ( pos >= inputLength ) { return candidates ; // (we're done, this is the sole return path) } // 6. Collect a sequence of characters that are not space characters, //    and let that be url. url = collectCharacters ( regexLeadingNotSpaces ) ; // 7. Let descriptors be a new empty list. descriptors = [ ] ; // 8. If url ends with a U+002C COMMA character (,), follow these substeps: //		(1). Remove all trailing U+002C COMMA characters from url. If this removed //         more than one character, that is a parse error. if ( url . slice ( - 1 ) === "," ) { url = url . replace ( regexTrailingCommas , "" ) ; // (Jump ahead to step 9 to skip tokenization and just push the candidate). parseDescriptors ( ) ; //	Otherwise, follow these substeps: } else { tokenize ( ) ; } // (close else of step 8) // 16. Return to the step labeled splitting loop. } // (Close of big while loop.) }
1. Let input be the value passed to this algorithm. (TO-DO : Explain what "set" argument is here. Maybe choose a more descriptive & more searchable name.  Since passing the "set" in really has nothing to do with parsing proper, I would prefer this assignment eventually go in an external fn.)
1 . Let input be the value passed to this algorithm . ( TO - DO : Explain what set argument is here . Maybe choose a more descriptive & more searchable name . Since passing the set in really has nothing to do with parsing proper I would prefer this assignment eventually go in an external fn . )