corrade-nucleus-nucleons

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 19  →  ?path2? @ 20
/base/000_base/node_modules/bootstrap-validator/sandbox/jquery/src/core.js
@@ -0,0 +1,500 @@
define([
"./var/arr",
"./var/slice",
"./var/concat",
"./var/push",
"./var/indexOf",
"./var/class2type",
"./var/toString",
"./var/hasOwn",
"./var/trim",
"./var/support"
], function( arr, slice, concat, push, indexOf, class2type, toString, hasOwn, trim, support ) {
 
var
// Use the correct document accordingly with window argument (sandbox)
document = window.document,
 
version = "@VERSION",
 
// Define a local copy of jQuery
jQuery = function( selector, context ) {
// The jQuery object is actually just the init constructor 'enhanced'
// Need init if jQuery is called (just allow error to be thrown if not included)
return new jQuery.fn.init( selector, context );
},
 
// Matches dashed string for camelizing
rmsPrefix = /^-ms-/,
rdashAlpha = /-([\da-z])/gi,
 
// Used by jQuery.camelCase as callback to replace()
fcamelCase = function( all, letter ) {
return letter.toUpperCase();
};
 
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
jquery: version,
 
constructor: jQuery,
 
// Start with an empty selector
selector: "",
 
// The default length of a jQuery object is 0
length: 0,
 
toArray: function() {
return slice.call( this );
},
 
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
return num != null ?
 
// Return a 'clean' array
( num < 0 ? this[ num + this.length ] : this[ num ] ) :
 
// Return just the object
slice.call( this );
},
 
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems ) {
 
// Build a new jQuery matched element set
var ret = jQuery.merge( this.constructor(), elems );
 
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
ret.context = this.context;
 
// Return the newly-formed element set
return ret;
},
 
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function( callback, args ) {
return jQuery.each( this, callback, args );
},
 
map: function( callback ) {
return this.pushStack( jQuery.map(this, function( elem, i ) {
return callback.call( elem, i, elem );
}));
},
 
slice: function() {
return this.pushStack( slice.apply( this, arguments ) );
},
 
first: function() {
return this.eq( 0 );
},
 
last: function() {
return this.eq( -1 );
},
 
eq: function( i ) {
var len = this.length,
j = +i + ( i < 0 ? len : 0 );
return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
},
 
end: function() {
return this.prevObject || this.constructor(null);
},
 
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: push,
sort: arr.sort,
splice: arr.splice
};
 
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[0] || {},
i = 1,
length = arguments.length,
deep = false;
 
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
 
// skip the boolean and the target
target = arguments[ i ] || {};
i++;
}
 
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
}
 
// extend jQuery itself if only one argument is passed
if ( i === length ) {
target = this;
i--;
}
 
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
if ( (options = arguments[ i ]) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
 
// Prevent never-ending loop
if ( target === copy ) {
continue;
}
 
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : [];
 
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
}
 
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
 
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}
}
}
 
// Return the modified object
return target;
};
 
jQuery.extend({
// Unique for each copy of jQuery on the page
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
 
// Assume jQuery is ready without the ready module
isReady: true,
 
error: function( msg ) {
throw new Error( msg );
},
 
noop: function() {},
 
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
return jQuery.type(obj) === "function";
},
 
isArray: Array.isArray,
 
isWindow: function( obj ) {
return obj != null && obj === obj.window;
},
 
isNumeric: function( obj ) {
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
// subtraction forces infinities to NaN
return obj - parseFloat( obj ) >= 0;
},
 
isPlainObject: function( obj ) {
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
return false;
}
 
// Support: Firefox <20
// The try/catch suppresses exceptions thrown when attempting to access
// the "constructor" property of certain host objects, ie. |window.location|
// https://bugzilla.mozilla.org/show_bug.cgi?id=814622
try {
if ( obj.constructor &&
!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
return false;
}
} catch ( e ) {
return false;
}
 
// If the function hasn't returned already, we're confident that
// |obj| is a plain object, created by {} or constructed with new Object
return true;
},
 
isEmptyObject: function( obj ) {
var name;
for ( name in obj ) {
return false;
}
return true;
},
 
