`
JavaSam
  • 浏览: 962614 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

jQ1.2原版

 
阅读更多

(function() {
    /*
    * jQuery 1.2.6 - New Wave Javascript
    *
    * Copyright (c) 2008 John Resig (jquery.com)
    * Dual licensed under the MIT (MIT-LICENSE.txt)
    * and GPL (GPL-LICENSE.txt) licenses.
    *
    * $Date: 2008-05-24 14:22:17 -0400 (Sat, 24 May 2008) $
    * $Rev: 5685 $
    */

    // Map over jQuery in case of overwrite
    var _jQuery = window.jQuery,
    // Map over the $ in case of overwrite
    _$ = window.$;

    var jQuery = window.jQuery = window.$ = function(selector, context) {
        // The jQuery object is actually just the init constructor 'enhanced'
        return new jQuery.fn.init(selector, context);
    };

    // A simple way to check for HTML strings or ID strings
    // (both of which we optimize for)
    var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/,

    // Is it a simple selector
    isSimple = /^.[^:#\[\.]*$/,

    // Will speed up references to undefined, and allows munging its name.
    undefined;

    jQuery.fn = jQuery.prototype = {
        init: function(selector, context) {
            // Make sure that a selection was provided
            selector = selector || document;

            // Handle $(DOMElement)
            if (selector.nodeType) {
                this[0] = selector;
                this.length = 1;
                return this;
            }
            // Handle HTML strings
            if (typeof selector == "string") {
                // Are we dealing with HTML string or an ID?
                var match = quickExpr.exec(selector);

                // Verify a match, and that no context was specified for #id
                if (match && (match[1] || !context)) {

                    // HANDLE: $(html) -> $(array)
                    if (match[1])
                        selector = jQuery.clean([match[1]], context);

                    // HANDLE: $("#id")
                    else {
                        var elem = document.getElementById(match[3]);

                        // 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
                            return jQuery(elem);
                        }
                        selector = [];
                    }

                    // HANDLE: $(expr, [context])
                    // (which is just equivalent to: $(content).find(expr)
                } else
                    return jQuery(context).find(selector);

                // HANDLE: $(function)
                // Shortcut for document ready
            } else if (jQuery.isFunction(selector))
                return jQuery(document)[jQuery.fn.ready ? "ready" : "load"](selector);

            return this.setArray(jQuery.makeArray(selector));
        },

        // The current version of jQuery being used
        jquery: "1.2.6",

        // The number of elements contained in the matched element set
        size: function() {
            return this.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);

            return this;
        },

        // 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
            return jQuery.inArray(
            // If it receives a jQuery object, the first element is used
            elem && elem.jquery ? elem[0] : elem
        , this);
        },

        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)
                return this[0] && jQuery[type || "attr"](this[0], name);

            else {
                options = {};
                options[name] = value;
            }

            // Check to see if we're setting style values
            return this.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;
            return this.attr(key, value, "curCSS");
        },

        text: function(text) {
            if (typeof text != "object" && text != null)
                return this.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);

            return this;
        },

        wrapInner: function(html) {
            return this.each(function() {
                jQuery(this).contents().wrapAll(html);
            });
        },

        wrap: function(html) {
            return this.each(function() {
                jQuery(this).wrapAll(html);
            });
        },

        append: function() {
            return this.domManip(arguments, true, false, function(elem) {
                if (this.nodeType == 1)
                    this.appendChild(elem);
            });
        },

        prepend: function() {
            return this.domManip(arguments, true, true, function(elem) {
                if (this.nodeType == 1)
                    this.insertBefore(elem, this.firstChild);
            });
        },

        before: function() {
            return this.domManip(arguments, false, false, function(elem) {
                this.parentNode.insertBefore(elem, this);
            });
        },

        after: function() {
            return this.domManip(arguments, false, true, function(elem) {
                this.parentNode.insertBefore(elem, this.nextSibling);
            });
        },

        end: function() {
            return this.prevObject || jQuery([]);
        },

        find: function(selector) {
            var elems = jQuery.map(this, function(elem) {
                return jQuery.find(selector, elem);
            });

            return this.pushStack(/[^+>] [^+>]/.test(selector) || selector.indexOf("..") > -1 ?
            jQuery.unique(elems) :
            elems);
        },

        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
                    return this.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);
                });

            // Return the cloned set
            return ret;
        },

        filter: function(selector) {
            return this.pushStack(
            jQuery.isFunction(selector) &&
            jQuery.grep(this, function(elem, i) {
                return selector.call(elem, i);
            }) ||

            jQuery.multiFilter(selector, this));
        },

        not: function(selector) {
            if (selector.constructor == String)
            // test special case where just one selector is passed in
                if (isSimple.test(selector))
                return this.pushStack(jQuery.multiFilter(selector, this, true));
            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) {
            return this.pushStack(jQuery.unique(jQuery.merge(
            this.get(),
            typeof selector == 'string' ?
                jQuery(selector) :
                jQuery.makeArray(selector)
        )));
        },

        is: function(selector) {
            return !!selector && jQuery.multiFilter(selector, this).length > 0;
        },

        hasClass: function(selector) {
            return this.is("." + selector);
        },

        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)
                            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.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;
            }

            if (value.constructor == Number)
                value += '';

            return this.each(function() {
                if (this.nodeType != 1)
                    return;

                if (value.constructor == Array && /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) {
            return value == undefined ?
            (this[0] ?
                this[0].innerHTML :
                null) :
            this.empty().append(value);
        },

        replaceWith: function(value) {
            return this.after(value).remove();
        },

        eq: function(i) {
            return this.slice(i, i + 1);
        },

        slice: function() {
            return this.pushStack(Array.prototype.slice.apply(this, arguments));
        },

        map: function(callback) {
            return this.pushStack(jQuery.map(this, function(elem, i) {
                return callback.call(elem, i, elem);
            }));
        },

        andSelf: function() {
            return this.add(this.prevObject);
        },

        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);
            });
        },

        domManip: function(args, table, reverse, callback) {
            var clone = this.length > 1, elems;

            return this.each(function() {
                if (!elems) {
                    elems = jQuery.clean(args, this.ownerDocument);

                    if (reverse)
                        elems.reverse();
                }

                var obj = this;

                if (table && jQuery.nodeName(this, "table") && jQuery.nodeName(elems[0], "tr"))
                    obj = this.getElementsByTagName("tbody")[0] || this.appendChild(this.ownerDocument.createElement("tbody"));

                var scripts = jQuery([]);

                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.fn.init.prototype = jQuery.fn;

    function evalScript(i, elem) {
        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() {
        return +new Date;
    }

    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 == 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;
    };

    var expando = "jQuery" + now(), uuid = 0, windowData = {},
    // exclude the following css properties to add px
    exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
    // cache defaultView
    defaultView = document.defaultView || {};

    jQuery.extend({
        noConflict: function(deep) {
            window.$ = _$;

            if (deep)
                window.jQuery = _jQuery;

            return jQuery;
        },

        // See test/unit/core.js for details concerning this function.
        isFunction: function(fn) {
            return !!fn && typeof fn != "string" && !fn.nodeName &&
            fn.constructor != Array && /^[\s[]?function/.test(fn + "");
        },

        // 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 (data) {
                // Inspired by code by Andrea Giammarchi
                // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
                var head = document.getElementsByTagName("head")[0] || document.documentElement,
                script = document.createElement("script");

                script.type = "text/javascript";
                if (jQuery.browser.msie)
                    script.text = data;
                else
                    script.appendChild(document.createTextNode(data));

                // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
                // This arises when a base node is used (#2709).
                head.insertBefore(script, head.firstChild);
                head.removeChild(script);
            }
        },

        nodeName: function(elem, name) {
            return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
        },

        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];
            }
        },

        // args is for internal usage only
        each: function(object, callback, args) {
            var name, i = 0, length = object.length;

            if (args) {
                if (length == undefined) {
                    for (name in object)
                        if (callback.apply(object[name], args) === false)
                        break;
                } else
                    for (; i < length; )
                    if (callback.apply(object[i++], args) === false)
                    break;

                // A special, fast, case for the most common use of each
            } else {
                if (length == undefined) {
                    for (name in object)
                        if (callback.call(object[name], name, object[name]) === false)
                        break;
                } else
                    for (var 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;
        },

        className: {
            // internal only, use addClass("class")
            add: function(elem, classNames) {
                jQuery.each((classNames || "").split(/\s+/), function(i, className) {
                    if (elem.nodeType == 1 && !jQuery.className.has(elem.className, className))
                        elem.className += (elem.className ? " " : "") + className;
                });
            },

            // internal only, use removeClass("class")
            remove: function(elem, classNames) {
                if (elem.nodeType == 1)
                    elem.className = classNames != undefined ?
                    jQuery.grep(elem.className.split(/\s+/), function(className) {
                        return !jQuery.className.has(classNames, className);
                    }).join(" ") :
                    "";
            },

            // internal only, use hasClass("class")
            has: function(elem, className) {
                return jQuery.inArray(className, (elem.className || elem).toString().split(/\s+/)) > -1;
            }
        },

        // 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);
                }

                if (jQuery(elem).is(":visible"))
                    getWH();
                else
                    jQuery.swap(elem, props, getWH);

                return Math.max(0, val);
            }

            return jQuery.curCSS(elem, name, force);
        },

        curCSS: function(elem, name, force) {
            var ret, style = elem.style;

            // A helper method for determining if an element's values are broken
            function color(elem) {
                if (!jQuery.browser.safari)
                    return false;

                // defaultView is cached
                var ret = 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(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 = style.outline;
                style.outline = "0 solid black";
                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 && style && style[name])
                ret = style[name];

            else if (defaultView.getComputedStyle) {

                // Only "float" is needed here
                if (name.match(/float/i))
                    name = "float";

                name = name.replace(/([A-Z])/g, "-$1").toLowerCase();

                var computedStyle = defaultView.getComputedStyle(elem, null);

                if (computedStyle && !color(elem))
                    ret = computedStyle.getPropertyValue(name);

                // If the element isn't reporting its values properly in Safari
                // then some display: none elements are involved
                else {
                    var swap = [], stack = [], a = elem, i = 0;

                    // Locate all of the parent display: none elements
                    for (; 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 (; 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" :
                    (computedStyle && computedStyle.getPropertyValue(name)) || "";

                    // Finally, revert the display styles back
                    for (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";

            } else if (elem.currentStyle) {
                var camelCase = name.replace(/\-(\w)/g, function(all, letter) {
                    return letter.toUpperCase();
                });

                ret = elem.currentStyle[name] || elem.currentStyle[camelCase];

                // From the awesome hack by Dean Edwards
                // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

                // 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 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) {
            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 += '';

                // 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("<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.browser.msie &&
                    [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.browser.msie) {

                        // String was a <table>, *may* have spurious <tbody>
                        var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
                        div.firstChild && div.firstChild.childNodes :

                        // String was a bare <thead> or <tfoot>
                        wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
                            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 (/^\s/.test(elem))
                            div.insertBefore(context.createTextNode(elem.match(/^\s*/)[0]), div.firstChild);

                    }

                    elem = jQuery.makeArray(div.childNodes);
                }

                if (elem.length === 0 && (!jQuery.nodeName(elem, "form") && !jQuery.nodeName(elem, "select")))
                    return;

                if (elem[0] == undefined || jQuery.nodeName(elem, "form") || elem.options)
                    ret.push(elem);

                else
                    ret = jQuery.merge(ret, elem);

            });

            return ret;
        },

        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 notxml = !jQuery.isXMLDoc(elem),
            // Whether we are setting (or getting)
            set = value !== undefined,
            msie = jQuery.browser.msie;

            // 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" && jQuery.browser.safari)
                    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;

                    return elem[name];
                }

                if (msie && notxml && name == "style")
                    return jQuery.attr(elem.style, "cssText", value);

                if (set)
                // convert the value to a string (all browsers do this but IE) see #1070
                    elem.setAttribute(name, "" + value);

                var attr = msie && notxml && special
                // Some attributes require a special call on IE
                    ? elem.getAttribute(name, 2)
                    : elem.getAttribute(name);

                // Non-existent attributes return null, we normalize to undefined
                return attr === null ? undefined : attr;
            }

            // elem is actually elem.style ... set the style

            // IE uses filters for opacity
            if (msie && name == "opacity") {
                if (set) {
                    // 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\([^)]*\)/, "") +
                    (parseInt(value) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
                }

                return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
                (parseFloat(elem.filter.match(/opacity=([^)]*)/)[1]) / 100) + '' :
                "";
            }

            name = name.replace(/-([a-z])/ig, function(all, letter) {
                return letter.toUpperCase();
            });

            if (set)
                elem[name] = value;

            return elem[name];
        },

        trim: function(text) {
            return (text || "").replace(/^\s+|\s+$/g, "");
        },

        makeArray: function(array) {
            var ret = [];

            if (array != null) {
                var i = array.length;
                //the window, strings and functions also have 'length'
                if (i == null || array.split || array.setInterval || array.call)
                    ret[0] = array;
                else
                    while (i)
                    ret[--i] = array[i];
            }

            return ret;
        },

        inArray: function(elem, array) {
            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) {
            // 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.browser.msie) {
                while (elem = second[i++])
                    if (elem.nodeType != 8)
                    first[pos++] = elem;

            } else
                while (elem = second[i++])
                first[pos++] = elem;

            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))
                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)
                    ret[ret.length] = value;
            }

            return ret.concat.apply([], 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",

        props: {
            "for": "htmlFor",
            "class": "className",
            "float": styleFloat,
            cssFloat: styleFloat,
            styleFloat: styleFloat,
            readonly: "readOnly",
            maxlength: "maxLength",
            cellspacing: "cellSpacing"
        }
    });

    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) {
            var ret = jQuery.map(this, fn);

            if (selector && typeof selector == "string")
                ret = jQuery.multiFilter(selector, ret);

            return this.pushStack(jQuery.unique(ret));
        };
    });

    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.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) {
            jQuery.className[jQuery.className.has(this, classNames) ? "remove" : "add"](this, classNames);
        },

        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() {
            return this.each(fn, arguments);
        };
    });

    jQuery.each(["Height", "Width"], function(i, name) {
        var type = name.toLowerCase();

        jQuery.fn[type] = function(size) {
            // Get window width or height
            return this[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");
        };
    });

    // 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 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 + "*)");

    jQuery.extend({
        expr: {
            "": function(a, i, m) { return m[2] == "*" || jQuery.nodeName(a, m[2]); },
            "#": function(a, i, m) { return a.getAttribute("id") == m[2]; },
            ":": {
                // Position Checks
                lt: function(a, i, m) { return i < m[3] - 0; },
                gt: function(a, i, m) { return i > m[3] - 0; },
                nth: function(a, i, m) { return m[3] - 0 == i; },
                eq: function(a, i, m) { return m[3] - 0 == i; },
                first: function(a, i) { return i == 0; },
                last: function(a, i, m, r) { return i == r.length - 1; },
                even: function(a, i) { return i % 2 == 0; },
                odd: function(a, i) { return i % 2; },

                // Child Checks
                "first-child": function(a) { return a.parentNode.getElementsByTagName("*")[0] == a; },
                "last-child": function(a) { return jQuery.nth(a.parentNode.lastChild, 1, "previousSibling") == a; },
                "only-child": function(a) { return !jQuery.nth(a.parentNode.lastChild, 2, "previousSibling"); },

                // Parent Checks
                parent: function(a) { return a.firstChild; },
                empty: function(a) { return !a.firstChild; },

                // Text Check
                contains: function(a, i, m) { return (a.textContent || a.innerText || jQuery(a).text() || "").indexOf(m[3]) >= 0; },

                // Visibility
                visible: function(a) { return "hidden" != a.type && jQuery.css(a, "display") != "none" && jQuery.css(a, "visibility") != "hidden"; },
                hidden: function(a) { return "hidden" == a.type || jQuery.css(a, "display") == "none" || jQuery.css(a, "visibility") == "hidden"; },

                // Form attributes
                enabled: function(a) { return !a.disabled; },
                disabled: function(a) { return a.disabled; },
                checked: function(a) { return a.checked; },
                selected: function(a) { return a.selected || jQuery.attr(a, "selected"); },

                // Form elements
                text: function(a) { return "text" == a.type; },
                radio: function(a) { return "radio" == a.type; },
                checkbox: function(a) { return "checkbox" == a.type; },
                file: function(a) { return "file" == a.type; },
                password: function(a) { return "password" == a.type; },
                submit: function(a) { return "submit" == a.type; },
                image: function(a) { return "image" == a.type; },
                reset: function(a) { return "reset" == a.type; },
                button: function(a) { return "button" == a.type || jQuery.nodeName(a, "button"); },
                input: function(a) { return /input|select|textarea|button/i.test(a.nodeName); },

                // :has()
                has: function(a, i, m) { return jQuery.find(m[3], a).length; },

                // :header
                header: function(a) { return /h\d/i.test(a.nodeName); },

                // :animated
                animated: function(a) { return jQuery.grep(jQuery.timers, function(fn) { return a == fn.elem; }).length; }
            }
        },

        // The regular expressions that power the parsing engine
        parse: [
        // Match: [@value='test'], [@foo]
        /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,

        // Match: :contains('foo')
        /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,

        // Match: :even, :last-child, #id, .class
        new RegExp("^([:.#]*)(" + chars + "+)")
    ],

        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
                re = quickChild,

                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
                else if (m[1] == ".")
                    r = jQuery.classFilter(r, m[2], not);

                else if (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
                } else if (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;
                        } else if ((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]];

                    if (typeof fn == "string")
                        fn = eval("false||function(a,i){return " + fn + ";}");

                    // 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 = [],
            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 && 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)
                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 = this.proxy(fn, function() {
                    // Pass arguments and context to original handler
                    return fn.apply(this, arguments);
                });

                // Store data in unique handler
                handler.data = data;
            }

            // 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() {
                // 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 jQuery.event.handle.apply(arguments.callee.elem, arguments);
            });
            // 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 separated 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);
                        else if (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);
                                    else if (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({
                        type: type,
                        target: elem,
                        preventDefault: function() { },
                        stopPropagation: function() { },
                        timeStamp: now()
                    });
                    data[0][expando] = true; // no need to fix fake event
                }

                // Enforce the right trigger type
                data[0].type = type;
                if (exclusive)
                    data[0].exclusive = true;

                // Trigger the event, it is assumed that "handle" is a function
                var handle = jQuery.data(elem, "handle");
                if (handle)
                    val = handle.apply(elem, data);

                // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
                if ((!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && 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, ret, namespace, all, handlers;

            event = arguments[0] = jQuery.event.fix(event || window.event);

            // Namespaced event handlers
            namespace = event.type.split(".");
            event.type = namespace[0];
            namespace = namespace[1];
            // Cache this now, all = true means, any handler
            all = !namespace && !event.exclusive;

            handlers = (jQuery.data(this, "events") || {})[event.type];

            for (var j in handlers) {
                var handler = handlers[j];

                // Filter the functions by class
                if (all || handler.type == namespace) {
                    // Pass in a reference to the handler function itself
                    // So that we can later remove it
                    event.handler = handler;
                    event.data = handler.data;

                    ret = handler.apply(this, arguments);

                    if (val !== false)
                        val = ret;

                    if (ret === false) {
                        event.preventDefault();
                        event.stopPropagation();
                    }
                }
            }

            return val;
        },

        fix: function(event) {
            if (event[expando] == true)
                return event;

            // store a copy of the original event object
            // and "clone" to set read-only properties
            var originalEvent = event;
            event = { originalEvent: originalEvent };
            var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" ");
            for (var i = props.length; i; i--)
                event[props[i]] = originalEvent[props[i]];

            // Mark it as fixed
            event[expando] = true;

            // 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 timeStamp
            event.timeStamp = event.timeStamp || now();

            // 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 = event.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;
        },

        proxy: function(fn, proxy) {
            // Set the guid of unique handler to the same of original handler, so it can be removed
            proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
            // So proxy can be declared as an argument
            return proxy;
        },

        special: {
            ready: {
                setup: function() {
                    // Make sure the ready event is setup
                    bindReady();
                    return;
                },

                teardown: function() { return; }
            },

            mouseenter: {
                setup: function() {
                    if (jQuery.browser.msie) return false;
                    jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
                    return true;
                },

                teardown: function() {
                    if (jQuery.browser.msie) return false;
                    jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
                    return true;
                },

                handler: function(event) {
                    // If we actually just moused on to a sub-element, ignore it
                    if (withinElement(event, this)) return true;
                    // Execute the right handlers by setting the event type to mouseenter
                    event.type = "mouseenter";
                    return jQuery.event.handle.apply(this, arguments);
                }
            },

            mouseleave: {
                setup: function() {
                    if (jQuery.browser.msie) return false;
                    jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
                    return true;
                },

                teardown: function() {
                    if (jQuery.browser.msie) return false;
                    jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
                    return true;
                },

                handler: function(event) {
                    // If we actually just moused on to a sub-element, ignore it
                    if (withinElement(event, this)) return true;
                    // Execute the right handlers by setting the event type to mouseleave
                    event.type = "mouseleave";
                    return jQuery.event.handle.apply(this, arguments);
                }
            }
        }
    };

    jQuery.fn.extend({
        bind: function(type, data, fn) {
            return type == "unload" ? this.one(type, data, fn) : this.each(function() {
                jQuery.event.add(this, type, fn || data, fn && data);
            });
        },

        one: function(type, data, fn) {
            var one = jQuery.event.proxy(fn || data, function(event) {
                jQuery(this).unbind(event, one);
                return (fn || data).apply(this, arguments);
            });
            return this.each(function() {
                jQuery.event.add(this, type, one, fn && data);
            });
        },

        unbind: function(type, fn) {
            return this.each(function() {
                jQuery.event.remove(this, type, fn);
            });
        },

        trigger: function(type, data, fn) {
            return this.each(function() {
                jQuery.event.trigger(type, data, this, true, fn);
            });
        },

        triggerHandler: function(type, data, fn) {
            return this[0] && jQuery.event.trigger(type, data, this[0], false, fn);
        },

        toggle: function(fn) {
            // Save reference to arguments for access in closure
            var args = arguments, i = 1;

            // link all the functions, so any of them can unbind this click handler
            while (i < args.length)
                jQuery.event.proxy(fn, args[i++]);

            return this.click(jQuery.event.proxy(fn, function(event) {
                // Figure out which function to execute
                this.lastToggle = (this.lastToggle || 0) % i;

                // Make sure that clicks stop
                event.preventDefault();

                // and execute the function
                return args[this.lastToggle++].apply(this, arguments) || false;
            }));
        },

        hover: function(fnOver, fnOut) {
            return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
        },

        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); });

            return this;
        }
    });

    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.call(document);
                    });

                    // Reset the list of functions
                    jQuery.readyList = null;
                }

                // Trigger any bound ready events
                jQuery(document).triggerHandler("ready");
            }
        }
    });

    var readyBound = false;

    function bindReady() {
        if (readyBound) return;
        readyBound = true;

        // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
        if (document.addEventListener && !jQuery.browser.opera)
        // Use the handy event callback
            document.addEventListener("DOMContentLoaded", jQuery.ready, false);

        // If IE is used and is not in a frame
        // Continually check to see if the document is ready
        if (jQuery.browser.msie && window == top) (function() {
            if (jQuery.isReady) return;
            try {
                // If IE is used, use the trick by Diego Perini
                // http://javascript.nwbox.com/IEContentLoaded/
                document.documentElement.doScroll("left");
            } catch (error) {
                setTimeout(arguments.callee, 0);
                return;
            }
            // and execute any waiting functions
            jQuery.ready();
        })();

        if (jQuery.browser.opera)
            document.addEventListener("DOMContentLoaded", function() {
                if (jQuery.isReady) return;
                for (var i = 0; i < document.styleSheets.length; i++)
                    if (document.styleSheets[i].disabled) {
                    setTimeout(arguments.callee, 0);
                    return;
                }
                // and execute any waiting functions
                jQuery.ready();
            }, false);

        if (jQuery.browser.safari) {
            var numStyles;
            (function() {
                if (jQuery.isReady) return;
                if (document.readyState != "loaded" && document.readyState != "complete") {
                    setTimeout(arguments.callee, 0);
                    return;
                }
                if (numStyles === undefined)
                    numStyles = jQuery("style, link[rel=stylesheet]").length;
                if (document.styleSheets.length != numStyles) {
                    setTimeout(arguments.callee, 0);
                    return;
                }
                // and execute any waiting functions
                jQuery.ready();
            })();
        }

        // A fallback to window.onload, that will always work
        jQuery.event.add(window, "load", jQuery.ready);
    }

    jQuery.each(("blur,focus,load,resize,scroll,unload,click,dblclick," +
    "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
    "submit,keydown,keypress,keyup,error").split(","), function(i, name) {

        // Handle event binding
        jQuery.fn[name] = function(fn) {
            return fn ? this.bind(name, fn) : this.trigger(name);
        };
    });

    // Checks if an event happened on an element within another element
    // Used in jQuery.event.special.mouseenter and mouseleave handlers
    var withinElement = function(event, elem) {
        // Check if mouse(over|out) are still within the same parent element
        var parent = event.relatedTarget;
        // Traverse up the tree
        while (parent && parent != elem) try { parent = parent.parentNode; } catch (error) { parent = elem; }
        // Return true if we actually just moused on to a sub-element
        return parent == elem;
    };

    // Prevent memory leaks in IE
    // And prevent errors on refresh with events like mouseover in other browsers
    // Window isn't included so as not to unbind existing unload events
    jQuery(window).bind("unload", function() {
        jQuery("*").add(document).unbind();
    });
    jQuery.fn.extend({
        // Keep a copy of the old load
        _load: jQuery.fn.load,

        load: function(url, params, callback) {
            if (typeof url != 'string')
                return this._load(url);

            var off = url.indexOf(" ");
            if (off >= 0) {
                var selector = url.slice(off, url.length);
                url = url.slice(0, off);
            }

            callback = callback || function() { };

            // Default to a GET request
            var type = "GET";

            // If the second parameter was provided
            if (params)
            // If it's a function
                if (jQuery.isFunction(params)) {
                // We assume that it's the callback
                callback = params;
                params = null;

                // Otherwise, build a param string
            } else {
                params = jQuery.param(params);
                type = "POST";
            }

            var self = this;

            // Request the remote document
            jQuery.ajax({
                url: url,
                type: type,
                dataType: "html",
                data: params,
                complete: function(res, status) {
                    // If successful, inject the HTML into all the matched elements
                    if (status == "success" || status == "notmodified")
                    // See if a selector was specified
                        self.html(selector ?
                    // Create a dummy div to hold the results
                        jQuery("<div/>")
                    // inject the contents of the document in, removing the scripts
                    // to avoid any 'Permission Denied' errors in IE
                            .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))

                    // Locate the specified elements
                            .find(selector) :

                    // If not, just inject the full result
                        res.responseText);

                    self.each(callback, [res.responseText, status, res]);
                }
            });
            return this;
        },

        serialize: function() {
            return jQuery.param(this.serializeArray());
        },
        serializeArray: function() {
            return this.map(function() {
                return jQuery.nodeName(this, "form") ?
                jQuery.makeArray(this.elements) : this;
            })
        .filter(function() {
            return this.name && !this.disabled &&
                (this.checked || /select|textarea/i.test(this.nodeName) ||
                    /text|hidden|password/i.test(this.type));
        })
        .map(function(i, elem) {
            var val = jQuery(this).val();
            return val == null ? null :
                val.constructor == Array ?
                    jQuery.map(val, function(val, i) {
                        return { name: elem.name, value: val };
                    }) :
                    { name: elem.name, value: val };
        }).get();
        }
    });

    // Attach a bunch of functions for handling common AJAX events
    jQuery.each("ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i, o) {
        jQuery.fn[o] = function(f) {
            return this.bind(o, f);
        };
    });

    var jsc = now();

    jQuery.extend({
        get: function(url, data, callback, type) {
            // shift arguments if data argument was ommited
            if (jQuery.isFunction(data)) {
                callback = data;
                data = null;
            }

            return jQuery.ajax({
                type: "GET",
                url: url,
                data: data,
                success: callback,
                dataType: type
            });
        },

        getScript: function(url, callback) {
            return jQuery.get(url, null, callback, "script");
        },

        getJSON: function(url, data, callback) {
            return jQuery.get(url, data, callback, "json");
        },

        post: function(url, data, callback, type) {
            if (jQuery.isFunction(data)) {
                callback = data;
                data = {};
            }

            return jQuery.ajax({
                type: "POST",
                url: url,
                data: data,
                success: callback,
                dataType: type
            });
        },

        ajaxSetup: function(settings) {
            jQuery.extend(jQuery.ajaxSettings, settings);
        },

        ajaxSettings: {
            url: location.href,
            global: true,
            type: "GET",
            timeout: 0,
            contentType: "application/x-www-form-urlencoded",
            processData: true,
            async: true,
            data: null,
            username: null,
            password: null,
            accepts: {
                xml: "application/xml, text/xml",
                html: "text/html",
                script: "text/javascript, application/javascript",
                json: "application/json, text/javascript",
                text: "text/plain",
                _default: "*/*"
            }
        },

        // Last-Modified header cache for next request
        lastModified: {},

        ajax: function(s) {
            // Extend the settings, but re-extend 's' so that it can be
            // checked again later (in the test suite, specifically)
            s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));

            var jsonp, jsre = /=\?(&|$)/g, status, data,
            type = s.type.toUpperCase();

            // convert data if not already a string
            if (s.data && s.processData && typeof s.data != "string")
                s.data = jQuery.param(s.data);

            // Handle JSONP Parameter Callbacks
            if (s.dataType == "jsonp") {
                if (type == "GET") {
                    if (!s.url.match(jsre))
                        s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
                } else if (!s.data || !s.data.match(jsre))
                    s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
                s.dataType = "json";
            }

            // Build temporary JSONP function
            if (s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre))) {
                jsonp = "jsonp" + jsc++;

                // Replace the =? sequence both in the query string and the data
                if (s.data)
                    s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
                s.url = s.url.replace(jsre, "=" + jsonp + "$1");

                // We need to make sure
                // that a JSONP style response is executed properly
                s.dataType = "script";

                // Handle JSONP-style loading
                window[jsonp] = function(tmp) {
                    data = tmp;
                    success();
                    complete();
                    // Garbage collect
                    window[jsonp] = undefined;
                    try { delete window[jsonp]; } catch (e) { }
                    if (head)
                        head.removeChild(script);
                };
            }

            if (s.dataType == "script" && s.cache == null)
                s.cache = false;

            if (s.cache === false && type == "GET") {
                var ts = now();
                // try replacing _= if it is there
                var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
                // if nothing was replaced, add timestamp to the end
                s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
            }

            // If data is available, append data to url for get requests
            if (s.data && type == "GET") {
                s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;

                // IE likes to send both get and post data, prevent this
                s.data = null;
            }

            // Watch for a new set of requests
            if (s.global && !jQuery.active++)
                jQuery.event.trigger("ajaxStart");

            // Matches an absolute URL, and saves the domain
            var remote = /^(?:\w+:)?\/\/([^\/?#]+)/;

            // If we're requesting a remote document
            // and trying to load JSON or Script with a GET
            if (s.dataType == "script" && type == "GET"
                && remote.test(s.url) && remote.exec(s.url)[1] != location.host) {
                var head = document.getElementsByTagName("head")[0];
                var script = document.createElement("script");
                script.src = s.url;
                if (s.scriptCharset)
                    script.charset = s.scriptCharset;

                // Handle Script loading
                if (!jsonp) {
                    var done = false;

                    // Attach handlers for all browsers
                    script.onload = script.onreadystatechange = function() {
                        if (!done && (!this.readyState ||
                            this.readyState == "loaded" || this.readyState == "complete")) {
                            done = true;
                            success();
                            complete();
                            head.removeChild(script);
                        }
                    };
                }

                head.appendChild(script);

                // We handle everything using the script element injection
                return undefined;
            }

            var requestDone = false;

            // Create the request object; Microsoft failed to properly
            // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
            var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();

            // Open the socket
            // Passing null username, generates a login popup on Opera (#2865)
            if (s.username)
                xhr.open(type, s.url, s.async, s.username, s.password);
            else
                xhr.open(type, s.url, s.async);

            // Need an extra try/catch for cross domain requests in Firefox 3
            try {
                // Set the correct header, if data is being sent
                if (s.data)
                    xhr.setRequestHeader("Content-Type", s.contentType);

                // Set the If-Modified-Since header, if ifModified mode.
                if (s.ifModified)
                    xhr.setRequestHeader("If-Modified-Since",
                    jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT");

                // Set header so the called script knows that it's an XMLHttpRequest
                xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");

                // Set the Accepts header for the server, depending on the dataType
                xhr.setRequestHeader("Accept", s.dataType && s.accepts[s.dataType] ?
                s.accepts[s.dataType] + ", */*" :
                s.accepts._default);
            } catch (e) { }

            // Allow custom headers/mimetypes
            if (s.beforeSend && s.beforeSend(xhr, s) === false) {
                // cleanup active request counter
                s.global && jQuery.active--;
                // close opended socket
                xhr.abort();
                return false;
            }

            if (s.global)
                jQuery.event.trigger("ajaxSend", [xhr, s]);

            // Wait for a response to come back
            var onreadystatechange = function(isTimeout) {
                // The transfer is complete and the data is available, or the request timed out
                if (!requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout")) {
                    requestDone = true;

                    // clear poll interval
                    if (ival) {
                        clearInterval(ival);
                        ival = null;
                    }

                    status = isTimeout == "timeout" && "timeout" ||
                    !jQuery.httpSuccess(xhr) && "error" ||
                    s.ifModified && jQuery.httpNotModified(xhr, s.url) && "notmodified" ||
                    "success";

                    if (status == "success") {
                        // Watch for, and catch, XML document parse errors
                        try {
                            // process the data (runs the xml through httpData regardless of callback)
                            data = jQuery.httpData(xhr, s.dataType, s.dataFilter);
                        } catch (e) {
                            status = "parsererror";
                        }
                    }

                    // Make sure that the request was successful or notmodified
                    if (status == "success") {
                        // Cache Last-Modified header, if ifModified mode.
                        var modRes;
                        try {
                            modRes = xhr.getResponseHeader("Last-Modified");
                        } catch (e) { } // swallow exception thrown by FF if header is not available

                        if (s.ifModified && modRes)
                            jQuery.lastModified[s.url] = modRes;

                        // JSONP handles its own success callback
                        if (!jsonp)
                            success();
                    } else
                        jQuery.handleError(s, xhr, status);

                    // Fire the complete handlers
                    complete();

                    // Stop memory leaks
                    if (s.async)
                        xhr = null;
                }
            };

            if (s.async) {
                // don't attach the handler to the request, just poll it instead
                var ival = setInterval(onreadystatechange, 13);

                // Timeout checker
                if (s.timeout > 0)
                    setTimeout(function() {
                        // Check to see if the request is still happening
                        if (xhr) {
                            // Cancel the request
                            xhr.abort();

                            if (!requestDone)
                                onreadystatechange("timeout");
                        }
                    }, s.timeout);
            }

            // Send the data
            try {
                xhr.send(s.data);
            } catch (e) {
                jQuery.handleError(s, xhr, null, e);
            }

            // firefox 1.5 doesn't fire statechange for sync requests
            if (!s.async)
                onreadystatechange();

            function success() {
                // If a local callback was specified, fire it and pass it the data
                if (s.success)
                    s.success(data, status);

                // Fire the global callback
                if (s.global)
                    jQuery.event.trigger("ajaxSuccess", [xhr, s]);
            }

            function complete() {
                // Process result
                if (s.complete)
                    s.complete(xhr, status);

                // The request was completed
                if (s.global)
                    jQuery.event.trigger("ajaxComplete", [xhr, s]);

                // Handle the global AJAX counter
                if (s.global && ! --jQuery.active)
                    jQuery.event.trigger("ajaxStop");
            }

            // return XMLHttpRequest to allow aborting the request etc.
            return xhr;
        },

        handleError: function(s, xhr, status, e) {
            // If a local callback was specified, fire it
            if (s.error) s.error(xhr, status, e);

            // Fire the global callback
            if (s.global)
                jQuery.event.trigger("ajaxError", [xhr, s, e]);
        },

        // Counter for holding the number of active queries
        active: 0,

        // Determines if an XMLHttpRequest was successful or not
        httpSuccess: function(xhr) {
            try {
                // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
                return !xhr.status && location.protocol == "file:" ||
                (xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || xhr.status == 1223 ||
                jQuery.browser.safari && xhr.status == undefined;
            } catch (e) { }
            return false;
        },

        // Determines if an XMLHttpRequest returns NotModified
        httpNotModified: function(xhr, url) {
            try {
                var xhrRes = xhr.getResponseHeader("Last-Modified");

                // Firefox always returns 200. check Last-Modified date
                return xhr.status == 304 || xhrRes == jQuery.lastModified[url] ||
                jQuery.browser.safari && xhr.status == undefined;
            } catch (e) { }
            return false;
        },

        httpData: function(xhr, type, filter) {
            var ct = xhr.getResponseHeader("content-type"),
            xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
            data = xml ? xhr.responseXML : xhr.responseText;

            if (xml && data.documentElement.tagName == "parsererror")
                throw "parsererror";

            // Allow a pre-filtering function to sanitize the response
            if (filter)
                data = filter(data, type);

            // If the type is "script", eval it in global context
            if (type == "script")
                jQuery.globalEval(data);

            // Get the JavaScript object, if JSON is used.
            if (type == "json")
                data = eval("(" + data + ")");

            return data;
        },

        // Serialize an array of form elements or a set of
        // key/values into a query string
        param: function(a) {
            var s = [];

            // If an array was passed in, assume that it is an array
            // of form elements
            if (a.constructor == Array || a.jquery)
            // Serialize the form elements
                jQuery.each(a, function() {
                    s.push(encodeURIComponent(this.name) + "=" + encodeURIComponent(this.value));
                });

            // Otherwise, assume that it's an object of key/value pairs
            else
            // Serialize the key/values
                for (var j in a)
            // If the value is an array then the key names need to be repeated
                if (a[j] && a[j].constructor == Array)
                jQuery.each(a[j], function() {
                    s.push(encodeURIComponent(j) + "=" + encodeURIComponent(this));
                });
            else
                s.push(encodeURIComponent(j) + "=" + encodeURIComponent(jQuery.isFunction(a[j]) ? a[j]() : a[j]));

            // Return the resulting serialization
            return s.join("&").replace(/%20/g, "+");
        }

    });
    jQuery.fn.extend({
        show: function(speed, callback) {
            return speed ?
            this.animate({
                height: "show", width: "show", opacity: "show"
            }, speed, callback) :

            this.filter(":hidden").each(function() {
                this.style.display = this.oldblock || "";
                if (jQuery.css(this, "display") == "none") {
                    var elem = jQuery("<" + this.tagName + " />").appendTo("body");
                    this.style.display = elem.css("display");
                    // handle an edge condition where css is - div { display:none; } or similar
                    if (this.style.display == "none")
                        this.style.display = "block";
                    elem.remove();
                }
            }).end();
        },

        hide: function(speed, callback) {
            return speed ?
            this.animate({
                height: "hide", width: "hide", opacity: "hide"
            }, speed, callback) :

            this.filter(":visible").each(function() {
                this.oldblock = this.oldblock || jQuery.css(this, "display");
                this.style.display = "none";
            }).end();
        },

        // Save the old toggle function
        _toggle: jQuery.fn.toggle,

        toggle: function(fn, fn2) {
            return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
            this._toggle.apply(this, arguments) :
            fn ?
                this.animate({
                    height: "toggle", width: "toggle", opacity: "toggle"
                }, fn, fn2) :
                this.each(function() {
                    jQuery(this)[jQuery(this).is(":hidden") ? "show" : "hide"]();
                });
        },

        slideDown: function(speed, callback) {
            return this.animate({ height: "show" }, speed, callback);
        },

        slideUp: function(speed, callback) {
            return this.animate({ height: "hide" }, speed, callback);
        },

        slideToggle: function(speed, callback) {
            return this.animate({ height: "toggle" }, speed, callback);
        },

        fadeIn: function(speed, callback) {
            return this.animate({ opacity: "show" }, speed, callback);
        },

        fadeOut: function(speed, callback) {
            return this.animate({ opacity: "hide" }, speed, callback);
        },

        fadeTo: function(speed, to, callback) {
            return this.animate({ opacity: to }, speed, callback);
        },

        animate: function(prop, speed, easing, callback) {
            var optall = jQuery.speed(speed, easing, callback);

            return this[optall.queue === false ? "each" : "queue"](function() {
                if (this.nodeType != 1)
                    return false;

                var opt = jQuery.extend({}, optall), p,
                hidden = jQuery(this).is(":hidden"), self = this;

                for (p in prop) {
                    if (prop[p] == "hide" && hidden || prop[p] == "show" && !hidden)
                        return opt.complete.call(this);

                    if (p == "height" || p == "width") {
                        // Store display property
                        opt.display = jQuery.css(this, "display");

                        // Make sure that nothing sneaks out
                        opt.overflow = this.style.overflow;
                    }
                }

                if (opt.overflow != null)
                    this.style.overflow = "hidden";

                opt.curAnim = jQuery.extend({}, prop);

                jQuery.each(prop, function(name, val) {
                    var e = new jQuery.fx(self, opt, name);

                    if (/toggle|show|hide/.test(val))
                        e[val == "toggle" ? hidden ? "show" : "hide" : val](prop);
                    else {
                        var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
                        start = e.cur(true) || 0;

                        if (parts) {
                            var end = parseFloat(parts[2]),
                            unit = parts[3] || "px";

                            // We need to compute starting value
                            if (unit != "px") {
                                self.style[name] = (end || 1) + unit;
                                start = ((end || 1) / e.cur(true)) * start;
                                self.style[name] = start + unit;
                            }

                            // If a +=/-= token was provided, we're doing a relative animation
                            if (parts[1])
                                end = ((parts[1] == "-=" ? -1 : 1) * end) + start;

                            e.custom(start, end, unit);
                        } else
                            e.custom(start, val, "");
                    }
                });

                // For JS strict compliance
                return true;
            });
        },

        queue: function(type, fn) {
            if (jQuery.isFunction(type) || (type && type.constructor == Array)) {
                fn = type;
                type = "fx";
            }

            if (!type || (typeof type == "string" && !fn))
                return queue(this[0], type);

            return this.each(function() {
                if (fn.constructor == Array)
                    queue(this, type, fn);
                else {
                    queue(this, type).push(fn);

                    if (queue(this, type).length == 1)
                        fn.call(this);
                }
            });
        },

        stop: function(clearQueue, gotoEnd) {
            var timers = jQuery.timers;

            if (clearQueue)
                this.queue([]);

            this.each(function() {
                // go in reverse order so anything added to the queue during the loop is ignored
                for (var i = timers.length - 1; i >= 0; i--)
                    if (timers[i].elem == this) {
                    if (gotoEnd)
                    // force the next step to be the last
                        timers[i](true);
                    timers.splice(i, 1);
                }
            });

            // start the next in the queue if the last step wasn't forced
            if (!gotoEnd)
                this.dequeue();

            return this;
        }

    });

    var queue = function(elem, type, array) {
        if (elem) {

            type = type || "fx";

            var q = jQuery.data(elem, type + "queue");

            if (!q || array)
                q = jQuery.data(elem, type + "queue", jQuery.makeArray(array));

        }
        return q;
    };

    jQuery.fn.dequeue = function(type) {
        type = type || "fx";

        return this.each(function() {
            var q = queue(this, type);

            q.shift();

            if (q.length)
                q[0].call(this);
        });
    };

    jQuery.extend({

        speed: function(speed, easing, fn) {
            var opt = speed && speed.constructor == Object ? speed : {
                complete: fn || !fn && easing ||
                jQuery.isFunction(speed) && speed,
                duration: speed,
                easing: fn && easing || easing && easing.constructor != Function && easing
            };

            opt.duration = (opt.duration && opt.duration.constructor == Number ?
            opt.duration :
            jQuery.fx.speeds[opt.duration]) || jQuery.fx.speeds.def;

            // Queueing
            opt.old = opt.complete;
            opt.complete = function() {
                if (opt.queue !== false)
                    jQuery(this).dequeue();
                if (jQuery.isFunction(opt.old))
                    opt.old.call(this);
            };

            return opt;
        },

        easing: {
            linear: function(p, n, firstNum, diff) {
                return firstNum + diff * p;
            },
            swing: function(p, n, firstNum, diff) {
                return ((-Math.cos(p * Math.PI) / 2) + 0.5) * diff + firstNum;
            }
        },

        timers: [],
        timerId: null,

        fx: function(elem, options, prop) {
            this.options = options;
            this.elem = elem;
            this.prop = prop;

            if (!options.orig)
                options.orig = {};
        }

    });

    jQuery.fx.prototype = {

        // Simple function for setting a style value
        update: function() {
            if (this.options.step)
                this.options.step.call(this.elem, this.now, this);

            (jQuery.fx.step[this.prop] || jQuery.fx.step._default)(this);

            // Set display property to block for height/width animations
            if (this.prop == "height" || this.prop == "width")
                this.elem.style.display = "block";
        },

        // Get the current size
        cur: function(force) {
            if (this.elem[this.prop] != null && this.elem.style[this.prop] == null)
                return this.elem[this.prop];

            var r = parseFloat(jQuery.css(this.elem, this.prop, force));
            return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
        },

        // Start an animation from one number to another
        custom: function(from, to, unit) {
            this.startTime = now();
            this.start = from;
            this.end = to;
            this.unit = unit || this.unit || "px";
            this.now = this.start;
            this.pos = this.state = 0;
            this.update();

            var self = this;
            function t(gotoEnd) {
                return self.step(gotoEnd);
            }

            t.elem = this.elem;

            jQuery.timers.push(t);

            if (jQuery.timerId == null) {
                jQuery.timerId = setInterval(function() {
                    var timers = jQuery.timers;

                    for (var i = 0; i < timers.length; i++)
                        if (!timers[i]())
                        timers.splice(i--, 1);

                    if (!timers.length) {
                        clearInterval(jQuery.timerId);
                        jQuery.timerId = null;
                    }
                }, 13);
            }
        },

        // Simple 'show' function
        show: function() {
            // Remember where we started, so that we can go back to it later
            this.options.orig[this.prop] = jQuery.attr(this.elem.style, this.prop);
            this.options.show = true;

            // Begin the animation
            this.custom(0, this.cur());

            // Make sure that we start at a small width/height to avoid any
            // flash of content
            if (this.prop == "width" || this.prop == "height")
                this.elem.style[this.prop] = "1px";

            // Start by showing the element
            jQuery(this.elem).show();
        },

        // Simple 'hide' function
        hide: function() {
            // Remember where we started, so that we can go back to it later
            this.options.orig[this.prop] = jQuery.attr(this.elem.style, this.prop);
            this.options.hide = true;

            // Begin the animation
            this.custom(this.cur(), 0);
        },

        // Each step of an animation
        step: function(gotoEnd) {
            var t = now();

            if (gotoEnd || t > this.options.duration + this.startTime) {
                this.now = this.end;
                this.pos = this.state = 1;
                this.update();

                this.options.curAnim[this.prop] = true;

                var done = true;
                for (var i in this.options.curAnim)
                    if (this.options.curAnim[i] !== true)
                    done = false;

                if (done) {
                    if (this.options.display != null) {
                        // Reset the overflow
                        this.elem.style.overflow = this.options.overflow;

                        // Reset the display
                        this.elem.style.display = this.options.display;
                        if (jQuery.css(this.elem, "display") == "none")
                            this.elem.style.display = "block";
                    }

                    // Hide the element if the "hide" operation was done
                    if (this.options.hide)
                        this.elem.style.display = "none";

                    // Reset the properties, if the item has been hidden or shown
                    if (this.options.hide || this.options.show)
                        for (var p in this.options.curAnim)
                        jQuery.attr(this.elem.style, p, this.options.orig[p]);
                }

                if (done)
                // Execute the complete function
                    this.options.complete.call(this.elem);

                return false;
            } else {
                var n = t - this.startTime;
                this.state = n / this.options.duration;

                // Perform the easing function, defaults to swing
                this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
                this.now = this.start + ((this.end - this.start) * this.pos);

                // Perform the next step of the animation
                this.update();
            }

            return true;
        }

    };

    jQuery.extend(jQuery.fx, {
        speeds: {
            slow: 600,
            fast: 200,
            // Default speed
            def: 400
        },
        step: {
            scrollLeft: function(fx) {
                fx.elem.scrollLeft = fx.now;
            },

            scrollTop: function(fx) {
                fx.elem.scrollTop = fx.now;
            },

            opacity: function(fx) {
                jQuery.attr(fx.elem.style, "opacity", fx.now);
            },

            _default: function(fx) {
                fx.elem.style[fx.prop] = fx.now + fx.unit;
            }
        }
    });
    // The Offset Method
    // Originally By Brandon Aaron, part of the Dimension Plugin
    // http://jquery.com/plugins/project/dimensions
    jQuery.fn.offset = function() {
        var left = 0, top = 0, elem = this[0], results;

        if (elem) with (jQuery.browser) {
            var parent = elem.parentNode,
            offsetChild = elem,
            offsetParent = elem.offsetParent,
            doc = elem.ownerDocument,
            safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
            css = jQuery.curCSS,
            fixed = css(elem, "position") == "fixed";

            // Use getBoundingClientRect if available
            if (elem.getBoundingClientRect) {
                var box = elem.getBoundingClientRect();

                // Add the document scroll offsets
                add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
                box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));

                // IE adds the HTML element's border, by default it is medium which is 2px
                // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
                // IE 7 standards mode, the border is always 2px
                // This border/offset is typically represented by the clientLeft and clientTop properties
                // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
                // Therefore this method will be off by 2px in IE while in quirksmode
                add(-doc.documentElement.clientLeft, -doc.documentElement.clientTop);

                // Otherwise loop through the offsetParents and parentNodes
            } else {

                // Initial element offsets
                add(elem.offsetLeft, elem.offsetTop);

                // Get parent offsets
                while (offsetParent) {
                    // Add offsetParent offsets
                    add(offsetParent.offsetLeft, offsetParent.offsetTop);

                    // Mozilla and Safari > 2 does not include the border on offset parents
                    // However Mozilla adds the border for table or table cells
                    if (mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2)
                        border(offsetParent);

                    // Add the document scroll offsets if position is fixed on any offsetParent
                    if (!fixed && css(offsetParent, "position") == "fixed")
                        fixed = true;

                    // Set offsetChild to previous offsetParent unless it is the body element
                    offsetChild = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
                    // Get next offsetParent
                    offsetParent = offsetParent.offsetParent;
                }

                // Get parent scroll offsets
                while (parent && parent.tagName && !/^body|html$/i.test(parent.tagName)) {
                    // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
                    if (!/^inline|table.*$/i.test(css(parent, "display")))
                    // Subtract parent scroll offsets
                        add(-parent.scrollLeft, -parent.scrollTop);

                    // Mozilla does not add the border for a parent that has overflow != visible
                    if (mozilla && css(parent, "overflow") != "visible")
                        border(parent);

                    // Get next parent
                    parent = parent.parentNode;
                }

                // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
                // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
                if ((safari2 && (fixed || css(offsetChild, "position") == "absolute")) ||
                (mozilla && css(offsetChild, "position") != "absolute"))
                    add(-doc.body.offsetLeft, -doc.body.offsetTop);

                // Add the document scroll offsets if position is fixed
                if (fixed)
                    add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
                    Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
            }

            // Return an object with top and left properties
            results = { top: top, left: left };
        }

        function border(elem) {
            add(jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true));
        }

        function add(l, t) {
            left += parseInt(l, 10) || 0;
            top += parseInt(t, 10) || 0;
        }

        return results;
    };

    jQuery.fn.extend({
        position: function() {
            var left = 0, top = 0, results;

            if (this[0]) {
                // Get *real* offsetParent
                var offsetParent = this.offsetParent(),

                // Get correct offsets
            offset = this.offset(),
            parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0} : offsetParent.offset();

                // Subtract element margins
                // note: when an element has margin: auto the offsetLeft and marginLeft
                // are the same in Safari causing offset.left to incorrectly be 0
                offset.top -= num(this, 'marginTop');
                offset.left -= num(this, 'marginLeft');

                // Add offsetParent borders
                parentOffset.top += num(offsetParent, 'borderTopWidth');
                parentOffset.left += num(offsetParent, 'borderLeftWidth');

                // Subtract the two offsets
                results = {
                    top: offset.top - parentOffset.top,
                    left: offset.left - parentOffset.left
                };
            }

            return results;
        },

        offsetParent: function() {
            var offsetParent = this[0].offsetParent;
            while (offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static'))
                offsetParent = offsetParent.offsetParent;
            return jQuery(offsetParent);
        }
    });

    // Create scrollLeft and scrollTop methods
    jQuery.each(['Left', 'Top'], function(i, name) {
        var method = 'scroll' + name;

        jQuery.fn[method] = function(val) {
            if (!this[0]) return;

            return val != undefined ?

            // Set the scroll offset
            this.each(function() {
                this == window || this == document ?
                    window.scrollTo(
                        !i ? val : jQuery(window).scrollLeft(),
                         i ? val : jQuery(window).scrollTop()
                    ) :
                    this[method] = val;
            }) :

            // Return the scroll offset
            this[0] == window || this[0] == document ?
                self[i ? 'pageYOffset' : 'pageXOffset'] ||
                    jQuery.boxModel && document.documentElement[method] ||
                    document.body[method] :
                this[0][method];
        };
    });
    // Create innerHeight, innerWidth, outerHeight and outerWidth methods
    jQuery.each(["Height", "Width"], function(i, name) {

        var tl = i ? "Left" : "Top",  // top or left
        br = i ? "Right" : "Bottom"; // bottom or right

        // innerHeight and innerWidth
        jQuery.fn["inner" + name] = function() {
            return this[name.toLowerCase()]() +
            num(this, "padding" + tl) +
            num(this, "padding" + br);
        };

        // outerHeight and outerWidth
        jQuery.fn["outer" + name] = function(margin) {
            return this["inner" + name]() +
            num(this, "border" + tl + "Width") +
            num(this, "border" + br + "Width") +
            (margin ?
                num(this, "margin" + tl) + num(this, "margin" + br) : 0);
        };

    });
})();

分享到:
评论

相关推荐

    jQuery Pagination Ajax分页插件(分页切换时无刷新与延迟)中文翻译版

    原项目可在[http://plugins.jquery.com/project/pagination](http://plugins.jquery.com/project/pagination)找到,版本为v1.2,提供英文原版和中文翻译修改版的源文件下载。 **二、功能与说明** 该插件的CSS样式...

    基于模糊故障树的工业控制系统可靠性分析与Python实现

    内容概要:本文探讨了模糊故障树(FFTA)在工业控制系统可靠性分析中的应用,解决了传统故障树方法无法处理不确定数据的问题。文中介绍了模糊数的基本概念和实现方式,如三角模糊数和梯形模糊数,并展示了如何用Python实现模糊与门、或门运算以及系统故障率的计算。此外,还详细讲解了最小割集的查找方法、单元重要度的计算,并通过实例说明了这些方法的实际应用场景。最后,讨论了模糊运算在处理语言变量方面的优势,强调了在可靠性分析中处理模糊性和优化计算效率的重要性。 适合人群:从事工业控制系统设计、维护的技术人员,以及对模糊数学和可靠性分析感兴趣的科研人员。 使用场景及目标:适用于需要评估复杂系统可靠性的场合,特别是在面对不确定数据时,能够提供更准确的风险评估。目标是帮助工程师更好地理解和预测系统故障,从而制定有效的预防措施。 其他说明:文中提供的代码片段和方法可用于初步方案验证和技术探索,但在实际工程项目中还需进一步优化和完善。

    风力发电领域双馈风力发电机(DFIG)Simulink模型的构建与电流电压波形分析

    内容概要:本文详细探讨了双馈风力发电机(DFIG)在Simulink环境下的建模方法及其在不同风速条件下的电流与电压波形特征。首先介绍了DFIG的基本原理,即定子直接接入电网,转子通过双向变流器连接电网的特点。接着阐述了Simulink模型的具体搭建步骤,包括风力机模型、传动系统模型、DFIG本体模型和变流器模型的建立。文中强调了变流器控制算法的重要性,特别是在应对风速变化时,通过实时调整转子侧的电压和电流,确保电流和电压波形的良好特性。此外,文章还讨论了模型中的关键技术和挑战,如转子电流环控制策略、低电压穿越性能、直流母线电压脉动等问题,并提供了具体的解决方案和技术细节。最终,通过对故障工况的仿真测试,验证了所建模型的有效性和优越性。 适用人群:从事风力发电研究的技术人员、高校相关专业师生、对电力电子控制系统感兴趣的工程技术人员。 使用场景及目标:适用于希望深入了解DFIG工作原理、掌握Simulink建模技能的研究人员;旨在帮助读者理解DFIG在不同风速条件下的动态响应机制,为优化风力发电系统的控制策略提供理论依据和技术支持。 其他说明:文章不仅提供了详细的理论解释,还附有大量Matlab/Simulink代码片段,便于读者进行实践操作。同时,针对一些常见问题给出了实用的调试技巧,有助于提高仿真的准确性和可靠性。

    基于西门子S7-200 PLC和组态王的八层电梯控制系统设计与实现

    内容概要:本文详细介绍了基于西门子S7-200 PLC和组态王软件构建的八层电梯控制系统。首先阐述了系统的硬件配置,包括PLC的IO分配策略,如输入输出信号的具体分配及其重要性。接着深入探讨了梯形图编程逻辑,涵盖外呼信号处理、轿厢运动控制以及楼层判断等关键环节。随后讲解了组态王的画面设计,包括动画效果的实现方法,如楼层按钮绑定、轿厢移动动画和门开合效果等。最后分享了一些调试经验和注意事项,如模拟困人场景、防抖逻辑、接线艺术等。 适合人群:从事自动化控制领域的工程师和技术人员,尤其是对PLC编程和组态软件有一定基础的人群。 使用场景及目标:适用于需要设计和实施小型电梯控制系统的工程项目。主要目标是帮助读者掌握PLC编程技巧、组态画面设计方法以及系统联调经验,从而提高项目的成功率。 其他说明:文中提供了详细的代码片段和调试技巧,有助于读者更好地理解和应用相关知识点。此外,还强调了安全性和可靠性方面的考量,如急停按钮的正确接入和硬件互锁设计等。

    CarSim与Simulink联合仿真:基于MPC模型预测控制实现智能超车换道

    内容概要:本文介绍了如何将CarSim的动力学模型与Simulink的智能算法相结合,利用模型预测控制(MPC)实现车辆的智能超车换道。主要内容包括MPC控制器的设计、路径规划算法、联合仿真的配置要点以及实际应用效果。文中提供了详细的代码片段和技术细节,如权重矩阵设置、路径跟踪目标函数、安全超车条件判断等。此外,还强调了仿真过程中需要注意的关键参数配置,如仿真步长、插值设置等,以确保系统的稳定性和准确性。 适合人群:从事自动驾驶研究的技术人员、汽车工程领域的研究人员、对联合仿真感兴趣的开发者。 使用场景及目标:适用于需要进行自动驾驶车辆行为模拟的研究机构和企业,旨在提高超车换道的安全性和效率,为自动驾驶技术研发提供理论支持和技术验证。 其他说明:随包提供的案例文件已调好所有参数,可以直接导入并运行,帮助用户快速上手。文中提到的具体参数和配置方法对于初学者非常友好,能够显著降低入门门槛。

    基于单片机的鱼缸监测设计(51+1602+AD0809+18B20+UART+JKx2)#0107

    包括:源程序工程文件、Proteus仿真工程文件、论文材料、配套技术手册等 1、采用51单片机作为主控; 2、采用AD0809(仿真0808)检测"PH、氨、亚硝酸盐、硝酸盐"模拟传感; 3、采用DS18B20检测温度; 4、采用1602液晶显示检测值; 5、检测值同时串口上传,调试助手监看; 6、亦可通过串口指令对加热器、制氧机进行控制;

    风电领域双馈永磁风电机组并网仿真及短路故障分析与MPPT控制

    内容概要:本文详细介绍了双馈永磁风电机组并网仿真模型及其短路故障分析方法。首先构建了一个9MW风电场模型,由6台1.5MW双馈风机构成,通过升压变压器连接到120kV电网。文中探讨了风速模块的设计,包括渐变风、阵风和随疾风的组合形式,并提供了相应的Python和MATLAB代码示例。接着讨论了双闭环控制策略,即功率外环和电流内环的具体实现细节,以及MPPT控制用于最大化风能捕获的方法。此外,还涉及了短路故障模块的建模,包括三相电压电流特性和离散模型与phasor模型的应用。最后,强调了永磁同步机并网模型的特点和注意事项。 适合人群:从事风电领域研究的技术人员、高校相关专业师生、对风电并网仿真感兴趣的工程技术人员。 使用场景及目标:适用于风电场并网仿真研究,帮助研究人员理解和优化风电机组在不同风速条件下的性能表现,特别是在短路故障情况下的应对措施。目标是提高风电系统的稳定性和可靠性。 其他说明:文中提供的代码片段和具体参数设置有助于读者快速上手并进行实验验证。同时提醒了一些常见的错误和需要注意的地方,如离散化步长的选择、初始位置对齐等。

    空手道训练测试系统BLE106版本

    适用于空手道训练和测试场景

    【音乐创作领域AI提示词】AI音乐提示词(deepseek,豆包,kimi,chatGPT,扣子空间,manus,AI训练师)

    内容概要:本文介绍了金牌音乐作词大师的角色设定、背景经历、偏好特点、创作目标、技能优势以及工作流程。金牌音乐作词大师凭借深厚的音乐文化底蕴和丰富的创作经验,能够为不同风格的音乐创作歌词,擅长将传统文化元素与现代流行文化相结合,创作出既富有情感又触动人心的歌词。在创作过程中,会严格遵守社会主义核心价值观,尊重用户需求,提供专业修改建议,确保歌词内容健康向上。; 适合人群:有歌词创作需求的音乐爱好者、歌手或音乐制作人。; 使用场景及目标:①为特定主题或情感创作歌词,如爱情、励志等;②融合传统与现代文化元素创作独特风格的歌词;③对已有歌词进行润色和优化。; 阅读建议:阅读时可以重点关注作词大师的创作偏好、技能优势以及工作流程,有助于更好地理解如何创作出高质量的歌词。同时,在提出创作需求时,尽量详细描述自己的情感背景和期望,以便获得更贴合心意的作品。

    linux之用户管理教程.md

    linux之用户管理教程.md

    基于单片机的搬运机器人设计(51+1602+L298+BZ+KEY6)#0096

    包括:源程序工程文件、Proteus仿真工程文件、配套技术手册等 1、采用51/52单片机作为主控芯片; 2、采用1602液晶显示设置及状态; 3、采用L298驱动两个电机,模拟机械臂动力、移动底盘动力; 3、首先按键配置-待搬运物块的高度和宽度(为0不能开始搬运); 4、按下启动键开始搬运,搬运流程如下: 机械臂先把物块抓取到机器车上, 机械臂减速 机器车带着物块前往目的地 机器车减速 机械臂把物块放下来 机械臂减速 机器车回到物块堆积处(此时机器车是空车) 机器车减速 蜂鸣器提醒 按下复位键,结束本次搬运

    基于下垂控制的三相逆变器电压电流双闭环仿真及MATLAB/Simulink/PLECS实现

    内容概要:本文详细介绍了基于下垂控制的三相逆变器电压电流双闭环控制的仿真方法及其在MATLAB/Simulink和PLECS中的具体实现。首先解释了下垂控制的基本原理,即有功调频和无功调压,并给出了相应的数学表达式。随后讨论了电压环和电流环的设计与参数整定,强调了两者带宽的差异以及PI控制器的参数选择。文中还提到了一些常见的调试技巧,如锁相环的响应速度、LC滤波器的谐振点处理、死区时间设置等。此外,作者分享了一些实用的经验,如避免过度滤波、合理设置采样周期和下垂系数等。最后,通过突加负载测试展示了系统的动态响应性能。 适合人群:从事电力电子、微电网研究的技术人员,尤其是有一定MATLAB/Simulink和PLECS使用经验的研发人员。 使用场景及目标:适用于希望深入了解三相逆变器下垂控制机制的研究人员和技术人员,旨在帮助他们掌握电压电流双闭环控制的具体实现方法,提高仿真的准确性和效率。 其他说明:本文不仅提供了详细的理论讲解,还结合了大量的实战经验和调试技巧,有助于读者更好地理解和应用相关技术。

    光伏并网逆变器全栈开发资料:硬件设计、控制算法及实战经验

    内容概要:本文详细介绍了光伏并网逆变器的全栈开发资料,涵盖了从硬件设计到控制算法的各个方面。首先,文章深入探讨了功率接口板的设计,包括IGBT缓冲电路、PCB布局以及EMI滤波器的具体参数和设计思路。接着,重点讲解了主控DSP板的核心控制算法,如MPPT算法的实现及其注意事项。此外,还详细描述了驱动扩展板的门极驱动电路设计,特别是光耦隔离和驱动电阻的选择。同时,文章提供了并联仿真的具体实现方法,展示了环流抑制策略的效果。最后,分享了许多宝贵的实战经验和调试技巧,如主变压器绕制、PWM输出滤波、电流探头使用等。 适合人群:从事电力电子、光伏系统设计的研发工程师和技术爱好者。 使用场景及目标:①帮助工程师理解和掌握光伏并网逆变器的硬件设计和控制算法;②提供详细的实战经验和调试技巧,提升产品的可靠性和性能;③适用于希望深入了解光伏并网逆变器全栈开发的技术人员。 其他说明:文中不仅提供了具体的电路设计和代码实现,还分享了许多宝贵的实际操作经验和常见问题的解决方案,有助于提高开发效率和产品质量。

    机器人轨迹规划中粒子群优化与3-5-3多项式结合的时间最优路径规划

    内容概要:本文详细介绍了粒子群优化(PSO)算法与3-5-3多项式相结合的方法,在机器人轨迹规划中的应用。首先解释了粒子群算法的基本原理及其在优化轨迹参数方面的作用,随后阐述了3-5-3多项式的数学模型,特别是如何利用不同阶次的多项式确保轨迹的平滑过渡并满足边界条件。文中还提供了具体的Python代码实现,展示了如何通过粒子群算法优化时间分配,使3-5-3多项式生成的轨迹达到时间最优。此外,作者分享了一些实践经验,如加入惩罚项以避免超速,以及使用随机扰动帮助粒子跳出局部最优。 适合人群:对机器人运动规划感兴趣的科研人员、工程师和技术爱好者,尤其是有一定编程基础并对优化算法有初步了解的人士。 使用场景及目标:适用于需要精确控制机器人运动的应用场合,如工业自动化生产线、无人机导航等。主要目标是在保证轨迹平滑的前提下,尽可能缩短运动时间,提高工作效率。 其他说明:文中不仅给出了理论讲解,还有详细的代码示例和调试技巧,便于读者理解和实践。同时强调了实际应用中需要注意的问题,如系统的建模精度和安全性考量。

    【KUKA 机器人资料】:kuka机器人压铸欧洲标准.pdf

    KUKA机器人相关资料

    光子晶体中BIC与OAM激发的模拟及三维Q值计算

    内容概要:本文详细探讨了光子晶体中的束缚态在连续谱中(BIC)及其与轨道角动量(OAM)激发的关系。首先介绍了光子晶体的基本概念和BIC的独特性质,随后展示了如何通过Python代码模拟二维光子晶体中的BIC,并解释了BIC在光学器件中的潜在应用。接着讨论了OAM激发与BIC之间的联系,特别是BIC如何增强OAM激发效率。文中还提供了使用有限差分时域(FDTD)方法计算OAM的具体步骤,并介绍了计算本征态和三维Q值的方法。此外,作者分享了一些实验中的有趣发现,如特定条件下BIC表现出OAM特征,以及不同参数设置对Q值的影响。 适合人群:对光子晶体、BIC和OAM感兴趣的科研人员和技术爱好者,尤其是从事微纳光子学研究的专业人士。 使用场景及目标:适用于希望通过代码模拟深入了解光子晶体中BIC和OAM激发机制的研究人员。目标是掌握BIC和OAM的基础理论,学会使用Python和其他工具进行模拟,并理解这些现象在实际应用中的潜力。 其他说明:文章不仅提供了详细的代码示例,还分享了许多实验心得和技巧,帮助读者避免常见错误,提高模拟精度。同时,强调了物理离散化方式对数值计算结果的重要影响。

    C#联合Halcon 17.12构建工业视觉项目的配置与应用

    内容概要:本文详细介绍了如何使用C#和Halcon 17.12构建一个功能全面的工业视觉项目。主要内容涵盖项目配置、Halcon脚本的选择与修改、相机调试、模板匹配、生产履历管理、历史图像保存以及与三菱FX5U PLC的以太网通讯。文中不仅提供了具体的代码示例,还讨论了实际项目中常见的挑战及其解决方案,如环境配置、相机控制、模板匹配参数调整、PLC通讯细节、生产数据管理和图像存储策略等。 适合人群:从事工业视觉领域的开发者和技术人员,尤其是那些希望深入了解C#与Halcon结合使用的专业人士。 使用场景及目标:适用于需要开发复杂视觉检测系统的工业应用场景,旨在提高检测精度、自动化程度和数据管理效率。具体目标包括但不限于:实现高效的视觉处理流程、确保相机与PLC的无缝协作、优化模板匹配算法、有效管理生产和检测数据。 其他说明:文中强调了框架整合的重要性,并提供了一些实用的技术提示,如避免不同版本之间的兼容性问题、处理实时图像流的最佳实践、确保线程安全的操作等。此外,还提到了一些常见错误及其规避方法,帮助开发者少走弯路。

    基于Matlab的9节点配电网中分布式电源接入对节点电压影响的研究

    内容概要:本文探讨了分布式电源(DG)接入对9节点配电网节点电压的影响。首先介绍了9节点配电网模型的搭建方法,包括定义节点和线路参数。然后,通过在特定节点接入分布式电源,利用Matlab进行潮流计算,模拟DG对接入点及其周围节点电压的影响。最后,通过绘制电压波形图,直观展示了不同DG容量和接入位置对配电网电压分布的具体影响。此外,还讨论了电压越限问题以及不同线路参数对电压波动的影响。 适合人群:电力系统研究人员、电气工程学生、从事智能电网和分布式能源研究的专业人士。 使用场景及目标:适用于研究分布式电源接入对配电网电压稳定性的影响,帮助优化分布式电源的规划和配置,确保电网安全稳定运行。 其他说明:文中提供的Matlab代码和图表有助于理解和验证理论分析,同时也为后续深入研究提供了有价值的参考资料。

    电力市场领域中基于CVaR风险评估的省间交易商最优购电模型研究与实现

    内容概要:本文探讨了在两级电力市场环境中,针对省间交易商的最优购电模型的研究。文中提出了一个双层非线性优化模型,用于处理省内电力市场和省间电力交易的出清问题。该模型采用CVaR(条件风险价值)方法来评估和管理由新能源和负荷不确定性带来的风险。通过KKT条件和对偶理论,将复杂的双层非线性问题转化为更易求解的线性单层问题。此外,还通过实际案例验证了模型的有效性,展示了不同风险偏好设置对购电策略的影响。 适合人群:从事电力系统规划、运营以及风险管理的专业人士,尤其是对电力市场机制感兴趣的学者和技术专家。 使用场景及目标:适用于希望深入了解电力市场运作机制及其风险控制手段的研究人员和技术开发者。主要目标是为省间交易商提供一种科学有效的购电策略,以降低风险并提高经济效益。 其他说明:文章不仅介绍了理论模型的构建过程,还包括具体的数学公式推导和Python代码示例,便于读者理解和实践。同时强调了模型在实际应用中存在的挑战,如数据精度等问题,并指出了未来改进的方向。

    西门子1200 PLC轴运动控制程序模板及其实战应用详解

    内容概要:本文详细介绍了一套成熟的西门子1200 PLC轴运动控制程序模板,涵盖多轴伺服控制、电缸控制、PLC通讯、气缸报警块、完整电路图、威纶通触摸屏程序和IO表等方面的内容。该模板已在多个项目中成功应用,如海康威视的路由器外壳装配机,确保了系统的稳定性和可靠性。文中不仅提供了具体的代码示例,还分享了许多实战经验和技巧,如参数设置、异常处理机制、通讯优化等。 适合人群:从事工业自动化领域的工程师和技术人员,尤其是那些需要进行PLC编程和轴运动控制的从业者。 使用场景及目标:适用于需要快速搭建稳定可靠的PLC控制系统的企业和个人开发者。通过学习和应用该模板,可以提高开发效率,减少调试时间和错误发生率,从而更好地满足项目需求。 其他说明:文章强调了程序模板的实用性,特别是在异常处理和参数配置方面的独特设计,能够有效应对复杂的工业环境挑战。此外,还提到了一些常见的陷阱和解决方案,帮助读者避开常见错误,顺利实施项目。

Global site tag (gtag.js) - Google Analytics