// Make sure an element was located if ( elem ) // Handle the case where IE and Opera return items // by name instead of ID if ( elem.id != match[3] ) return jQuery().find( selector );
// Otherwise, we inject the element directly into the jQuery object else { this[0] = elem; this.length = 1; returnthis;
}
else
selector = [];
}
// HANDLE: $(expr, [context]) // (which is just equivalent to: $(content).find(expr)
} else returnnew jQuery( context ).find( selector );
// HANDLE: $(arraylike) // Watch for when an array-like object, contains DOM nodes, is passed in as the selector
(selector.jquery || selector.length && selector != window && !selector.nodeType && selector[0] != undefined && selector[0].nodeType) && jQuery.makeArray( selector ) ||
// HANDLE: $(*)
[ selector ] );
},
// The current version of jQuery being used
jquery: "1.2.3",
// The number of elements contained in the matched element set
size: function() { returnthis.length;
},
// The number of elements contained in the matched element set
length: 0,
// 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 == undefined ?
// Return a 'clean' array
jQuery.makeArray( this ) :
// Return just the object this[ num ];
},
// 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( elems );
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
// Return the newly-formed element set return ret;
},
// Force the current matched set of elements to become // the specified array of elements (destroying the stack in the process) // You should use pushStack() in order to do this, but maintain the stack
setArray: function( elems ) { // Resetting the length to 0, then using the native Array push // is a super-fast way to populate an object with array-like properties this.length = 0;
Array.prototype.push.apply( this, elems );
returnthis;
},
// 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 );
},
// Determine the position of an element within // the matched set of elements
index: function( elem ) { var ret = -1;
// Locate the position of the desired element this.each(function(i){ if ( this == elem )
ret = i;
});
return ret;
},
attr: function( name, value, type ) { var options = name;
// Look for the case where we're accessing a style value if ( name.constructor == String ) if ( value == undefined ) returnthis.length && jQuery[ type || "attr" ]( this[0], name ) || undefined;
else {
options = {};
options[ name ] = value;
}
// Check to see if we're setting style values returnthis.each(function(i){ // Set all the styles for ( name in options )
jQuery.attr(
type ? this.style : this,
name, jQuery.prop( this, options[ name ], type, i, name )
);
});
},
css: function( key, value ) { // ignore negative width and height values if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
value = undefined; returnthis.attr( key, value, "curCSS" );
},
text: function( text ) { if ( typeof text != "object" && text != null ) returnthis.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
var ret = "";
jQuery.each( text || this, function(){
jQuery.each( this.childNodes, function(){ if ( this.nodeType != 8 )
ret += this.nodeType != 1 ? this.nodeValue :
jQuery.fn.text( [ this ] );
});
});
return ret;
},
wrapAll: function( html ) { if ( this[0] ) // The elements to wrap the target around
jQuery( html, this[0].ownerDocument )
.clone()
.insertBefore( this[0] )
.map(function(){ var elem = this;
while ( elem.firstChild )
elem = elem.firstChild;
return elem;
})
.append(this);
returnthis;
},
wrapInner: function( html ) { returnthis.each(function(){
jQuery( this ).contents().wrapAll( html );
});
},
wrap: function( html ) { returnthis.each(function(){
jQuery( this ).wrapAll( html );
});
},
clone: function( events ) { // Do the clone var ret = this.map(function(){ if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) { // IE copies events bound via attachEvent when // using cloneNode. Calling detachEvent on the // clone will also remove the events from the orignal // In order to get around this, we use innerHTML. // Unfortunately, this means some modifications to // attributes in IE that are actually only stored // as properties will not be copied (such as the // the name attribute on an input). var clone = this.cloneNode(true),
container = document.createElement("div");
container.appendChild(clone); return jQuery.clean([container.innerHTML])[0];
} else returnthis.cloneNode(true);
});
// Need to set the expando to null on the cloned set if it exists // removeData doesn't work here, IE removes it from the original as well // this is primarily for IE but the data expando shouldn't be copied over in any browser var clone = ret.find("*").andSelf().each(function(){ if ( this[ expando ] != undefined ) this[ expando ] = null;
});
// Copy the events from the original to the clone if ( events === true ) this.find("*").andSelf().each(function(i){ if (this.nodeType == 3) return; var events = jQuery.data( this, "events" );
for ( var type in events ) for ( var handler in events[ type ] )
jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
});
not: function( selector ) { if ( selector.constructor == String ) // test special case where just one selector is passed in if ( isSimple.test( selector ) ) returnthis.pushStack( jQuery.multiFilter( selector, this, true ) ); else
selector = jQuery.multiFilter( selector, this );
val: function( value ) { if ( value == undefined ) {
if ( this.length ) { var elem = this[0];
// We need to handle select boxes special if ( jQuery.nodeName( elem, "select" ) ) { var index = elem.selectedIndex,
values = [],
options = elem.options,
one = elem.type == "select-one";
// Nothing was selected if ( index < 0 ) returnnull;
// Loop through all the selected options for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { var option = options[ i ];
if ( option.selected ) { // Get the specifc value for the option
value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
// We don't need an array for one selects if ( one ) return value;
// Multi-Selects return an array
values.push( value );
}
}
return values;
// Everything else, we just grab the value
} else return (this[0].value || "").replace(/\r/g, "");
}
return undefined;
}
returnthis.each(function(){ if ( this.nodeType != 1 ) return;
jQuery.each(elems, function(){ var elem = clone ?
jQuery( this ).clone( true )[0] : this;
// execute all scripts after the elements have been injected if ( jQuery.nodeName( elem, "script" ) ) {
scripts = scripts.add( elem );
} else { // Remove any inner scripts for later evaluation if ( elem.nodeType == 1 )
scripts = scripts.add( jQuery( "script", elem ).remove() );
// Inject the elements into the document
callback.call( obj, elem );
}
});
scripts.each( evalScript );
});
}
};
// Give the init function the jQuery prototype for later instantiation
jQuery.prototype.init.prototype = jQuery.prototype;
function evalScript( i, elem ) { if ( elem.src )
jQuery.ajax({
url: elem.src,
async: false,
dataType: "script"
});
if ( elem.parentNode )
elem.parentNode.removeChild( elem );
}
jQuery.extend = jQuery.fn.extend = function() { // copy reference to target object var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
// Handle a deep copy situation if ( target.constructor == Boolean ) {
deep = target;
target = arguments[1] || {}; // skip the boolean and the target
i = 2;
}
// Handle case when target is a string or something (possible in deep copy) if ( typeof target != "object" && typeof target != "function" )
target = {};
// extend jQuery itself if only one argument is passed if ( length == 1 ) {
target = this;
i = 0;
}
for ( ; i < length; i++ ) // Only deal with non-null/undefined values if ( (options = arguments[ i ]) != null ) // Extend the base object for ( var name in options ) { // Prevent never-ending loop if ( target === options[ name ] ) continue;
// Recurse if we're merging object values if ( deep && options[ name ] && typeof options[ name ] == "object" && target[ name ] && !options[ name ].nodeType )
target[ name ] = jQuery.extend( target[ name ], options[ name ] );
// Don't bring in undefined values elseif ( options[ name ] != undefined )
target[ name ] = options[ name ];
}
// Return the modified object return target;
};
var expando = "jQuery" + (new Date()).getTime(), uuid = 0, windowData = {};
// exclude the following css properties to add px var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i;
jQuery.extend({
noConflict: function( deep ) {
window.$ = _$;
// check if an element is in a (or is an) XML document
isXMLDoc: function( elem ) { return elem.documentElement && !elem.body ||
elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
},
// Evalulates a script in a global context
globalEval: function( data ) {
data = jQuery.trim( data );
// If we want to remove a specific section of the element's data if ( name ) { if ( jQuery.cache[ id ] ) { // Remove the section of cache data delete jQuery.cache[ id ][ name ];
// If we've removed all the data, remove the element's cache
name = "";
for ( name in jQuery.cache[ id ] ) break;
if ( !name )
jQuery.removeData( elem );
}
// Otherwise, we want to remove all of the element's data
} else { // Clean up the element expando try { delete elem[ expando ];
} catch(e){ // IE has trouble directly removing the expando // but it's ok with using removeAttribute if ( elem.removeAttribute )
elem.removeAttribute( expando );
}
// Completely remove the data cache delete jQuery.cache[ id ];
}
},
// args is for internal usage only
each: function( object, callback, args ) { if ( args ) { if ( object.length == undefined ) { for ( var name in object ) if ( callback.apply( object[ name ], args ) === false ) break;
} else for ( var i = 0, length = object.length; i < length; i++ ) if ( callback.apply( object[ i ], args ) === false ) break;
// A special, fast, case for the most common use of each
} else { if ( object.length == undefined ) { for ( var name in object ) if ( callback.call( object[ name ], name, object[ name ] ) === false ) break;
} else for ( var i = 0, length = object.length, value = object[0];
i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
}
return object;
},
prop: function( elem, value, type, i, name ) { // Handle executable functions if ( jQuery.isFunction( value ) )
value = value.call( elem, i );
// Handle passing in a number to a CSS property return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
value + "px" :
value;
},
// A method for quickly swapping in/out CSS properties to get correct calculations
swap: function( elem, options, callback ) { var old = {}; // Remember the old values, and insert the new ones for ( var name in options ) {
old[ name ] = elem.style[ name ];
elem.style[ name ] = options[ name ];
}
callback.call( elem );
// Revert the old values for ( var name in options )
elem.style[ name ] = old[ name ];
},
css: function( elem, name, force ) { if ( name == "width" || name == "height" ) { var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
function getWH() {
val = name == "width" ? elem.offsetWidth : elem.offsetHeight; var padding = 0, border = 0;
jQuery.each( which, function() {
padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
});
val -= Math.round(padding + border);
}
// A helper method for determining if an element's values are broken function color( elem ) { if ( !jQuery.browser.safari ) returnfalse;
var ret = document.defaultView.getComputedStyle( elem, null ); return !ret || ret.getPropertyValue("color") == "";
}
// We need to handle opacity special in IE if ( name == "opacity" && jQuery.browser.msie ) {
ret = jQuery.attr( elem.style, "opacity" );
return ret == "" ? "1" :
ret;
} // Opera sometimes will give the wrong display answer, this fixes it, see #2037 if ( jQuery.browser.opera && name == "display" ) { var save = elem.style.outline;
elem.style.outline = "0 solid black";
elem.style.outline = save;
}
// Make sure we're using the right name for getting the float value if ( name.match( /float/i ) )
name = styleFloat;
if ( !force && elem.style && elem.style[ name ] )
ret = elem.style[ name ];
// Only "float" is needed here if ( name.match( /float/i ) )
name = "float";
name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
var getComputedStyle = document.defaultView.getComputedStyle( elem, null );
if ( getComputedStyle && !color( elem ) )
ret = getComputedStyle.getPropertyValue( name );
// If the element isn't reporting its values properly in Safari // then some display: none elements are involved else { var swap = [], stack = [];
// Locate all of the parent display: none elements for ( var a = elem; a && color(a); a = a.parentNode )
stack.unshift(a);
// Go through and make them visible, but in reverse // (It would be better if we knew the exact display type that they had) for ( var i = 0; i < stack.length; i++ ) if ( color( stack[ i ] ) ) {
swap[ i ] = stack[ i ].style.display;
stack[ i ].style.display = "block";
}
// Since we flip the display style, we have to handle that // one special, otherwise get the value
ret = name == "display" && swap[ stack.length - 1 ] != null ? "none" :
( getComputedStyle && getComputedStyle.getPropertyValue( name ) ) || "";
// Finally, revert the display styles back for ( var i = 0; i < swap.length; i++ ) if ( swap[ i ] != null )
stack[ i ].style.display = swap[ i ];
}
// We should always get a number back from opacity if ( name == "opacity" && ret == "" )
ret = "1";
// If we're not dealing with a regular pixel number // but a number that has a weird ending, we need to convert it to pixels if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) { // Remember the original values var style = elem.style.left, runtimeStyle = elem.runtimeStyle.left;
// Put in the new values to get a computed value out
elem.runtimeStyle.left = elem.currentStyle.left;
elem.style.left = ret || 0;
ret = elem.style.pixelLeft + "px";
clean: function( elems, context ) { var ret = [];
context = context || document; // !context.createElement fails in IE with an error but returns typeof 'object' if (typeof context.createElement == 'undefined')
context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
jQuery.each(elems, function(i, elem){ if ( !elem ) return;
if ( elem.constructor == Number )
elem = elem.toString();
// Convert html string into DOM nodes if ( typeof elem == "string" ) { // Fix "XHTML"-style tags in all browsers
elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){ return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
all :
front + "> + tag + ">";
});
// Trim whitespace, otherwise indexOf won't work as expected var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");
var wrap = // option or optgroup
!tags.indexOf(") &&
[ 1, ", "" ] ||
// IE completely kills leading whitespace when innerHTML is used if ( /^\s/.test( elem ) )
div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
attr: function( elem, name, value ) { // don't set attributes on text and comment nodes if (!elem || elem.nodeType == 3 || elem.nodeType == 8) return undefined;
var fix = jQuery.isXMLDoc( elem ) ?
{} :
jQuery.props;
// Safari mis-reports the default selected property of a hidden option // Accessing the parent's selectedIndex property fixes it if ( name == "selected" && jQuery.browser.safari )
elem.parentNode.selectedIndex;
// Certain attributes only work when accessed via the old DOM 0 way if ( fix[ name ] ) { if ( value != undefined )
elem[ fix[ name ] ] = value;
return elem[ fix[ name ] ];
} elseif ( jQuery.browser.msie && name == "style" ) return jQuery.attr( elem.style, "cssText", value );
elseif ( value == undefined && jQuery.browser.msie && jQuery.nodeName( elem, "form" ) && (name == "action" || name == "method") ) return elem.getAttributeNode( name ).nodeValue;
// IE elem.getAttribute passes even for style elseif ( elem.tagName ) {
if ( value != undefined ) { // We can't allow the type property to be changed (since it causes problems in IE) if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode ) throw"type property can't be changed";
// convert the value to a string (all browsers do this but IE) see #1070
elem.setAttribute( name, "" + value );
}
if ( jQuery.browser.msie && /href|src/.test( name ) && !jQuery.isXMLDoc( elem ) ) return elem.getAttribute( name, 2 );
return elem.getAttribute( name );
// elem is actually elem.style ... set the style
} else { // IE actually uses filters for opacity if ( name == "opacity" && jQuery.browser.msie ) { if ( value != undefined ) { // IE has trouble with opacity if it does not have layout // Force it by setting the zoom level
elem.zoom = 1;
// Set the alpha filter to set the opacity
elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
(parseFloat( value ).toString() == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
}
// Need to use typeof to fight Safari childNodes crashes if ( typeof array != "array" ) for ( var i = 0, length = array.length; i < length; i++ )
ret.push( array[ i ] ); else
ret = array.slice( 0 );
return ret;
},
inArray: function( elem, array ) { for ( var i = 0, length = array.length; i < length; i++ ) if ( array[ i ] == elem ) return i;
return -1;
},
merge: function( first, second ) { // We have to loop this way because IE & Opera overwrite the length // expando of getElementsByTagName
// Also, we need to make sure that the correct elements are being returned // (IE returns comment nodes in a '*' query) if ( jQuery.browser.msie ) { for ( var i = 0; second[ i ]; i++ ) if ( second[ i ].nodeType != 8 )
first.push( second[ i ] );
} else for ( var i = 0; second[ i ]; i++ )
first.push( second[ i ] );
return first;
},
unique: function( array ) { var ret = [], done = {};
try {
for ( var i = 0, length = array.length; i < length; i++ ) { var id = jQuery.data( array[ i ] );
if ( !done[ id ] ) {
done[ id ] = true;
ret.push( array[ i ] );
}
}
} catch( e ) {
ret = array;
}
return ret;
},
grep: function( elems, callback, inv ) { var ret = [];
// Go through the array, only saving the items // that pass the validator function for ( var i = 0, length = elems.length; i < length; i++ ) if ( !inv && callback( elems[ i ], i ) || inv && !callback( elems[ i ], i ) )
ret.push( elems[ i ] );
return ret;
},
map: function( elems, callback ) { var ret = [];
// Go through the array, translating each of the items to their // new value (or values). for ( var i = 0, length = elems.length; i < length; i++ ) { var value = callback( elems[ i ], i );
if ( value !== null && value != undefined ) { if ( value.constructor != Array )
value = [ value ];
ret = ret.concat( value );
}
}
return ret;
}
});
var userAgent = navigator.userAgent.toLowerCase();
// Figure out what browser is being used
jQuery.browser = {
version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
safari: /webkit/.test( userAgent ),
opera: /opera/.test( userAgent ),
msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};
var styleFloat = jQuery.browser.msie ? "styleFloat" : "cssFloat";
jQuery.extend({ // Check to see if the W3C box model is being used
boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
remove: function( selector ) { if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) { // Prevent memory leaks
jQuery( "*", this ).add(this).each(function(){
jQuery.event.remove(this);
jQuery.removeData(this);
}); if (this.parentNode) this.parentNode.removeChild( this );
}
},
empty: function() { // Remove element nodes and prevent memory leaks
jQuery( ">*", this ).remove();
// Remove any remaining nodes while ( this.firstChild ) this.removeChild( this.firstChild );
}
}, function(name, fn){
jQuery.fn[ name ] = function(){ returnthis.each( fn, arguments );
};
});
jQuery.each([ "Height", "Width" ], function(i, name){ var type = name.toLowerCase();
jQuery.fn[ type ] = function( size ) { // Get window width or height returnthis[0] == window ? // Opera reports document.body.client[Width/Height] properly in both quirks and standards
jQuery.browser.opera && document.body[ "client" + name ] ||
// Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
jQuery.browser.safari && window[ "inner" + name ] ||
// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
// Get document width or height this[0] == document ? // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
Math.max(
Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
Math.max(document.body["offset" + name], document.documentElement["offset" + name])
) :
// Get or set width or height on the element
size == undefined ? // Get width or height on the element
(this.length ? jQuery.css( this[0], type ) : null) :
// Set the width or height on the element (default to pixels if value is unitless) this.css( type, size.constructor == String ? size : size + "px" );
};
});
var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ? "(?:[\\w*_-]|\\\\.)" : "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
quickChild = new RegExp("^>\\s*(" + chars + "+)"),
quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
quickClass = new RegExp("^([#.]?)(" + chars + "*)");
// The regular expressions that power the parsing engine
parse: [ // Match: [@value='test'], [@foo]
/^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,
multiFilter: function( expr, elems, not ) { var old, cur = [];
while ( expr && expr != old ) {
old = expr; var f = jQuery.filter( expr, elems, not );
expr = f.t.replace(/^\s*,\s*/, "" );
cur = not ? elems = f.r : jQuery.merge( cur, f.r );
}
return cur;
},
find: function( t, context ) { // Quickly handle non-string expressions if ( typeof t != "string" ) return [ t ];
// check to make sure context is a DOM element or a document if ( context && context.nodeType != 1 && context.nodeType != 9) return [ ];
// Set the correct context (if none is provided)
context = context || document;
// Initialize the search var ret = [context], done = [], last, nodeName;
// Continue while a selector expression exists, and while // we're no longer looping upon ourselves while ( t && last != t ) { var r = [];
last = t;
t = jQuery.trim(t);
var foundToken = false;
// An attempt at speeding up child selectors that // point to a specific element tag var re = quickChild; var m = re.exec(t);
if ( m ) {
nodeName = m[1].toUpperCase();
// Perform our own iteration and filter for ( var i = 0; ret[i]; i++ ) for ( var c = ret[i].firstChild; c; c = c.nextSibling ) if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
r.push( c );
ret = r;
t = t.replace( re, "" ); if ( t.indexOf(" ") == 0 ) continue;
foundToken = true;
} else {
re = /^([>+~])\s*(\w*)/i;
if ( (m = re.exec(t)) != null ) {
r = [];
var merge = {};
nodeName = m[2].toUpperCase();
m = m[1];
for ( var j = 0, rl = ret.length; j < rl; j++ ) { var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild; for ( ; n; n = n.nextSibling ) if ( n.nodeType == 1 ) { var id = jQuery.data(n);
if ( m == "~" && merge[id] ) break;
if (!nodeName || n.nodeName.toUpperCase() == nodeName ) { if ( m == "~" ) merge[id] = true;
r.push( n );
}
if ( m == "+" ) break;
}
}
ret = r;
// And remove the token
t = jQuery.trim( t.replace( re, "" ) );
foundToken = true;
}
}
// See if there's still an expression, and that we haven't already // matched a token if ( t && !foundToken ) { // Handle multiple expressions if ( !t.indexOf(",") ) { // Clean the result set if ( context == ret[0] ) ret.shift();
// Merge the result sets
done = jQuery.merge( done, ret );
// Reset the context
r = ret = [context];
// Touch up the selector string
t = " " + t.substr(1,t.length);
} else { // Optimize for the case nodeName#idName var re2 = quickID; var m = re2.exec(t);
// Re-organize the results, so that they're consistent if ( m ) {
m = [ 0, m[2], m[3], m[1] ];
} else { // Otherwise, do a traditional filter check for // ID, class, and element selectors
re2 = quickClass;
m = re2.exec(t);
}
m[2] = m[2].replace(/\\/g, "");
var elem = ret[ret.length-1];
// Try to do a global search by ID, where we can if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) { // Optimization for HTML document case var oid = elem.getElementById(m[2]);
// Do a quick check for the existence of the actual ID attribute // to avoid selecting by the name attribute in IE // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
// Do a quick check for node name (where applicable) so // that div#foo searches will be really fast
ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
} else { // We need to find all descendant elements for ( var i = 0; ret[i]; i++ ) { // Grab the tag name being searched for var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];
// Handle IE7 being really dumb about <object>s if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
tag = "param";
r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
}
// It's faster to filter by class and be done with it if ( m[1] == "." )
r = jQuery.classFilter( r, m[2] );
// Same with ID filtering if ( m[1] == "#" ) { var tmp = [];
// Try to find the element with the ID for ( var i = 0; r[i]; i++ ) if ( r[i].getAttribute("id") == m[2] ) {
tmp = [ r[i] ]; break;
}
r = tmp;
}
ret = r;
}
t = t.replace( re2, "" );
}
}
// If a selector string still exists if ( t ) { // Attempt to filter it var val = jQuery.filter(t,r);
ret = r = val.r;
t = jQuery.trim(val.t);
}
}
// An error occurred with the selector; // just return an empty set instead if ( t )
ret = [];
// Remove the root context if ( ret && context == ret[0] )
ret.shift();
// And combine the results
done = jQuery.merge( done, ret );
return done;
},
classFilter: function(r,m,not){
m = " " + m + " "; var tmp = []; for ( var i = 0; r[i]; i++ ) { var pass = (" " + r[i].className + " ").indexOf( m ) >= 0; if ( !not && pass || not && !pass )
tmp.push( r[i] );
} return tmp;
},
filter: function(t,r,not) { var last;
// Look for common filter expressions while ( t && t != last ) {
last = t;
var p = jQuery.parse, m;
for ( var i = 0; p[i]; i++ ) {
m = p[i].exec( t );
if ( m ) { // Remove what we just matched
t = t.substring( m[0].length );
m[2] = m[2].replace(/\\/g, ""); break;
}
}
if ( !m ) break;
// :not() is a special case that can be optimized by // keeping it out of the expression list if ( m[1] == ":" && m[2] == "not" ) // optimize if only one selector found (most common case)
r = isSimple.test( m[3] ) ?
jQuery.filter(m[3], r, true).r :
jQuery( r ).not( m[3] );
// We can get a big speed boost by filtering by class here elseif ( m[1] == "." )
r = jQuery.classFilter(r, m[2], not);
elseif ( m[1] == "[" ) { var tmp = [], type = m[3];
for ( var i = 0, rl = r.length; i < rl; i++ ) { var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
if ( z == null || /href|src|selected/.test(m[2]) )
z = jQuery.attr(a,m[2]) || '';
if ( (type == "" && !!z ||
type == "=" && z == m[5] ||
type == "!=" && z != m[5] ||
type == "^=" && z && !z.indexOf(m[5]) ||
type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
(type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
tmp.push( a );
}
r = tmp;
// We can get a speed boost by handling nth-child here
} elseif ( m[1] == ":" && m[2] == "nth-child" ) { var merge = {}, tmp = [], // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
!/\D/.test(m[3]) && "0n+" + m[3] || m[3]), // calculate the numbers (first)n+(last) including if they are negative
first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;
// loop through all the elements left in the jQuery object for ( var i = 0, rl = r.length; i < rl; i++ ) { var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);
if ( !merge[id] ) { var c = 1;
for ( var n = parentNode.firstChild; n; n = n.nextSibling ) if ( n.nodeType == 1 )
n.nodeIndex = c++;
merge[id] = true;
}
var add = false;
if ( first == 0 ) { if ( node.nodeIndex == last )
add = true;
} elseif ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
add = true;
if ( add ^ not )
tmp.push( node );
}
r = tmp;
// Otherwise, find the expression to execute
} else { var fn = jQuery.expr[ m[1] ]; if ( typeof fn == "object" )
fn = fn[ m[2] ];
// Execute it against the current filter
r = jQuery.grep( r, function(elem, i){ return fn(elem, i, m, r);
}, not );
}
}
// Return an array of filtered elements (r) // and the modified expression string (t) return { r: r, t: t };
},
dir: function( elem, dir ){ var matched = []; var cur = elem[dir]; while ( cur && cur != document ) { if ( cur.nodeType == 1 )
matched.push( cur );
cur = cur[dir];
} return matched;
},
nth: function(cur,result,dir,elem){
result = result || 1; var num = 0;
for ( ; cur; cur = cur[dir] ) if ( cur.nodeType == 1 && ++num == result ) break;
return cur;
},
sibling: function( n, elem ) { var r = [];
for ( ; n; n = n.nextSibling ) { if ( n.nodeType == 1 && (!elem || n != elem) )
r.push( n );
}
return r;
}
});
/* * A number of helper functions used for managing events. * Many of the ideas behind this code orignated from * Dean Edwards' addEvent library.
*/
jQuery.event = {
// Bind an event to an element // Original by Dean Edwards
add: function(elem, types, handler, data) { if ( elem.nodeType == 3 || elem.nodeType == 8 ) return;
// For whatever reason, IE has trouble passing the window object // around, causing it to be cloned in the process if ( jQuery.browser.msie && elem.setInterval != undefined )
elem = window;
// Make sure that the function being executed has a unique ID if ( !handler.guid )
handler.guid = this.guid++;
// if data is passed, bind to handler if( data != undefined ) { // Create temporary function pointer to original handler var fn = handler;
// Create unique handler function, wrapped around original handler
handler = function() { // Pass arguments and context to original handler return fn.apply(this, arguments);
};
// Store data in unique handler
handler.data = data;
// Set the guid of unique handler to the same of original handler, so it can be removed
handler.guid = fn.guid;
}
// Init the element's event structure var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){ // returned undefined or false var val;
// Handle the second event of a trigger and when // an event is called after a page has unloaded if ( typeof jQuery == "undefined" || jQuery.event.triggered ) return val;
val = jQuery.event.handle.apply(arguments.callee.elem, arguments);
return val;
}); // Add elem as a property of the handle function // This is to prevent a memory leak with non-native // event in IE.
handle.elem = elem;
// Handle multiple events seperated by a space // jQuery(...).bind("mouseover mouseout", fn);
jQuery.each(types.split(/\s+/), function(index, type) { // Namespaced event handlers var parts = type.split(".");
type = parts[0];
handler.type = parts[1];
// Get the current list of functions bound to this event var handlers = events[type];
// Init the event handler queue if (!handlers) {
handlers = events[type] = {};
// Check for a special event handler // Only use addEventListener/attachEvent if the special // events handler returns false if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) { // Bind the global event handler to the element if (elem.addEventListener)
elem.addEventListener(type, handle, false); elseif (elem.attachEvent)
elem.attachEvent("on" + type, handle);
}
}
// Add the function to the element's handler list
handlers[handler.guid] = handler;
// Keep track of which events have been used, for global triggering
jQuery.event.global[type] = true;
});
// Nullify elem to prevent memory leaks in IE
elem = null;
},
guid: 1,
global: {},
// Detach an event or set of events from an element
remove: function(elem, types, handler) { // don't do events on text and comment nodes if ( elem.nodeType == 3 || elem.nodeType == 8 ) return;
var events = jQuery.data(elem, "events"), ret, index;
if ( events ) { // Unbind all events for the element if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") ) for ( var type in events ) this.remove( elem, type + (types || "") ); else { // types is actually an event object here if ( types.type ) {
handler = types.handler;
types = types.type;
}
// Handle multiple events seperated by a space // jQuery(...).unbind("mouseover mouseout", fn);
jQuery.each(types.split(/\s+/), function(index, type){ // Namespaced event handlers var parts = type.split(".");
type = parts[0];
if ( events[type] ) { // remove the given handler for the given type if ( handler ) delete events[type][handler.guid];
// remove all handlers for the given type else for ( handler in events[type] ) // Handle the removal of namespaced events if ( !parts[1] || events[type][handler].type == parts[1] ) delete events[type][handler];
// remove generic event handler if no more handlers exist for ( ret in events[type] ) break; if ( !ret ) { if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) { if (elem.removeEventListener)
elem.removeEventListener(type, jQuery.data(elem, "handle"), false); elseif (elem.detachEvent)
elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
}
ret = null; delete events[type];
}
}
});
}
// Remove the expando if it's no longer used for ( ret in events ) break; if ( !ret ) { var handle = jQuery.data( elem, "handle" ); if ( handle ) handle.elem = null;
jQuery.removeData( elem, "events" );
jQuery.removeData( elem, "handle" );
}
}
},
trigger: function(type, data, elem, donative, extra) { // Clone the incoming data, if any
data = jQuery.makeArray(data || []);
if ( type.indexOf("!") >= 0 ) {
type = type.slice(0, -1); var exclusive = true;
}
// Handle a global trigger if ( !elem ) { // Only trigger if we've ever bound an event for it if ( this.global[type] )
jQuery("*").add([window, document]).trigger(type, data);
// Handle triggering a single element
} else { // don't do events on text and comment nodes if ( elem.nodeType == 3 || elem.nodeType == 8 ) return undefined;
var val, ret, fn = jQuery.isFunction( elem[ type ] || null ), // Check to see if we need to provide a fake event, or not
event = !data[0] || !data[0].preventDefault;
// Pass along a fake event if ( event )
data.unshift( this.fix({ type: type, target: elem }) );
// Enforce the right trigger type
data[0].type = type; if ( exclusive )
data[0].exclusive = true;
// Trigger the event if ( jQuery.isFunction( jQuery.data(elem, "handle") ) )
val = jQuery.data(elem, "handle").apply( elem, data );
// Handle triggering native .onfoo handlers if ( !fn && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
val = false;
// Extra functions don't get the custom event object if ( event )
data.shift();
// Handle triggering of extra function if ( extra && jQuery.isFunction( extra ) ) { // call the extra function and tack the current return value on the end for possible inspection
ret = extra.apply( elem, val == null ? data : data.concat( val ) ); // if anything is returned, give it precedence and have it overwrite the previous value if (ret !== undefined)
val = ret;
}
// Trigger the native events (except for clicks on links) if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) { this.triggered = true; try {
elem[ type ](); // prevent IE from throwing an error for some hidden elements
} catch (e) {}
}
this.triggered = false;
}
return val;
},
handle: function(event) { // returned undefined or false var val;
// Empty object is for triggered events with no data
event = jQuery.event.fix( event || window.event || {} );
// Namespaced event handlers var parts = event.type.split(".");
event.type = parts[0];
for ( var j in handlers ) { var handler = handlers[j]; // Pass in a reference to the handler function itself // So that we can later remove it
args[0].handler = handler;
args[0].data = handler.data;
// Filter the functions by class if ( !parts[1] && !event.exclusive || handler.type == parts[1] ) { var ret = handler.apply( this, args );
if ( val !== false )
val = ret;
if ( ret === false ) {
event.preventDefault();
event.stopPropagation();
}
}
}
// Clean up added properties in IE to prevent memory leak if (jQuery.browser.msie)
event.target = event.preventDefault = event.stopPropagation =
event.handler = event.data = null;
return val;
},
fix: function(event) { // store a copy of the original event object // and clone to set read-only properties var originalEvent = event;
event = jQuery.extend({}, originalEvent);
// add preventDefault and stopPropagation since // they will not work on the clone
event.preventDefault = function() { // if preventDefault exists run it on the original event if (originalEvent.preventDefault)
originalEvent.preventDefault(); // otherwise set the returnValue property of the original event to false (IE)
originalEvent.returnValue = false;
};
event.stopPropagation = function() { // if stopPropagation exists run it on the original event if (originalEvent.stopPropagation)
originalEvent.stopPropagation(); // otherwise set the cancelBubble property of the original event to true (IE)
originalEvent.cancelBubble = true;
};
// Fix target property, if necessary if ( !event.target )
event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
// check if target is a textnode (safari) if ( event.target.nodeType == 3 )
event.target = originalEvent.target.parentNode;
// Add relatedTarget, if necessary if ( !event.relatedTarget && event.fromElement )
event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
// Calculate pageX/Y if missing and clientX/Y available if ( event.pageX == null && event.clientX != null ) { var doc = document.documentElement, body = document.body;
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
}
// Add which for key events if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
event.which = event.charCode || event.keyCode;
// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs) if ( !event.metaKey && event.ctrlKey )
event.metaKey = event.ctrlKey;
// Add which for click: 1 == left; 2 == middle; 3 == right // Note: button is not normalized, so don't use it if ( !event.which && event.button )
event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
return event;
},
special: {
ready: {
setup: function() { // Make sure the ready event is setup
bindReady(); return;
},
handler: function(event) { // If we actually just moused on to a sub-element, ignore it if ( withinElement(event, this) ) returntrue; // Execute the right handlers by setting the event type to mouseenter
arguments[0].type = "mouseenter"; return jQuery.event.handle.apply(this, arguments);
}
},
handler: function(event) { // If we actually just moused on to a sub-element, ignore it if ( withinElement(event, this) ) returntrue; // Execute the right handlers by setting the event type to mouseleave
arguments[0].type = "mouseleave"; return jQuery.event.handle.apply(this, arguments);
}
}
}
};
ready: function(fn) { // Attach the listeners
bindReady();
// If the DOM is already ready if ( jQuery.isReady ) // Execute the function immediately
fn.call( document, jQuery );
// Otherwise, remember the function for later else // Add the function to the wait list
jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
returnthis;
}
});
jQuery.extend({
isReady: false,
readyList: [], // Handle when the DOM is ready
ready: function() { // Make sure that the DOM is not already loaded if ( !jQuery.isReady ) { // Remember that the DOM is ready
jQuery.isReady = true;
// If there are functions bound, to execute if ( jQuery.readyList ) { // Execute all of them
jQuery.each( jQuery.readyList, function(){ this.apply( document );
});
// Reset the list of functions
jQuery.readyList = null;
}
// Trigger any bound ready events
jQuery(document).triggerHandler("ready");
}
--> --------------------
--> maximum size reached
--> --------------------
Messung V0.5
¤ Dauer der Verarbeitung: 0.14 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
