tools/side_chain_tool/web/node_modules/jquery/src/selector-native.js

   1 define( [
   2         "./core",
   3         "./var/document",
   4         "./var/documentElement",
   5         "./var/hasOwn",
   6         "./var/indexOf"
   7 ], function( jQuery, document, documentElement, hasOwn, indexOf ) {
   8
   9 "use strict";
  10
  11 /*
  12  * Optional (non-Sizzle) selector module for custom builds.
  13  *
  14  * Note that this DOES NOT SUPPORT many documented jQuery
  15  * features in exchange for its smaller size:
  16  *
  17  * Attribute not equal selector
  18  * Positional selectors (:first; :eq(n); :odd; etc.)
  19  * Type selectors (:input; :checkbox; :button; etc.)
  20  * State-based selectors (:animated; :visible; :hidden; etc.)
  21  * :has(selector)
  22  * :not(complex selector)
  23  * custom selectors via Sizzle extensions
  24  * Leading combinators (e.g., $collection.find("> *"))
  25  * Reliable functionality on XML fragments
  26  * Requiring all parts of a selector to match elements under context
  27  *   (e.g., $div.find("div > *") now matches children of $div)
  28  * Matching against non-elements
  29  * Reliable sorting of disconnected nodes
  30  * querySelectorAll bug fixes (e.g., unreliable :focus on WebKit)
  31  *
  32  * If any of these are unacceptable tradeoffs, either use Sizzle or
  33  * customize this stub for the project's specific needs.
  34  */
  35
  36 var hasDuplicate, sortInput,
  37         sortStable = jQuery.expando.split( "" ).sort( sortOrder ).join( "" ) === jQuery.expando,
  38         matches = documentElement.matches ||
  39                 documentElement.webkitMatchesSelector ||
  40                 documentElement.mozMatchesSelector ||
  41                 documentElement.oMatchesSelector ||
  42                 documentElement.msMatchesSelector,
  43
  44         // CSS string/identifier serialization
  45         // https://drafts.csswg.org/cssom/#common-serializing-idioms
  46         rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g,
  47         fcssescape = function( ch, asCodePoint ) {
  48                 if ( asCodePoint ) {
  49
  50                         // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
  51                         if ( ch === "\0" ) {
  52                                 return "\uFFFD";
  53                         }
  54
  55                         // Control characters and (dependent upon position) numbers get escaped as code points
  56                         return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
  57                 }
  58
  59                 // Other potentially-special ASCII characters get backslash-escaped
  60                 return "\\" + ch;
  61         };
  62
  63 function sortOrder( a, b ) {
  64
  65         // Flag for duplicate removal
  66         if ( a === b ) {
  67                 hasDuplicate = true;
  68                 return 0;
  69         }
  70
  71         // Sort on method existence if only one input has compareDocumentPosition
  72         var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  73         if ( compare ) {
  74                 return compare;
  75         }
  76
  77         // Calculate position if both inputs belong to the same document
  78         compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
  79                 a.compareDocumentPosition( b ) :
  80
  81                 // Otherwise we know they are disconnected
  82                 1;
  83
  84         // Disconnected nodes
  85         if ( compare & 1 ) {
  86
  87                 // Choose the first element that is related to our preferred document
  88                 if ( a === document || a.ownerDocument === document &&
  89                         jQuery.contains( document, a ) ) {
  90                         return -1;
  91                 }
  92                 if ( b === document || b.ownerDocument === document &&
  93                         jQuery.contains( document, b ) ) {
  94                         return 1;
  95                 }
  96
  97                 // Maintain original order
  98                 return sortInput ?
  99                         ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
 100                         0;
 101         }
 102
 103         return compare & 4 ? -1 : 1;
 104 }
 105
 106 function uniqueSort( results ) {
 107         var elem,
 108                 duplicates = [],
 109                 j = 0,
 110                 i = 0;
 111
 112         hasDuplicate = false;
 113         sortInput = !sortStable && results.slice( 0 );
 114         results.sort( sortOrder );
 115
 116         if ( hasDuplicate ) {
 117                 while ( ( elem = results[ i++ ] ) ) {
 118                         if ( elem === results[ i ] ) {
 119                                 j = duplicates.push( i );
 120                         }
 121                 }
 122                 while ( j-- ) {
 123                         results.splice( duplicates[ j ], 1 );
 124                 }
 125         }
 126
 127         // Clear input after sorting to release objects
 128         // See https://github.com/jquery/sizzle/pull/225
 129         sortInput = null;
 130
 131         return results;
 132 }
 133
 134 function escape( sel ) {
 135         return ( sel + "" ).replace( rcssescape, fcssescape );
 136 }
 137
 138 jQuery.extend( {
 139         uniqueSort: uniqueSort,
 140         unique: uniqueSort,
 141         escapeSelector: escape,
 142         find: function( selector, context, results, seed ) {
 143                 var elem, nodeType,
 144                         i = 0;
 145
 146                 results = results || [];
 147                 context = context || document;
 148
 149                 // Same basic safeguard as Sizzle
 150                 if ( !selector || typeof selector !== "string" ) {
 151                         return results;
 152                 }
 153
 154                 // Early return if context is not an element or document
 155                 if ( ( nodeType = context.nodeType ) !== 1 && nodeType !== 9 ) {
 156                         return [];
 157                 }
 158
 159                 if ( seed ) {
 160                         while ( ( elem = seed[ i++ ] ) ) {
 161                                 if ( jQuery.find.matchesSelector( elem, selector ) ) {
 162                                         results.push( elem );
 163                                 }
 164                         }
 165                 } else {
 166                         jQuery.merge( results, context.querySelectorAll( selector ) );
 167                 }
 168
 169                 return results;
 170         },
 171         text: function( elem ) {
 172                 var node,
 173                         ret = "",
 174                         i = 0,
 175                         nodeType = elem.nodeType;
 176
 177                 if ( !nodeType ) {
 178
 179                         // If no nodeType, this is expected to be an array
 180                         while ( ( node = elem[ i++ ] ) ) {
 181
 182                                 // Do not traverse comment nodes
 183                                 ret += jQuery.text( node );
 184                         }
 185                 } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
 186
 187                         // Use textContent for elements
 188                         return elem.textContent;
 189                 } else if ( nodeType === 3 || nodeType === 4 ) {
 190                         return elem.nodeValue;
 191                 }
 192
 193                 // Do not include comment or processing instruction nodes
 194
 195                 return ret;
 196         },
 197         contains: function( a, b ) {
 198                 var adown = a.nodeType === 9 ? a.documentElement : a,
 199                         bup = b && b.parentNode;
 200                 return a === bup || !!( bup && bup.nodeType === 1 && adown.contains( bup ) );
 201         },
 202         isXMLDoc: function( elem ) {
 203
 204                 // documentElement is verified for cases where it doesn't yet exist
 205                 // (such as loading iframes in IE - #4833)
 206                 var documentElement = elem && ( elem.ownerDocument || elem ).documentElement;
 207                 return documentElement ? documentElement.nodeName !== "HTML" : false;
 208         },
 209         expr: {
 210                 attrHandle: {},
 211                 match: {
 212                         bool: new RegExp( "^(?:checked|selected|async|autofocus|autoplay|controls|defer" +
 213                                 "|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)$", "i" ),
 214                         needsContext: /^[\x20\t\r\n\f]*[>+~]/
 215                 }
 216         }
 217 } );
 218
 219 jQuery.extend( jQuery.find, {
 220         matches: function( expr, elements ) {
 221                 return jQuery.find( expr, null, null, elements );
 222         },
 223         matchesSelector: function( elem, expr ) {
 224                 return matches.call( elem, expr );
 225         },
 226         attr: function( elem, name ) {
 227                 var fn = jQuery.expr.attrHandle[ name.toLowerCase() ],
 228
 229                         // Don't get fooled by Object.prototype properties (jQuery #13807)
 230                         value = fn && hasOwn.call( jQuery.expr.attrHandle, name.toLowerCase() ) ?
 231                                 fn( elem, name, jQuery.isXMLDoc( elem ) ) :
 232                                 undefined;
 233                 return value !== undefined ? value : elem.getAttribute( name );
 234         }
 235 } );
 236
 237 } );