xonecas.io
286
Sf

simple-flask-coffee-sass-boilerplate / files

simple-flask-coffee-sass-boilerplate / bower_components / jquery / src / core.js

11.4 KB
1define([
2	"./var/arr",
3	"./var/slice",
4	"./var/concat",
5	"./var/push",
6	"./var/indexOf",
7	"./var/class2type",
8	"./var/toString",
9	"./var/hasOwn",
10	"./var/support"
11], function( arr, slice, concat, push, indexOf, class2type, toString, hasOwn, support ) {
12
13var
14	// Use the correct document accordingly with window argument (sandbox)
15	document = window.document,
16
17	version = "@VERSION",
18
19	// Define a local copy of jQuery
20	jQuery = function( selector, context ) {
21		// The jQuery object is actually just the init constructor 'enhanced'
22		// Need init if jQuery is called (just allow error to be thrown if not included)
23		return new jQuery.fn.init( selector, context );
24	},
25
26	// Support: Android<4.1
27	// Make sure we trim BOM and NBSP
28	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
29
30	// Matches dashed string for camelizing
31	rmsPrefix = /^-ms-/,
32	rdashAlpha = /-([\da-z])/gi,
33
34	// Used by jQuery.camelCase as callback to replace()
35	fcamelCase = function( all, letter ) {
36		return letter.toUpperCase();
37	};
38
39jQuery.fn = jQuery.prototype = {
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	// (You can seed the arguments with an array of args, but this is
84	// only used internally.)
85	each: function( callback, args ) {
86		return jQuery.each( this, callback, args );
87	},
88
89	map: function( callback ) {
90		return this.pushStack( jQuery.map(this, function( elem, i ) {
91			return callback.call( elem, i, elem );
92		}));
93	},
94
95	slice: function() {
96		return this.pushStack( slice.apply( this, arguments ) );
97	},
98
99	first: function() {
100		return this.eq( 0 );
101	},
102
103	last: function() {
104		return this.eq( -1 );
105	},
106
107	eq: function( i ) {
108		var len = this.length,
109			j = +i + ( i < 0 ? len : 0 );
110		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
111	},
112
113	end: function() {
114		return this.prevObject || this.constructor(null);
115	},
116
117	// For internal use only.
118	// Behaves like an Array's method, not like a jQuery method.
119	push: push,
120	sort: arr.sort,
121	splice: arr.splice
122};
123
124jQuery.extend = jQuery.fn.extend = function() {
125	var options, name, src, copy, copyIsArray, clone,
126		target = arguments[0] || {},
127		i = 1,
128		length = arguments.length,
129		deep = false;
130
131	// Handle a deep copy situation
132	if ( typeof target === "boolean" ) {
133		deep = target;
134
135		// skip the boolean and the target
136		target = arguments[ i ] || {};
137		i++;
138	}
139
140	// Handle case when target is a string or something (possible in deep copy)
141	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
142		target = {};
143	}
144
145	// extend jQuery itself if only one argument is passed
146	if ( i === length ) {
147		target = this;
148		i--;
149	}
150
151	for ( ; i < length; i++ ) {
152		// Only deal with non-null/undefined values
153		if ( (options = arguments[ i ]) != null ) {
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) || (copyIsArray = jQuery.isArray(copy)) ) ) {
166					if ( copyIsArray ) {
167						copyIsArray = false;
168						clone = src && jQuery.isArray(src) ? src : [];
169
170					} else {
171						clone = src && jQuery.isPlainObject(src) ? src : {};
172					}
173
174					// Never move original objects, clone them
175					target[ name ] = jQuery.extend( deep, clone, copy );
176
177				// Don't bring in undefined values
178				} else if ( copy !== undefined ) {
179					target[ name ] = copy;
180				}
181			}
182		}
183	}
184
185	// Return the modified object
186	return target;
187};
188
189jQuery.extend({
190	// Unique for each copy of jQuery on the page
191	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
192
193	// Assume jQuery is ready without the ready module
194	isReady: true,
195
196	error: function( msg ) {
197		throw new Error( msg );
198	},
199
200	noop: function() {},
201
202	// See test/unit/core.js for details concerning isFunction.
203	// Since version 1.3, DOM methods and functions like alert
204	// aren't supported. They return false on IE (#2968).
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		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
217		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
218		// subtraction forces infinities to NaN
219		return !jQuery.isArray( obj ) && obj - parseFloat( obj ) >= 0;
220	},
221
222	isPlainObject: function( obj ) {
223		// Not plain objects:
224		// - Any object or value whose internal [[Class]] property is not "[object Object]"
225		// - DOM nodes
226		// - window
227		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
228			return false;
229		}
230
231		if ( obj.constructor &&
232				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
233			return false;
234		}
235
236		// If the function hasn't returned already, we're confident that
237		// |obj| is a plain object, created by {} or constructed with new Object
238		return true;
239	},
240
241	isEmptyObject: function( obj ) {
242		var name;
243		for ( name in obj ) {
244			return false;
245		}
246		return true;
247	},
248
249	type: function( obj ) {
250		if ( obj == null ) {
251			return obj + "";
252		}
253		// Support: Android < 4.0, iOS < 6 (functionish RegExp)
254		return typeof obj === "object" || typeof obj === "function" ?
255			class2type[ toString.call(obj) ] || "object" :
256			typeof obj;
257	},
258
259	// Evaluates a script in a global context
260	globalEval: function( code ) {
261		var script,
262			indirect = eval;
263
264		code = jQuery.trim( code );
265
266		if ( code ) {
267			// If the code includes a valid, prologue position
268			// strict mode pragma, execute code by injecting a
269			// script tag into the document.
270			if ( code.indexOf("use strict") === 1 ) {
271				script = document.createElement("script");
272				script.text = code;
273				document.head.appendChild( script ).parentNode.removeChild( script );
274			} else {
275			// Otherwise, avoid the DOM node creation, insertion
276			// and removal by using an indirect global eval
277				indirect( code );
278			}
279		}
280	},
281
282	// Convert dashed to camelCase; used by the css and data modules
283	// Microsoft forgot to hump their vendor prefix (#9572)
284	camelCase: function( string ) {
285		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
286	},
287
288	nodeName: function( elem, name ) {
289		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
290	},
291
292	// args is for internal usage only
293	each: function( obj, callback, args ) {
294		var value,
295			i = 0,
296			length = obj.length,
297			isArray = isArraylike( obj );
298
299		if ( args ) {
300			if ( isArray ) {
301				for ( ; i < length; i++ ) {
302					value = callback.apply( obj[ i ], args );
303
304					if ( value === false ) {
305						break;
306					}
307				}
308			} else {
309				for ( i in obj ) {
310					value = callback.apply( obj[ i ], args );
311
312					if ( value === false ) {
313						break;
314					}
315				}
316			}
317
318		// A special, fast, case for the most common use of each
319		} else {
320			if ( isArray ) {
321				for ( ; i < length; i++ ) {
322					value = callback.call( obj[ i ], i, obj[ i ] );
323
324					if ( value === false ) {
325						break;
326					}
327				}
328			} else {
329				for ( i in obj ) {
330					value = callback.call( obj[ i ], i, obj[ i ] );
331
332					if ( value === false ) {
333						break;
334					}
335				}
336			}
337		}
338
339		return obj;
340	},
341
342	// Support: Android<4.1
343	trim: function( text ) {
344		return text == null ?
345			"" :
346			( text + "" ).replace( rtrim, "" );
347	},
348
349	// results is for internal usage only
350	makeArray: function( arr, results ) {
351		var ret = results || [];
352
353		if ( arr != null ) {
354			if ( isArraylike( Object(arr) ) ) {
355				jQuery.merge( ret,
356					typeof arr === "string" ?
357					[ arr ] : arr
358				);
359			} else {
360				push.call( ret, arr );
361			}
362		}
363
364		return ret;
365	},
366
367	inArray: function( elem, arr, i ) {
368		return arr == null ? -1 : indexOf.call( arr, elem, i );
369	},
370
371	merge: function( first, second ) {
372		var len = +second.length,
373			j = 0,
374			i = first.length;
375
376		for ( ; j < len; j++ ) {
377			first[ i++ ] = second[ j ];
378		}
379
380		first.length = i;
381
382		return first;
383	},
384
385	grep: function( elems, callback, invert ) {
386		var callbackInverse,
387			matches = [],
388			i = 0,
389			length = elems.length,
390			callbackExpect = !invert;
391
392		// Go through the array, only saving the items
393		// that pass the validator function
394		for ( ; i < length; i++ ) {
395			callbackInverse = !callback( elems[ i ], i );
396			if ( callbackInverse !== callbackExpect ) {
397				matches.push( elems[ i ] );
398			}
399		}
400
401		return matches;
402	},
403
404	// arg is for internal usage only
405	map: function( elems, callback, arg ) {
406		var value,
407			i = 0,
408			length = elems.length,
409			isArray = isArraylike( elems ),
410			ret = [];
411
412		// Go through the array, translating each of the items to their new values
413		if ( isArray ) {
414			for ( ; i < length; i++ ) {
415				value = callback( elems[ i ], i, arg );
416
417				if ( value != null ) {
418					ret.push( value );
419				}
420			}
421
422		// Go through every key on the object,
423		} else {
424			for ( i in elems ) {
425				value = callback( elems[ i ], i, arg );
426
427				if ( value != null ) {
428					ret.push( value );
429				}
430			}
431		}
432
433		// Flatten any nested arrays
434		return concat.apply( [], ret );
435	},
436
437	// A global GUID counter for objects
438	guid: 1,
439
440	// Bind a function to a context, optionally partially applying any
441	// arguments.
442	proxy: function( fn, context ) {
443		var tmp, args, proxy;
444
445		if ( typeof context === "string" ) {
446			tmp = fn[ context ];
447			context = fn;
448			fn = tmp;
449		}
450
451		// Quick check to determine if target is callable, in the spec
452		// this throws a TypeError, but we will just return undefined.
453		if ( !jQuery.isFunction( fn ) ) {
454			return undefined;
455		}
456
457		// Simulated bind
458		args = slice.call( arguments, 2 );
459		proxy = function() {
460			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
461		};
462
463		// Set the guid of unique handler to the same of original handler, so it can be removed
464		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
465
466		return proxy;
467	},
468
469	now: Date.now,
470
471	// jQuery.support is not used in Core but other projects attach their
472	// properties to it so it needs to exist.
473	support: support
474});
475
476// Populate the class2type map
477jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
478	class2type[ "[object " + name + "]" ] = name.toLowerCase();
479});
480
481function isArraylike( obj ) {
482	var length = obj.length,
483		type = jQuery.type( obj );
484
485	if ( type === "function" || jQuery.isWindow( obj ) ) {
486		return false;
487	}
488
489	if ( obj.nodeType === 1 && length ) {
490		return true;
491	}
492
493	return type === "array" || length === 0 ||
494		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
495}
496
497return jQuery;
498});