utils/test/testapi/3rd_party/static/testapi-ui/assets/lib/jquery/src/core.js

   1 /* global Symbol */
   2 // Defining this global in .eslintrc.json would create a danger of using the global
   3 // unguarded in another place, it seems safer to define global only for this module
   4
   5 define( [
   6         "./var/arr",
   7         "./var/document",
   8         "./var/getProto",
   9         "./var/slice",
  10         "./var/concat",
  11         "./var/push",
  12         "./var/indexOf",
  13         "./var/class2type",
  14         "./var/toString",
  15         "./var/hasOwn",
  16         "./var/fnToString",
  17         "./var/ObjectFunctionString",
  18         "./var/support",
  19         "./core/DOMEval"
  20 ], function( arr, document, getProto, slice, concat, push, indexOf,
  21         class2type, toString, hasOwn, fnToString, ObjectFunctionString,
  22         support, DOMEval ) {
  23
  24 "use strict";
  25
  26 var
  27         version = "3.2.1",
  28
  29         // Define a local copy of jQuery
  30         jQuery = function( selector, context ) {
  31
  32                 // The jQuery object is actually just the init constructor 'enhanced'
  33                 // Need init if jQuery is called (just allow error to be thrown if not included)
  34                 return new jQuery.fn.init( selector, context );
  35         },
  36
  37         // Support: Android <=4.0 only
  38         // Make sure we trim BOM and NBSP
  39         rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
  40
  41         // Matches dashed string for camelizing
  42         rmsPrefix = /^-ms-/,
  43         rdashAlpha = /-([a-z])/g,
  44
  45         // Used by jQuery.camelCase as callback to replace()
  46         fcamelCase = function( all, letter ) {
  47                 return letter.toUpperCase();
  48         };
  49
  50 jQuery.fn = jQuery.prototype = {
  51
  52         // The current version of jQuery being used
  53         jquery: version,
  54
  55         constructor: jQuery,
  56
  57         // The default length of a jQuery object is 0
  58         length: 0,
  59
  60         toArray: function() {
  61                 return slice.call( this );
  62         },
  63
  64         // Get the Nth element in the matched element set OR
  65         // Get the whole matched element set as a clean array
  66         get: function( num ) {
  67
  68                 // Return all the elements in a clean array
  69                 if ( num == null ) {
  70                         return slice.call( this );
  71                 }
  72
  73                 // Return just the one element from the set
  74                 return num < 0 ? this[ num + this.length ] : this[ num ];
  75         },
  76
  77         // Take an array of elements and push it onto the stack
  78         // (returning the new matched element set)
  79         pushStack: function( elems ) {
  80
  81                 // Build a new jQuery matched element set
  82                 var ret = jQuery.merge( this.constructor(), elems );
  83
  84                 // Add the old object onto the stack (as a reference)
  85                 ret.prevObject = this;
  86
  87                 // Return the newly-formed element set
  88                 return ret;
  89         },
  90
  91         // Execute a callback for every element in the matched set.
  92         each: function( callback ) {
  93                 return jQuery.each( this, callback );
  94         },
  95
  96         map: function( callback ) {
  97                 return this.pushStack( jQuery.map( this, function( elem, i ) {
  98                         return callback.call( elem, i, elem );
  99                 } ) );
 100         },
 101
 102         slice: function() {
 103                 return this.pushStack( slice.apply( this, arguments ) );
 104         },
 105
 106         first: function() {
 107                 return this.eq( 0 );
 108         },
 109
 110         last: function() {
 111                 return this.eq( -1 );
 112         },
 113
 114         eq: function( i ) {
 115                 var len = this.length,
 116                         j = +i + ( i < 0 ? len : 0 );
 117                 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
 118         },
 119
 120         end: function() {
 121                 return this.prevObject || this.constructor();
 122         },
 123
 124         // For internal use only.
 125         // Behaves like an Array's method, not like a jQuery method.
 126         push: push,
 127         sort: arr.sort,
 128         splice: arr.splice
 129 };
 130
 131 jQuery.extend = jQuery.fn.extend = function() {
 132         var options, name, src, copy, copyIsArray, clone,
 133                 target = arguments[ 0 ] || {},
 134                 i = 1,
 135                 length = arguments.length,
 136                 deep = false;
 137
 138         // Handle a deep copy situation
 139         if ( typeof target === "boolean" ) {
 140                 deep = target;
 141
 142                 // Skip the boolean and the target
 143                 target = arguments[ i ] || {};
 144                 i++;
 145         }
 146
 147         // Handle case when target is a string or something (possible in deep copy)
 148         if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
 149                 target = {};
 150         }
 151
 152         // Extend jQuery itself if only one argument is passed
 153         if ( i === length ) {
 154                 target = this;
 155                 i--;
 156         }
 157
 158         for ( ; i < length; i++ ) {
 159
 160                 // Only deal with non-null/undefined values
 161                 if ( ( options = arguments[ i ] ) != null ) {
 162
 163                         // Extend the base object
 164                         for ( name in options ) {
 165                                 src = target[ name ];
 166                                 copy = options[ name ];
 167
 168                                 // Prevent never-ending loop
 169                                 if ( target === copy ) {
 170                                         continue;
 171                                 }
 172
 173                                 // Recurse if we're merging plain objects or arrays
 174                                 if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
 175                                         ( copyIsArray = Array.isArray( copy ) ) ) ) {
 176
 177                                         if ( copyIsArray ) {
 178                                                 copyIsArray = false;
 179                                                 clone = src && Array.isArray( src ) ? src : [];
 180
 181                                         } else {
 182                                                 clone = src && jQuery.isPlainObject( src ) ? src : {};
 183                                         }
 184
 185                                         // Never move original objects, clone them
 186                                         target[ name ] = jQuery.extend( deep, clone, copy );
 187
 188                                 // Don't bring in undefined values
 189                                 } else if ( copy !== undefined ) {
 190                                         target[ name ] = copy;
 191                                 }
 192                         }
 193                 }
 194         }
 195
 196         // Return the modified object
 197         return target;
 198 };
 199
 200 jQuery.extend( {
 201
 202         // Unique for each copy of jQuery on the page
 203         expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
 204
 205         // Assume jQuery is ready without the ready module
 206         isReady: true,
 207
 208         error: function( msg ) {
 209                 throw new Error( msg );
 210         },
 211
 212         noop: function() {},
 213
 214         isFunction: function( obj ) {
 215                 return jQuery.type( obj ) === "function";
 216         },
 217
 218         isWindow: function( obj ) {
 219                 return obj != null && obj === obj.window;
 220         },
 221
 222         isNumeric: function( obj ) {
 223
 224                 // As of jQuery 3.0, isNumeric is limited to
 225                 // strings and numbers (primitives or objects)
 226                 // that can be coerced to finite numbers (gh-2662)
 227                 var type = jQuery.type( obj );
 228                 return ( type === "number" || type === "string" ) &&
 229
 230                         // parseFloat NaNs numeric-cast false positives ("")
 231                         // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
 232                         // subtraction forces infinities to NaN
 233                         !isNaN( obj - parseFloat( obj ) );
 234         },
 235
 236         isPlainObject: function( obj ) {
 237                 var proto, Ctor;
 238
 239                 // Detect obvious negatives
 240                 // Use toString instead of jQuery.type to catch host objects
 241                 if ( !obj || toString.call( obj ) !== "[object Object]" ) {
 242                         return false;
 243                 }
 244
 245                 proto = getProto( obj );
 246
 247                 // Objects with no prototype (e.g., `Object.create( null )`) are plain
 248                 if ( !proto ) {
 249                         return true;
 250                 }
 251
 252                 // Objects with prototype are plain iff they were constructed by a global Object function
 253                 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
 254                 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
 255         },
 256
 257         isEmptyObject: function( obj ) {
 258
 259                 /* eslint-disable no-unused-vars */
 260                 // See https://github.com/eslint/eslint/issues/6125
 261                 var name;
 262
 263                 for ( name in obj ) {
 264                         return false;
 265                 }
 266                 return true;
 267         },
 268
 269         type: function( obj ) {
 270                 if ( obj == null ) {
 271                         return obj + "";
 272                 }
 273
 274                 // Support: Android <=2.3 only (functionish RegExp)
 275                 return typeof obj === "object" || typeof obj === "function" ?
 276                         class2type[ toString.call( obj ) ] || "object" :
 277                         typeof obj;
 278         },
 279
 280         // Evaluates a script in a global context
 281         globalEval: function( code ) {
 282                 DOMEval( code );
 283         },
 284
 285         // Convert dashed to camelCase; used by the css and data modules
 286         // Support: IE <=9 - 11, Edge 12 - 13
 287         // Microsoft forgot to hump their vendor prefix (#9572)
 288         camelCase: function( string ) {
 289                 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
 290         },
 291
 292         each: function( obj, callback ) {
 293                 var length, i = 0;
 294
 295                 if ( isArrayLike( obj ) ) {
 296                         length = obj.length;
 297                         for ( ; i < length; i++ ) {
 298                                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 299                                         break;
 300                                 }
 301                         }
 302                 } else {
 303                         for ( i in obj ) {
 304                                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 305                                         break;
 306                                 }
 307                         }
 308                 }
 309
 310                 return obj;
 311         },
 312
 313         // Support: Android <=4.0 only
 314         trim: function( text ) {
 315                 return text == null ?
 316                         "" :
 317                         ( text + "" ).replace( rtrim, "" );
 318         },
 319
 320         // results is for internal usage only
 321         makeArray: function( arr, results ) {
 322                 var ret = results || [];
 323
 324                 if ( arr != null ) {
 325                         if ( isArrayLike( Object( arr ) ) ) {
 326                                 jQuery.merge( ret,
 327                                         typeof arr === "string" ?
 328                                         [ arr ] : arr
 329                                 );
 330                         } else {
 331                                 push.call( ret, arr );
 332                         }
 333                 }
 334
 335                 return ret;
 336         },
 337
 338         inArray: function( elem, arr, i ) {
 339                 return arr == null ? -1 : indexOf.call( arr, elem, i );
 340         },
 341
 342         // Support: Android <=4.0 only, PhantomJS 1 only
 343         // push.apply(_, arraylike) throws on ancient WebKit
 344         merge: function( first, second ) {
 345                 var len = +second.length,
 346                         j = 0,
 347                         i = first.length;
 348
 349                 for ( ; j < len; j++ ) {
 350                         first[ i++ ] = second[ j ];
 351                 }
 352
 353                 first.length = i;
 354
 355                 return first;
 356         },
 357
 358         grep: function( elems, callback, invert ) {
 359                 var callbackInverse,
 360                         matches = [],
 361                         i = 0,
 362                         length = elems.length,
 363                         callbackExpect = !invert;
 364
 365                 // Go through the array, only saving the items
 366                 // that pass the validator function
 367                 for ( ; i < length; i++ ) {
 368                         callbackInverse = !callback( elems[ i ], i );
 369                         if ( callbackInverse !== callbackExpect ) {
 370                                 matches.push( elems[ i ] );
 371                         }
 372                 }
 373
 374                 return matches;
 375         },
 376
 377         // arg is for internal usage only
 378         map: function( elems, callback, arg ) {
 379                 var length, value,
 380                         i = 0,
 381                         ret = [];
 382
 383                 // Go through the array, translating each of the items to their new values
 384                 if ( isArrayLike( elems ) ) {
 385                         length = elems.length;
 386                         for ( ; i < length; i++ ) {
 387                                 value = callback( elems[ i ], i, arg );
 388
 389                                 if ( value != null ) {
 390                                         ret.push( value );
 391                                 }
 392                         }
 393
 394                 // Go through every key on the object,
 395                 } else {
 396                         for ( i in elems ) {
 397                                 value = callback( elems[ i ], i, arg );
 398
 399                                 if ( value != null ) {
 400                                         ret.push( value );
 401                                 }
 402                         }
 403                 }
 404
 405                 // Flatten any nested arrays
 406                 return concat.apply( [], ret );
 407         },
 408
 409         // A global GUID counter for objects
 410         guid: 1,
 411
 412         // Bind a function to a context, optionally partially applying any
 413         // arguments.
 414         proxy: function( fn, context ) {
 415                 var tmp, args, proxy;
 416
 417                 if ( typeof context === "string" ) {
 418                         tmp = fn[ context ];
 419                         context = fn;
 420                         fn = tmp;
 421                 }
 422
 423                 // Quick check to determine if target is callable, in the spec
 424                 // this throws a TypeError, but we will just return undefined.
 425                 if ( !jQuery.isFunction( fn ) ) {
 426                         return undefined;
 427                 }
 428
 429                 // Simulated bind
 430                 args = slice.call( arguments, 2 );
 431                 proxy = function() {
 432                         return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
 433                 };
 434
 435                 // Set the guid of unique handler to the same of original handler, so it can be removed
 436                 proxy.guid = fn.guid = fn.guid || jQuery.guid++;
 437
 438                 return proxy;
 439         },
 440
 441         now: Date.now,
 442
 443         // jQuery.support is not used in Core but other projects attach their
 444         // properties to it so it needs to exist.
 445         support: support
 446 } );
 447
 448 if ( typeof Symbol === "function" ) {
 449         jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
 450 }
 451
 452 // Populate the class2type map
 453 jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
 454 function( i, name ) {
 455         class2type[ "[object " + name + "]" ] = name.toLowerCase();
 456 } );
 457
 458 function isArrayLike( obj ) {
 459
 460         // Support: real iOS 8.2 only (not reproducible in simulator)
 461         // `in` check used to prevent JIT error (gh-2145)
 462         // hasOwn isn't used here due to false negatives
 463         // regarding Nodelist length in IE
 464         var length = !!obj && "length" in obj && obj.length,
 465                 type = jQuery.type( obj );
 466
 467         if ( type === "function" || jQuery.isWindow( obj ) ) {
 468                 return false;
 469         }
 470
 471         return type === "array" || length === 0 ||
 472                 typeof length === "number" && length > 0 && ( length - 1 ) in obj;
 473 }
 474
 475 return jQuery;
 476 } );