after
after: function() {
// <summary>
// Insert content after each of the matched elements.
// Part of DOM/Manipulation
// </summary>
// <returns type="jQuery" />
// <param name="" type="Content">
// Content to insert after each target.
// </param>
return this.domManip(arguments, false, function(elem){
this.parentNode.insertBefore( elem, this.nextSibling );
});
},
end: function() {
// <summary>
// End the most recent 'destructive' operation, reverting the list of matched elements
// back to its previous state. After an end operation, the list of matched elements will
// revert to the last state of matched elements.
// If there was no destructive operation before, an empty set is returned.
// Part of DOM/Traversing
// </summary>
// <returns type="jQuery" />
return this.prevObject || jQuery( [] );
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: [].push,
sort: [].sort,
splice: [].splice,
find: function( selector ) {
// <summary>
// Searches for all elements that match the specified expression.
// This method is a good way to find additional descendant
// elements with which to process.
// All searching is done using a jQuery expression. The expression can be
// written using CSS 1-3 Selector syntax, or basic XPath.
// Part of DOM/Traversing
// </summary>
// <returns type="jQuery" />
// <param name="selector" type="String">
// An expression to search with.
// </param>
// <returns type="jQuery" />
if ( this.length === 1 ) {
var ret = this.pushStack( [], "find", selector );
ret.length = 0;
jQuery.find( selector, this[0], ret );
return ret;
} else {
return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){
return jQuery.find( selector, elem );
})), "find", selector );
}
},
clone: function( events ) {
// <summary>
// Clone matched DOM Elements and select the clones.
// This is useful for moving copies of the elements to another
// location in the DOM.
// Part of DOM/Manipulation
// </summary>
// <returns type="jQuery" />
// <param name="deep" type="Boolean" optional="true">
// (Optional) Set to false if you don't want to clone all descendant nodes, in addition to the element itself.
// </param>
// Do the clone
var ret = this.map(function(){
if ( !jQuery.support.noCloneEvent && !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 html = this.outerHTML;
if ( !html ) {
var div = this.ownerDocument.createElement("div");
div.appendChild( this.cloneNode(true) );
html = div.innerHTML;
}
return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];
} else
return this.cloneNode(true);
});
// Copy the events from the original to the clone
if ( events === true ) {
var orig = this.find("*").andSelf(), i = 0;
ret.find("*").andSelf().each(function(){
if ( this.nodeName !== orig[i].nodeName )
return;
var events = jQuery.data( orig[i], "events" );
for ( var type in events ) {
for ( var handler in events[ type ] ) {
jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
}
}
i++;
});
}
// Return the cloned set
return ret;
},
filter: function( selector ) {
//
<summary>
// Removes all elements from the set of matched elements that do not
// pass the specified filter. This method is used to narrow down
// the results of a search.
// })
// Part of DOM/Traversing
//
</summary>
//
<returns type="jQuery" />
//
<param name="selector" type="Function">
// A function to use for filtering
//
</param>
//
<returns type="jQuery" />
return this.pushStack(
jQuery.isFunction( selector ) &&
jQuery.grep(this, function(elem, i){
return selector.call( elem, i );
}) ||
jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
return elem.nodeType === 1;
}) ), "filter", selector );
},
closest: function( selector ) {
//
<summary>
// Get a set of elements containing the closest parent element that matches the specified selector, the starting element included.
//
</summary>
//
<returns type="jQuery" />
//
<param name="selector" type="Function">
// An expression to filter the elements with.
//
</param>
//
<returns type="jQuery" />
var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,
closer = 0;
return this.map(function(){
var cur = this;
while ( cur && cur.ownerDocument ) {
if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {
jQuery.data(cur, "closest", closer);
return cur;
}
cur = cur.parentNode;
closer++;
}
});
},
not: function( selector ) {
//
<summary>
// Removes any elements inside the array of elements from the set
// of matched elements. This method is used to remove one or more
// elements from a jQuery object.
// Part of DOM/Traversing
//
</summary>
//
<param name="selector" type="jQuery">
// A set of elements to remove from the jQuery set of matched elements.
//
</param>
//
<returns type="jQuery" />
if ( typeof selector === "string" )
// test special case where just one selector is passed in
if ( isSimple.test( selector ) )
return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
else
selector = jQuery.multiFilter( selector, this );
var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
return this.filter(function() {
return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
});
},
add: function( selector ) {
//
<summary>
// Adds one or more Elements to the set of matched elements.
// Part of DOM/Traversing
//
</summary>
//
<param name="elements" type="Element">
// One or more Elements to add
//
</param>
//
<returns type="jQuery" />
return this.pushStack( jQuery.unique( jQuery.merge(
this.get(),
typeof selector === "string" ?
jQuery( selector ) :
jQuery.makeArray( selector )
)));
},
is: function( selector ) {
//
<summary>
// Checks the current selection against an expression and returns true,
// if at least one element of the selection fits the given expression.
// Does return false, if no element fits or the expression is not valid.
// filter(String) is used internally, therefore all rules that apply there
// apply here, too.
// Part of DOM/Traversing
//
</summary>
//
<returns type="Boolean" />
//
<param name="expr" type="String">
// The expression with which to filter
//
</param>
return !!selector && jQuery.multiFilter( selector, this ).length > 0;
},
hasClass: function( selector ) {
//
<summary>
// Checks the current selection against a class and returns whether at least one selection has a given class.
//
</summary>
//
<param name="selector" type="String">The class to check against
</param>
//
<returns type="Boolean">True if at least one element in the selection has the class, otherwise false.
</returns>
return !!selector && this.is( "." + selector );
},
val: function( value ) {
//
<summary>
// Set the value of every matched element.
// Part of DOM/Attributes
//
</summary>
//
<returns type="jQuery" />
//
<param name="val" type="String">
// Set the property to the specified value.
//
</param>
if ( value === undefined ) {
var elem = this[0];
if ( elem ) {
if( jQuery.nodeName( elem, 'option' ) )
return (elem.attributes.value || {}).specified ? elem.value : elem.text;
// 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 )
return null;
// 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(option).val();
// 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
return (elem.value || "").replace(/\r/g, "");
}
return undefined;
}
if ( typeof value === "number" )
value += '';
return this.each(function(){
if ( this.nodeType != 1 )
return;
if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
this.checked = (jQuery.inArray(this.value, value) >= 0 ||
jQuery.inArray(this.name, value) >= 0);
else if ( jQuery.nodeName( this, "select" ) ) {
var values = jQuery.makeArray(value);
jQuery( "option", this ).each(function(){
this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
jQuery.inArray( this.text, values ) >= 0);
});
if ( !values.length )
this.selectedIndex = -1;
} else
this.value = value;
});
},
html: function( value ) {
//
<summary>
// Set the html contents of every matched element.
// This property is not available on XML documents.
// Part of DOM/Attributes
//
</summary>
//
<returns type="jQuery" />
//
<param name="val" type="String">
// Set the html contents to the specified value.
//
</param>
return value === undefined ?
(this[0] ?
this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :
null) :
this.empty().append( value );
},
replaceWith: function( value ) {
//
<summary>
// Replaces all matched element with the specified HTML or DOM elements.
//
</summary>
//
<param name="value" type="String">
// The content with which to replace the matched elements.
//
</param>
//
<returns type="jQuery">The element that was just replaced.
</returns>
return this.after( value ).remove();
},
eq: function( i ) {
//
<summary>
// Reduce the set of matched elements to a single element.
// The position of the element in the set of matched elements
// starts at 0 and goes to length - 1.
// Part of Core
//
</summary>
//
<returns type="jQuery" />
//
<param name="num" type="Number">
// pos The index of the element that you wish to limit to.
//
</param>
return this.slice( i, +i + 1 );
},
slice: function() {
//
<summary>
// Selects a subset of the matched elements. Behaves exactly like the built-in Array slice method.
//
</summary>
//
<param name="start" type="Number" integer="true">Where to start the subset (0-based).
</param>
//
<param name="end" optional="true" type="Number" integer="true">Where to end the subset (not including the end element itself).
// If omitted, ends at the end of the selection
</param>
//
<returns type="jQuery">The sliced elements
</returns>
return this.pushStack( Array.prototype.slice.apply( this, arguments ),
"slice", Array.prototype.slice.call(arguments).join(",") );
},
map: function( callback ) {
//
<summary>
// This member is internal.
//
</summary>
//
<private />
//
<returns type="jQuery" />
return this.pushStack( jQuery.map(this, function(elem, i){
return callback.call( elem, i, elem );
}));
},
andSelf: function() {
//
<summary>
// Adds the previous selection to the current selection.
//
</summary>
//
<returns type="jQuery" />
return this.add( this.prevObject );
},
domManip: function( args, table, callback ) {
//
<param name="args" type="Array">
// Args
//
</param>
//
<param name="table" type="Boolean">
// Insert TBODY in TABLEs if one is not found.
//
</param>
//
<param name="dir" type="Number">
// If dir<0, process args in reverse order.
//
</param>
//
<param name="fn" type="Function">
// The function doing the DOM manipulation.
//
</param>
//
<returns type="jQuery" />
//
<summary>
// Part of Core
//
</summary>
if ( this[0] ) {
var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
first = fragment.firstChild;
if ( first )
for ( var i = 0, l = this.length; i < l; i++ )
callback.call( root(this[i], first), this.length > 1 || i > 0 ?
fragment.cloneNode(true) : fragment );
if ( scripts )
jQuery.each( scripts, evalScript );
}
return this;
function root( elem, cur ) {
return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
(elem.getElementsByTagName("tbody")[0] ||
elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
elem;
}
}
};
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;
function evalScript( i, elem ) {
//
<summary>
// This method is internal.
//
</summary>
//
<private />
if ( elem.src )
jQuery.ajax({
url: elem.src,
async: false,
dataType: "script"
});
else
jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
if ( elem.parentNode )
elem.parentNode.removeChild( elem );
}
function now(){
//
<summary>
// Gets the current date.
//
</summary>
//
<returns type="Date">The current date.
</returns>
return +new Date;
}
jQuery.extend = jQuery.fn.extend = function() {
//
<summary>
// Extend one object with one or more others, returning the original,
// modified, object. This is a great utility for simple inheritance.
// jQuery.extend(settings, options);
// var settings = jQuery.extend({}, defaults, options);
// Part of JavaScript
//
</summary>
//
<param name="target" type="Object">
// The object to extend
//
</param>
//
<param name="prop1" type="Object">
// The object that will be merged into the first.
//
</param>
//
<param name="propN" type="Object" optional="true" parameterArray="true">
// (optional) More objects to merge into the first
//
</param>
//
<returns type="Object" />
// copy reference to target object
var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
// Handle a deep copy situation
if ( typeof target === "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" && !jQuery.isFunction(target) )
target = {
};
// extend jQuery itself if only one argument is passed
if ( length == i ) {
target = this;
--i;
}
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 ) {
var src = target[ name ], copy = options[ name ];
// Prevent never-ending loop
if ( target === copy )
continue;
// Recurse if we're merging object values
if ( deep && copy && typeof copy === "object" && !copy.nodeType )
target[ name ] = jQuery.extend( deep,
// Never move original objects, clone them
src || ( copy.length != null ? [ ] : { } )
, copy );
// Don't bring in undefined values
else if ( copy !== undefined )
target[ name ] = copy;
}
// Return the modified object
return target;
};
// exclude the following css properties to add px
var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
// cache defaultView
defaultView = document.defaultView || {},
toString = Object.prototype.toString;
jQuery.extend({
noConflict: function( deep ) {
//
<summary>
// Run this function to give control of the variable back
// to whichever library first implemented it. This helps to make
// sure that jQuery doesn't conflict with the
= _
/i.test( ret ) && /^\d/.test( ret ) ) {
// Remember the original values
var left = style.left, rsLeft = elem.runtimeStyle.left;
// Put in the new values to get a computed value out
elem.runtimeStyle.left = elem.currentStyle.left;
style.left = ret || 0;
ret = style.pixelLeft + "px";
// Revert the changed values
style.left = left;
elem.runtimeStyle.left = rsLeft;
}
}
return ret;
},
clean: function( elems, context, fragment ) {
//
<summary>
// This method is internal only.
//
</summary>
//
<private />
// This method is undocumented in the jQuery API:
http://docs.jquery.com/action/edit/Internals/jQuery.clean
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;
// If a single string is passed in and it's a single tag
// just do a createElement and skip the rest
if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
var match = /^<(\w+)\s*\/?>
/i) ?
all :
front + "></" + tag + ">";
});
// Trim whitespace, otherwise indexOf won't work as expected
var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();
var wrap =
// option or optgroup
!tags.indexOf("
<opt") &&
[ 1, "
<select multiple='multiple'>", "
</select>" ] ||
!tags.indexOf("
<leg") &&
[ 1, "
<fieldset>", "
</fieldset>" ] ||
tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
[ 1, "
<table>", "
</table>" ] ||
!tags.indexOf("
<tr") &&
[ 2, "
<table><tbody>", "
</tbody></table>" ] ||
//
<thead> matched above
(!tags.indexOf("
<td") || !tags.indexOf("
<th")) &&
[ 3, "
<table><tbody><tr>", "
</tr></tbody></table>" ] ||
!tags.indexOf("
<col") &&
[ 2, "
<table><tbody></tbody><colgroup>", "
</colgroup></table>" ] ||
// IE can't serialize
<link> and
<script> tags normally
!jQuery.support.htmlSerialize &&
[ 1, "div
<div>", "
</div>" ] ||
[ 0, "", "" ];
// Go to html and back, then peel off extra wrappers
div.innerHTML = wrap[1] + elem + wrap[2];
// Move to the right depth
while ( wrap[0]-- )
div = div.lastChild;
// Remove IE's autoinserted
<tbody> from table fragments
if ( !jQuery.support.tbody ) {
// String was a
<table>, *may* have spurious
<tbody>
var hasBody = /
<tbody/i.test(elem),
tbody = !tags.indexOf("
<table") && !hasBody ?
div.firstChild && div.firstChild.childNodes :
// String was a bare
<thead> or
<tfoot>
wrap[1] == "
<table>" && !hasBody ?
div.childNodes :
[];
for ( var j = tbody.length - 1; j >= 0 ; --j )
if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
tbody[ j ].parentNode.removeChild( tbody[ j ] );
}
// IE completely kills leading whitespace when innerHTML is used
if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
elem = jQuery.makeArray( div.childNodes );
}
if ( elem.nodeType )
ret.push( elem );
else
ret = jQuery.merge( ret, elem );
});
if ( fragment ) {
for ( var i = 0; ret[i]; i++ ) {
if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
} else {
if ( ret[i].nodeType === 1 )
ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
fragment.appendChild( ret[i] );
}
}
return scripts;
}
return ret;
},
attr: function( elem, name, value ) {
// <summary>
// This method is internal.
//
</summary>
//
<private />
// don't set attributes on text and comment nodes
if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
return undefined;
var notxml = !jQuery.isXMLDoc( elem ),
// Whether we are setting (or getting)
set = value !== undefined;
// Try to normalize/fix the name
name = notxml && jQuery.props[ name ] || name;
// Only do all the following if this is a node (faster for style)
// IE elem.getAttribute passes even for style
if ( elem.tagName ) {
// These attributes require special treatment
var special = /href|src|style/.test( name );
// Safari mis-reports the default selected property of a hidden option
// Accessing the parent's selectedIndex property fixes it
if ( name == "selected" && elem.parentNode )
elem.parentNode.selectedIndex;
// If applicable, access the attribute via the DOM 0 way
if ( name in elem && notxml && !special ) {
if ( set ){
// 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";
elem[ name ] = value;
}
// browsers index elements by id/name on forms, give priority to attributes.
if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
return elem.getAttributeNode( name ).nodeValue;
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
//
http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
if ( name == "tabIndex" ) {
var attributeNode = elem.getAttributeNode( "tabIndex" );
return attributeNode && attributeNode.specified
? attributeNode.value
: elem.nodeName.match(/(button|input|object|select|textarea)/i)
? 0
: elem.nodeName.match(/^(a|area)
/g, "" );
},
makeArray: function( array ) {
//
<summary>
// Turns anything into a true array. This is an internal method.
//
</summary>
//
<param name="array" type="Object">Anything to turn into an actual Array
</param>
//
<returns type="Array" />
//
<private />
var ret = [];
if( array != null ){
var i = array.length;
// The window, strings (and functions) also have 'length'
if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
ret[0] = array;
else
while( i )
ret[--i] = array[i];
}
return ret;
},
inArray: function( elem, array ) {
//
<summary>
// Determines the index of the first parameter in the array.
//
</summary>
//
<param name="elem">The value to see if it exists in the array.
</param>
//
<param name="array" type="Array">The array to look through for the value
</param>
//
<returns type="Number" integer="true">The 0-based index of the item if it was found, otherwise -1.
</returns>
for ( var i = 0, length = array.length; i < length; i++ )
// Use === because on IE, window == document
if ( array[ i ] === elem )
return i;
return -1;
},
merge: function( first, second ) {
//
<summary>
// Merge two arrays together, removing all duplicates.
// The new array is: All the results from the first array, followed
// by the unique results from the second array.
// Part of JavaScript
//
</summary>
//
<returns type="Array" />
//
<param name="first" type="Array">
// The first array to merge.
//
</param>
//
<param name="second" type="Array">
// The second array to merge.
//
</param>
// We have to loop this way because IE & Opera overwrite the length
// expando of getElementsByTagName
var i = 0, elem, pos = first.length;
// Also, we need to make sure that the correct elements are being returned
// (IE returns comment nodes in a '*' query)
if ( !jQuery.support.getAll ) {
while ( (elem = second[ i++ ]) != null )
if ( elem.nodeType != 8 )
first[ pos++ ] = elem;
} else
while ( (elem = second[ i++ ]) != null )
first[ pos++ ] = elem;
return first;
},
unique: function( array ) {
//
<summary>
// Removes all duplicate elements from an array of elements.
//
</summary>
//
<param name="array" type="Array<Element>">The array to translate
</param>
//
<returns type="Array<Element>">The array after translation.
</returns>
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 ) {
//
<summary>
// Filter items out of an array, by using a filter function.
// The specified function will be passed two arguments: The
// current array item and the index of the item in the array. The
// function must return 'true' to keep the item in the array,
// false to remove it.
// });
// Part of JavaScript
//
</summary>
//
<returns type="Array" />
//
<param name="elems" type="Array">
// array The Array to find items in.
//
</param>
//
<param name="fn" type="Function">
// The function to process each item against.
//
</param>
//
<param name="inv" type="Boolean">
// Invert the selection - select the opposite of the function.
//
</param>
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 ) )
ret.push( elems[ i ] );
return ret;
},
map: function( elems, callback ) {
//
<summary>
// Translate all items in an array to another array of items.
// The translation function that is provided to this method is
// called for each item in the array and is passed one argument:
// The item to be translated.
// The function can then return the translated value, 'null'
// (to remove the item), or an array of values - which will
// be flattened into the full array.
// Part of JavaScript
//
</summary>
//
<returns type="Array" />
//
<param name="elems" type="Array">
// array The Array to translate.
//
</param>
//
<param name="fn" type="Function">
// The function to process each item against.
//
</param>
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 )
ret[ ret.length ] = value;
}
return ret.concat.apply( [], ret );
}
});
// Use of jQuery.browser is deprecated.
// It's included for backwards compatibility and plugins,
// although they should work to migrate away.
var userAgent = navigator.userAgent.toLowerCase();
// Figure out what browser is being used
jQuery.browser = {
version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
safari: /webkit/.test( userAgent ),
opera: /opera/.test( userAgent ),
msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// jQuery.each({
// parent: function(elem){return elem.parentNode;},
// parents: function(elem){return jQuery.dir(elem,"parentNode");},
// next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
// prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
// nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
// prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
// siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
// children: function(elem){return jQuery.sibling(elem.firstChild);},
// contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
// }, function(name, fn){
// jQuery.fn[ name ] = function( selector ) {
// //
<summary>
// // Get a set of elements containing the unique parents of the matched
// // set of elements.
// // Can be filtered with an optional expressions.
// // Part of DOM/Traversing
// //
</summary>
// //
<param name="expr" type="String" optional="true">
// // (optional) An expression to filter the parents with
// //
</param>
// //
<returns type="jQuery" />
//
// var ret = jQuery.map( this, fn );
//
// if ( selector && typeof selector == "string" )
// ret = jQuery.multiFilter( selector, ret );
//
// return this.pushStack( jQuery.unique( ret ), name, selector );
//
};
// });
jQuery.each({
parent: function(elem){return elem.parentNode;}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Get a set of elements containing the unique parents of the matched
// set of elements.
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the parents with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
parents: function(elem){return jQuery.dir(elem,"parentNode");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Get a set of elements containing the unique ancestors of the matched
// set of elements (except for the root element).
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the ancestors with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
next: function(elem){return jQuery.nth(elem,2,"nextSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Get a set of elements containing the unique next siblings of each of the
// matched set of elements.
// It only returns the very next sibling, not all next siblings.
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the next Elements with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Get a set of elements containing the unique previous siblings of each of the
// matched set of elements.
// Can be filtered with an optional expressions.
// It only returns the immediately previous sibling, not all previous siblings.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the previous Elements with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}
}, function(name, fn){
jQuery.fn[name] = function(selector) {
//
<summary>
// Finds all sibling elements after the current element.
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the next Elements with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
prevAll: function(elem){return jQuery.dir(elem,"previousSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Finds all sibling elements before the current element.
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the previous Elements with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Get a set of elements containing all of the unique siblings of each of the
// matched set of elements.
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the sibling Elements with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
children: function(elem){return jQuery.sibling(elem.firstChild);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>
// Get a set of elements containing all of the unique children of each of the
// matched set of elements.
// Can be filtered with an optional expressions.
// Part of DOM/Traversing
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) An expression to filter the child Elements with
//
</param>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
//
<summary>Finds all the child nodes inside the matched elements including text nodes, or the content document if the element is an iframe.
</summary>
//
<returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// jQuery.each({
// appendTo: "append",
// prependTo: "prepend",
// insertBefore: "before",
// insertAfter: "after",
// replaceAll: "replaceWith"
// }, function(name, original){
// jQuery.fn[ name ] = function() {
// var args = arguments;
//
// return this.each(function(){
// for ( var i = 0, length = args.length; i < length; i++ )
// jQuery( args[ i ] )[ original ]( this );
// });
//
};
// });
jQuery.fn.appendTo = function( selector ) {
//
<summary>
// Append all of the matched elements to another, specified, set of elements.
// As of jQuery 1.3.2, returns all of the inserted elements.
// This operation is, essentially, the reverse of doing a regular
// A.append(B), in that instead of appending B to A, you're appending
// A to B.
//
</summary>
//
<param name="selector" type="Selector">
// target to which the content will be appended.
//
</param>
//
<returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "append" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "appendTo", selector );
};
jQuery.fn.prependTo = function( selector ) {
//
<summary>
// Prepend all of the matched elements to another, specified, set of elements.
// As of jQuery 1.3.2, returns all of the inserted elements.
// This operation is, essentially, the reverse of doing a regular
// A.prepend(B), in that instead of prepending B to A, you're prepending
// A to B.
//
</summary>
//
<param name="selector" type="Selector">
// target to which the content will be appended.
//
</param>
//
<returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "prepend" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "prependTo", selector );
};
jQuery.fn.insertBefore = function( selector ) {
//
<summary>
// Insert all of the matched elements before another, specified, set of elements.
// As of jQuery 1.3.2, returns all of the inserted elements.
// This operation is, essentially, the reverse of doing a regular
// A.before(B), in that instead of inserting B before A, you're inserting
// A before B.
//
</summary>
//
<param name="content" type="String">
// Content after which the selected element(s) is inserted.
//
</param>
//
<returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "before" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "insertBefore", selector );
};
jQuery.fn.insertAfter = function( selector ) {
//
<summary>
// Insert all of the matched elements after another, specified, set of elements.
// As of jQuery 1.3.2, returns all of the inserted elements.
// This operation is, essentially, the reverse of doing a regular
// A.after(B), in that instead of inserting B after A, you're inserting
// A after B.
//
</summary>
//
<param name="content" type="String">
// Content after which the selected element(s) is inserted.
//
</param>
//
<returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "after" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "insertAfter", selector );
};
jQuery.fn.replaceAll = function( selector ) {
//
<summary>
// Replaces the elements matched by the specified selector with the matched elements.
// As of jQuery 1.3.2, returns all of the inserted elements.
//
</summary>
//
<param name="selector" type="Selector">The elements to find and replace the matched elements with.
</param>
//
<returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "replaceWith" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "replaceAll", selector );
};
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// jQuery.each({
// removeAttr: function( name ) {
// jQuery.attr( this, name, "" );
// if (this.nodeType == 1)
// this.removeAttribute( name );
// },
//
// addClass: function( classNames ) {
// jQuery.className.add( this, classNames );
// },
//
// removeClass: function( classNames ) {
// jQuery.className.remove( this, classNames );
// },
//
// toggleClass: function( classNames, state ) {
// if( typeof state !== "boolean" )
// state = !jQuery.className.has( this, classNames );
// jQuery.className[ state ? "add" : "remove" ]( this, classNames );
// },
//
// remove: function( selector ) {
// if ( !selector || jQuery.filter( selector, [ this ] ).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(){
// return this.each( fn, arguments );
//
};
// });
jQuery.fn.removeAttr = function(){
//
<summary>
// Remove an attribute from each of the matched elements.
// Part of DOM/Attributes
//
</summary>
//
<param name="key" type="String">
// name The name of the attribute to remove.
//
</param>
//
<returns type="jQuery" />
return this.each( function( name ) {
jQuery.attr( this, name, "" );
if (this.nodeType == 1)
this.removeAttribute( name );
}, arguments );
};
jQuery.fn.addClass = function(){
//
<summary>
// Adds the specified class(es) to each of the set of matched elements.
// Part of DOM/Attributes
//
</summary>
//
<param name="classNames" type="String">
// lass One or more CSS classes to add to the elements
//
</param>
//
<returns type="jQuery" />
return this.each( function( classNames ) {
jQuery.className.add( this, classNames );
}, arguments );
};
jQuery.fn.removeClass = function(){
//
<summary>
// Removes all or the specified class(es) from the set of matched elements.
// Part of DOM/Attributes
//
</summary>
//
<param name="cssClasses" type="String" optional="true">
// (Optional) One or more CSS classes to remove from the elements
//
</param>
//
<returns type="jQuery" />
return this.each( function( classNames ) {
jQuery.className.remove( this, classNames );
}, arguments );
};
jQuery.fn.toggleClass = function(){
//
<summary>
// Adds the specified class if it is not present, removes it if it is
// present.
// Part of DOM/Attributes
//
</summary>
//
<param name="cssClass" type="String">
// A CSS class with which to toggle the elements
//
</param>
//
<returns type="jQuery" />
return this.each( function( classNames, state ) {
if( typeof state !== "boolean" )
state = !jQuery.className.has( this, classNames );
jQuery.className[ state ? "add" : "remove" ]( this, classNames );
}, arguments );
};
jQuery.fn.remove = function(){
//
<summary>
// Removes all matched elements from the DOM. This does NOT remove them from the
// jQuery object, allowing you to use the matched elements further.
// Can be filtered with an optional expressions.
// Part of DOM/Manipulation
//
</summary>
//
<param name="expr" type="String" optional="true">
// (optional) A jQuery expression to filter elements by.
//
</param>
//
<returns type="jQuery" />
return this.each( function( selector ) {
if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
// Prevent memory leaks
jQuery( "*", this ).add([this]).each(function(){
jQuery.event.remove(this);
jQuery.removeData(this);
});
if (this.parentNode)
this.parentNode.removeChild( this );
}
}, arguments );
};
jQuery.fn.empty = function(){
//
<summary>
// Removes all child nodes from the set of matched elements.
// Part of DOM/Manipulation
//
</summary>
//
<returns type="jQuery" />
return this.each( function() {
// Remove element nodes and prevent memory leaks
jQuery(this).children().remove();
// Remove any remaining nodes
while ( this.firstChild )
this.removeChild( this.firstChild );
}, arguments );
};
// Helper function used by the dimensions and offset modules
function num(elem, prop) {
return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
}
var expando = "jQuery" + now(), uuid = 0, windowData = {
};
jQuery.extend({
cache: {},
data: function( elem, name, data ) {
elem = elem == window ?
windowData :
elem;
var id = elem[ expando ];
// Compute a unique ID for the element
if ( !id )
id = elem[ expando ] = ++uuid;
// Only generate the data cache if we're
// trying to access or manipulate it
if ( name && !jQuery.cache[ id ] )
jQuery.cache[ id ] = {
};
// Prevent overriding the named cache with undefined values
if ( data !== undefined )
jQuery.cache[ id ][ name ] = data;
// Return the named cache data, or the ID for the element
return name ?
jQuery.cache[ id ][ name ] :
id;
},
removeData: function( elem, name ) {
elem = elem == window ?
windowData :
elem;
var id = elem[ expando ];
// 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 ];
}
},
queue: function( elem, type, data ) {
if ( elem ){
type = (type || "fx") + "queue";
var q = jQuery.data( elem, type );
if ( !q || jQuery.isArray(data) )
q = jQuery.data( elem, type, jQuery.makeArray(data) );
else if( data )
q.push( data );
}
return q;
},
dequeue: function( elem, type ){
var queue = jQuery.queue( elem, type ),
fn = queue.shift();
if( !type || type === "fx" )
fn = queue[0];
if( fn !== undefined )
fn.call(elem);
}
});
jQuery.fn.extend({
data: function( key, value ){
var parts = key.split(".");
parts[1] = parts[1] ? "." + parts[1] : "";
if ( value === undefined ) {
var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
if ( data === undefined && this.length )
data = jQuery.data( this[0], key );
return data === undefined && parts[1] ?
this.data( parts[0] ) :
data;
} else
return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
jQuery.data( this, key, value );
});
},
removeData: function( key ){
return this.each(function(){
jQuery.removeData( this, key );
});
},
queue: function(type, data){
//
<summary>
// 1: queue() - Returns a reference to the first element's queue (which is an array of functions).
// 2: queue(callback) - Adds a new function, to be executed, onto the end of the queue of all matched elements.
// 3: queue(queue) - Replaces the queue of all matched element with this new queue (the array of functions).
//
</summary>
//
<param name="type" type="Function">The function to add to the queue.
</param>
//
<returns type="jQuery" />
if ( typeof type !== "string" ) {
data = type;
type = "fx";
}
if ( data === undefined )
return jQuery.queue( this[0], type );
return this.each(function(){
var queue = jQuery.queue( this, type, data );
if( type == "fx" && queue.length == 1 )
queue[0].call(this);
});
},
dequeue: function(type){
//
<summary>
// Removes a queued function from the front of the queue and executes it.
//
</summary>
//
<param name="type" type="String" optional="true">The type of queue to access.
</param>
//
<returns type="jQuery" />
return this.each(function(){
jQuery.dequeue( this, type );
});
}
});
/*!
* Sizzle CSS Selector Engine - v0.9.3
* Copyright 2009, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
* More information: http://sizzlejs.com/
*/
(function(){
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
done = 0,
toString = Object.prototype.toString;
var Sizzle = function(selector, context, results, seed) {
results = results || [];
context = context || document;
if ( context.nodeType !== 1 && context.nodeType !== 9 )
return [];
if ( !selector || typeof selector !== "string" ) {
return results;
}
var parts = [], m, set, checkSet, check, mode, extra, prune = true;
// Reset the position of the chunker regexp (start from head)
chunker.lastIndex = 0;
while ( (m = chunker.exec(selector)) !== null ) {
parts.push( m[1] );
if ( m[2] ) {
extra = RegExp.rightContext;
break;
}
}
if ( parts.length > 1 && origPOS.exec( selector ) ) {
if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
set = posProcess( parts[0] + parts[1], context );
} else {
set = Expr.relative[ parts[0] ] ?
[ context ] :
Sizzle( parts.shift(), context );
while ( parts.length ) {
selector = parts.shift();
if ( Expr.relative[ selector ] )
selector += parts.shift();
set = posProcess( selector, set );
}
}
} else {
var ret = seed ?
{ expr: parts.pop(), set: makeArray(seed) } :
Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
set = Sizzle.filter( ret.expr, ret.set );
if ( parts.length > 0 ) {
checkSet = makeArray(set);
} else {
prune = false;
}
while ( parts.length ) {
var cur = parts.pop(), pop = cur;
if ( !Expr.relative[ cur ] ) {
cur = "";
} else {
pop = parts.pop();
}
if ( pop == null ) {
pop = context;
}
Expr.relative[ cur ]( checkSet, pop, isXML(context) );
}
}
if ( !checkSet ) {
checkSet = set;
}
if ( !checkSet ) {
throw "Syntax error, unrecognized expression: " + (cur || selector);
}
if ( toString.call(checkSet) === "[object Array]" ) {
if ( !prune ) {
results.push.apply( results, checkSet );
} else if ( context.nodeType === 1 ) {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
results.push( set[i] );
}
}
} else {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
results.push( set[i] );
}
}
}
} else {
makeArray( checkSet, results );
}
if ( extra ) {
Sizzle( extra, context, results, seed );
if ( sortOrder ) {
hasDuplicate = false;
results.sort(sortOrder);
if ( hasDuplicate ) {
for ( var i = 1; i < results.length; i++ ) {
if ( results[i] === results[i-1] ) {
results.splice(i--, 1);
}
}
}
}
}
return results;
};
Sizzle.matches = function(expr, set){
return Sizzle(expr, null, null, set);
};
Sizzle.find = function(expr, context, isXML){
var set, match;
if ( !expr ) {
return [];
}
for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
var type = Expr.order[i], match;
if ( (match = Expr.match[ type ].exec( expr )) ) {
var left = RegExp.leftContext;
if ( left.substr( left.length - 1 ) !== "\\" ) {
match[1] = (match[1] || "").replace(/\\/g, "");
set = Expr.find[ type ]( match, context, isXML );
if ( set != null ) {
expr = expr.replace( Expr.match[ type ], "" );
break;
}
}
}
}
if ( !set ) {
set = context.getElementsByTagName("*");
}
return {set: set, expr: expr
};
};
Sizzle.filter = function(expr, set, inplace, not){
var old = expr, result = [], curLoop = set, match, anyFound,
isXMLFilter = set && set[0] && isXML(set[0]);
while ( expr && set.length ) {
for ( var type in Expr.filter ) {
if ( (match = Expr.match[ type ].exec( expr )) != null ) {
var filter = Expr.filter[ type ], found, item;
anyFound = false;
if ( curLoop == result ) {
result = [];
}
if ( Expr.preFilter[ type ] ) {
match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
if ( !match ) {
anyFound = found = true;
} else if ( match === true ) {
continue;
}
}
if ( match ) {
for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
if ( item ) {
found = filter( item, match, i, curLoop );
var pass = not ^ !!found;
if ( inplace && found != null ) {
if ( pass ) {
anyFound = true;
} else {
curLoop[i] = false;
}
} else if ( pass ) {
result.push( item );
anyFound = true;
}
}
}
}
if ( found !== undefined ) {
if ( !inplace ) {
curLoop = result;
}
expr = expr.replace( Expr.match[ type ], "" );
if ( !anyFound ) {
return [];
}
break;
}
}
}
// Improper expression
if ( expr == old ) {
if ( anyFound == null ) {
throw "Syntax error, unrecognized expression: " + expr;
} else {
break;
}
}
old = expr;
}
return curLoop;
};
var Expr = Sizzle.selectors = {
order: [ "ID", "NAME", "TAG" ],
match: {
ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|
=" ?
value.substr(value.length - check.length) === check :
type === "|=" ?
value === check || value.substr(0, check.length + 1) === check + "-" :
false;
},
POS: function(elem, match, i, array){
var name = match[2], filter = Expr.setFilters[ name ];
if ( filter ) {
return filter( elem, i, match, array );
}
}
}
};
var origPOS = Expr.match.POS;
for ( var type in Expr.match ) {
Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
}
var makeArray = function(array, results) {
array = Array.prototype.slice.call( array );
if ( results ) {
results.push.apply( results, array );
return results;
}
return array;
};
// Perform a simple check to determine if the browser is capable of
// converting a NodeList to an array using builtin methods.
try {
Array.prototype.slice.call( document.documentElement.childNodes );
// Provide a fallback method if it does not work
} catch(e){
makeArray = function(array, results) {
var ret = results || [];
if ( toString.call(array) === "[object Array]" ) {
Array.prototype.push.apply( ret, array );
} else {
if ( typeof array.length === "number" ) {
for ( var i = 0, l = array.length; i < l; i++ ) {
ret.push( array[i] );
}
} else {
for ( var i = 0; array[i]; i++ ) {
ret.push( array[i] );
}
}
}
return ret;
};
}
var sortOrder;
if ( document.documentElement.compareDocumentPosition ) {
sortOrder = function( a, b ) {
var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
} else if ( "sourceIndex" in document.documentElement ) {
sortOrder = function( a, b ) {
var ret = a.sourceIndex - b.sourceIndex;
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
} else if ( document.createRange ) {
sortOrder = function( a, b ) {
var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
aRange.selectNode(a);
aRange.collapse(true);
bRange.selectNode(b);
bRange.collapse(true);
var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
}
// [vsdoc] The following function has been modified for IntelliSense.
// Check to see if the browser returns elements by name when
// querying by getElementById (and provide a workaround)
(function(){
// We're going to inject a fake input element with a specified name