ecomp-portal-FE/client/bower_components/jquery/src/core.js

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