scratch – Diff between revs 58 and 125

Subversion Repositories:

?pathlinks?

Rev 58 – Details – Blame – Last modification – View Log

Only display areas with differences – Ignore whitespace

-define( [
+define([
-	"./core",
+	"./core"
-	"./var/document",
-	"./var/documentElement",
+], function( jQuery ) {
-	"./var/hasOwn",
-	"./var/indexOf"
-], function( jQuery, document, documentElement, hasOwn, indexOf ) {
-"use strict";
 /*
  * Optional (non-Sizzle) selector module for custom builds.
+ *
  * Note that this DOES NOT SUPPORT many documented jQuery
  * features in exchange for its smaller size:
+ *
  * Attribute not equal selector
  * Positional selectors (:first; :eq(n); :odd; etc.)
  * Type selectors (:input; :checkbox; :button; etc.)
  * State-based selectors (:animated; :visible; :hidden; etc.)
  * :has(selector)
  * :not(complex selector)
  * custom selectors via Sizzle extensions
  * Leading combinators (e.g., $collection.find("> *"))
  * Reliable functionality on XML fragments
  * Requiring all parts of a selector to match elements under context
  *   (e.g., $div.find("div > *") now matches children of $div)
  * Matching against non-elements
  * Reliable sorting of disconnected nodes
  * querySelectorAll bug fixes (e.g., unreliable :focus on WebKit)
+ *
  * If any of these are unacceptable tradeoffs, either use Sizzle or
  * customize this stub for the project's specific needs.
  */
-var hasDuplicate, sortInput,
+var docElem = window.document.documentElement,
-	sortStable = jQuery.expando.split( "" ).sort( sortOrder ).join( "" ) === jQuery.expando,
+	selector_hasDuplicate,
-	matches = documentElement.matches ||
+	matches = docElem.matches ||
-		documentElement.webkitMatchesSelector ||
+		docElem.webkitMatchesSelector ||
-		documentElement.mozMatchesSelector ||
+		docElem.mozMatchesSelector ||
-		documentElement.oMatchesSelector ||
+		docElem.oMatchesSelector ||
+		docElem.msMatchesSelector,
+	selector_sortOrder = function( a, b ) {
+		// Flag for duplicate removal
+		if ( a === b ) {
+			selector_hasDuplicate = true;
+			return 0;
+		}
-		documentElement.msMatchesSelector,
+		var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b );
+		if ( compare ) {
+			// Disconnected nodes
+			if ( compare & 1 ) {
-	// CSS string/identifier serialization
-	// https://drafts.csswg.org/cssom/#common-serializing-idioms
+				// Choose the first element that is related to our document
+				if ( a === document || jQuery.contains(document, a) ) {
+					return -1;
-	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g,
+				}
-	fcssescape = function( ch, asCodePoint ) {
+				if ( b === document || jQuery.contains(document, b) ) {
+					return 1;
-		if ( asCodePoint ) {
+				}
-			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
-			if ( ch === "\0" ) {
+				// Maintain original order
-				return "\uFFFD";
+				return 0;
-			}
+			}
 			// Control characters and (dependent upon position) numbers get escaped as code points
-			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+			return compare & 4 ? -1 : 1;
 		}
-		// Other potentially-special ASCII characters get backslash-escaped
-		return "\\" + ch;
-	};
-function sortOrder( a, b ) {
-	// Flag for duplicate removal
-	if ( a === b ) {
-		hasDuplicate = true;
-		return 0;
-	}
-	// Sort on method existence if only one input has compareDocumentPosition
-	var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
-	if ( compare ) {
-		return compare;
-	}
-	// Calculate position if both inputs belong to the same document
-	compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
-		a.compareDocumentPosition( b ) :
-		// Otherwise we know they are disconnected
-;
-	// Disconnected nodes
-	if ( compare & 1 ) {
-		// Choose the first element that is related to our preferred document
-		if ( a === document || a.ownerDocument === document &&
-			jQuery.contains( document, a ) ) {
-			return -1;
-		}
-		if ( b === document || b.ownerDocument === document &&
-			jQuery.contains( document, b ) ) {
-			return 1;
-		}
-		// Maintain original order
-		return sortInput ?
-			( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
-;
-	}
-	return compare & 4 ? -1 : 1;
-}
-function uniqueSort( results ) {
-	var elem,
-		duplicates = [],
-		j = 0,
-		i = 0;
-	hasDuplicate = false;
-	sortInput = !sortStable && results.slice( 0 );
-	results.sort( sortOrder );
-	if ( hasDuplicate ) {
-		while ( ( elem = results[ i++ ] ) ) {
-			if ( elem === results[ i ] ) {
-				j = duplicates.push( i );
-			}
-		}
-		while ( j-- ) {
-			results.splice( duplicates[ j ], 1 );
-		}
-	}
-	// Clear input after sorting to release objects
-	// See https://github.com/jquery/sizzle/pull/225
-	sortInput = null;
-	return results;
-}
-function escape( sel ) {
+		// Not directly comparable, sort on existence of method
-	return ( sel + "" ).replace( rcssescape, fcssescape );
-}
-jQuery.extend( {
+		return a.compareDocumentPosition ? -1 : 1;
-	uniqueSort: uniqueSort,
+	};
 	unique: uniqueSort,
-	escapeSelector: escape,
+jQuery.extend({
 	find: function( selector, context, results, seed ) {
 		var elem, nodeType,
 			i = 0;
 		results = results || [];
 		context = context || document;
 		// Same basic safeguard as Sizzle
 		if ( !selector || typeof selector !== "string" ) {
 			return results;
+		}
 		// Early return if context is not an element or document
-		if ( ( nodeType = context.nodeType ) !== 1 && nodeType !== 9 ) {
+		if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
 			return [];
+		}
 		if ( seed ) {
-			while ( ( elem = seed[ i++ ] ) ) {
+			while ( (elem = seed[i++]) ) {
-				if ( jQuery.find.matchesSelector( elem, selector ) ) {
+				if ( jQuery.find.matchesSelector(elem, selector) ) {
 					results.push( elem );
+				}
+			}
 		} else {
-			jQuery.merge( results, context.querySelectorAll( selector ) );
+			jQuery.merge( results, context.querySelectorAll(selector) );
+		}
+		return results;
+	},
+	unique: function( results ) {
+		var elem,
+			duplicates = [],
+			i = 0,
+			j = 0;
+		selector_hasDuplicate = false;
+		results.sort( selector_sortOrder );
+		if ( selector_hasDuplicate ) {
+			while ( (elem = results[i++]) ) {
+				if ( elem === results[ i ] ) {
+					j = duplicates.push( i );
+				}
+			}
+			while ( j-- ) {
+				results.splice( duplicates[ j ], 1 );
+			}
+		}
 		return results;
 	},
 	text: function( elem ) {
 		var node,
 			ret = "",
 			i = 0,
 			nodeType = elem.nodeType;
 		if ( !nodeType ) {
 			// If no nodeType, this is expected to be an array
-			while ( ( node = elem[ i++ ] ) ) {
+			while ( (node = elem[i++]) ) {
 				// Do not traverse comment nodes
 				ret += jQuery.text( node );
+			}
 		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
 			// Use textContent for elements
 			return elem.textContent;
 		} else if ( nodeType === 3 || nodeType === 4 ) {
 			return elem.nodeValue;
+		}
 		// Do not include comment or processing instruction nodes
 		return ret;
 	},
 	contains: function( a, b ) {
 		var adown = a.nodeType === 9 ? a.documentElement : a,
 			bup = b && b.parentNode;
-		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains( bup ) );
+		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains(bup) );
 	},
 	isXMLDoc: function( elem ) {
-		// documentElement is verified for cases where it doesn't yet exist
-		// (such as loading iframes in IE - #4833)
-		var documentElement = elem && ( elem.ownerDocument || elem ).documentElement;
-		return documentElement ? documentElement.nodeName !== "HTML" : false;
+		return (elem.ownerDocument || elem).documentElement.nodeName !== "HTML";
 	},
 	expr: {
 		attrHandle: {},
 		match: {
-			bool: new RegExp( "^(?:checked|selected|async|autofocus|autoplay|controls|defer" +
-				"|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)$", "i" ),
+			bool: /^(?:checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)$/i,
 			needsContext: /^[\x20\t\r\n\f]*[>+~]/
+		}
+	}
-} );
+});
 jQuery.extend( jQuery.find, {
 	matches: function( expr, elements ) {
 		return jQuery.find( expr, null, null, elements );
 	},
 	matchesSelector: function( elem, expr ) {
 		return matches.call( elem, expr );
 	},
 	attr: function( elem, name ) {
-		var fn = jQuery.expr.attrHandle[ name.toLowerCase() ],
-			// Don't get fooled by Object.prototype properties (jQuery #13807)
-			value = fn && hasOwn.call( jQuery.expr.attrHandle, name.toLowerCase() ) ?
-				fn( elem, name, jQuery.isXMLDoc( elem ) ) :
-				undefined;
-		return value !== undefined ? value : elem.getAttribute( name );
+		return elem.getAttribute( name );
+	}
-} );
+});
-} );
+});