type: function( obj ) {
if ( obj == null ) {
return obj + "";
}
// Support: Android < 4.0, iOS < 6 (functionish RegExp)
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call(obj) ] || "object" :
typeof obj;
},
 
// Evaluates a script in a global context
globalEval: function( code ) {
var script,
indirect = eval;
 
code = jQuery.trim( code );
 
if ( code ) {
// If the code includes a valid, prologue position
// strict mode pragma, execute code by injecting a
// script tag into the document.
if ( code.indexOf("use strict") === 1 ) {
script = document.createElement("script");
script.text = code;
document.head.appendChild( script ).parentNode.removeChild( script );
} else {
// Otherwise, avoid the DOM node creation, insertion
// and removal by using an indirect global eval
indirect( code );
}
}
},
 
// Convert dashed to camelCase; used by the css and data modules
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function( string ) {
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
},
 
nodeName: function( elem, name ) {
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
},
 
// args is for internal usage only
each: function( obj, callback, args ) {
var value,
i = 0,
length = obj.length,
isArray = isArraylike( obj );
 
if ( args ) {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.apply( obj[ i ], args );
 
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.apply( obj[ i ], args );
 
if ( value === false ) {
break;
}
}
}
 
// A special, fast, case for the most common use of each
} else {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.call( obj[ i ], i, obj[ i ] );
 
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.call( obj[ i ], i, obj[ i ] );
 
if ( value === false ) {
break;
}
}
}
}
 
return obj;
},
 
trim: function( text ) {
return text == null ? "" : trim.call( text );
},
 
// results is for internal usage only
makeArray: function( arr, results ) {
var ret = results || [];
 
if ( arr != null ) {
if ( isArraylike( Object(arr) ) ) {
jQuery.merge( ret,
typeof arr === "string" ?
[ arr ] : arr
);
} else {
push.call( ret, arr );
}
}
 
return ret;
},
 
inArray: function( elem, arr, i ) {
return arr == null ? -1 : indexOf.call( arr, elem, i );
},
 
merge: function( first, second ) {
var len = +second.length,
j = 0,
i = first.length;
 
for ( ; j < len; j++ ) {
first[ i++ ] = second[ j ];
}
 
first.length = i;
 
return first;
},
 
grep: function( elems, callback, invert ) {
var callbackInverse,
matches = [],
i = 0,
length = elems.length,
callbackExpect = !invert;
 
// Go through the array, only saving the items
// that pass the validator function
for ( ; i < length; i++ ) {
callbackInverse = !callback( elems[ i ], i );
if ( callbackInverse !== callbackExpect ) {
matches.push( elems[ i ] );
}
}
 
return matches;
},
 
// arg is for internal usage only
map: function( elems, callback, arg ) {
var value,
i = 0,
length = elems.length,
isArray = isArraylike( elems ),
ret = [];
 
// Go through the array, translating each of the items to their new values
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
 
if ( value != null ) {
ret.push( value );
}
}
 
// Go through every key on the object,
} else {
for ( i in elems ) {
value = callback( elems[ i ], i, arg );
 
if ( value != null ) {
ret.push( value );
}
}
}
 
// Flatten any nested arrays
return concat.apply( [], ret );
},
 
// A global GUID counter for objects
guid: 1,
 
// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function( fn, context ) {
var tmp, args, proxy;
 
if ( typeof context === "string" ) {
tmp = fn[ context ];
context = fn;
fn = tmp;
}
 
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if ( !jQuery.isFunction( fn ) ) {
return undefined;
}
 
// Simulated bind
args = slice.call( arguments, 2 );
proxy = function() {
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
};
 
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
 
return proxy;
},
 
now: Date.now,
 
// jQuery.support is not used in Core but other projects attach their
// properties to it so it needs to exist.
support: support
});
 
// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
});
 
function isArraylike( obj ) {
var length = obj.length,
type = jQuery.type( obj );
 
if ( type === "function" || jQuery.isWindow( obj ) ) {
return false;
}
 
if ( obj.nodeType === 1 && length ) {
return true;
}
 
return type === "array" || length === 0 ||
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
}
 
return jQuery;
});