PageRenderTime 112ms CodeModel.GetById 16ms app.highlight 79ms RepoModel.GetById 1ms app.codeStats 1ms

/Docs/07-Implementacion/Source/trunk/EDUAR_Regular/EDUAR/EDUAR_UI/Scripts/JQuery.js

http://blpm.googlecode.com/
JavaScript | 4376 lines | 3716 code | 314 blank | 346 comment | 389 complexity | b3f6b70893a29bf77c2d20ef1647b309 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*!
   2* jQuery JavaScript Library v1.3.2
   3* http://jquery.com/
   4*
   5* Copyright (c) 2009 John Resig
   6* Dual licensed under the MIT and GPL licenses.
   7* http://docs.jquery.com/License
   8*
   9* Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)
  10* Revision: 6246
  11*/
  12(function () {
  13
  14    var 
  15    // Will speed up references to window, and allows munging its name.
  16	window = this,
  17    // Will speed up references to undefined, and allows munging its name.
  18	undefined,
  19    // Map over jQuery in case of overwrite
  20	_jQuery = window.jQuery,
  21    // Map over the $ in case of overwrite
  22	_$ = window.$,
  23
  24	jQuery = window.jQuery = window.$ = function (selector, context) {
  25	    // The jQuery object is actually just the init constructor 'enhanced'
  26	    return new jQuery.fn.init(selector, context);
  27	},
  28
  29    // A simple way to check for HTML strings or ID strings
  30    // (both of which we optimize for)
  31	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
  32    // Is it a simple selector
  33	isSimple = /^.[^:#\[\.,]*$/;
  34
  35    jQuery.fn = jQuery.prototype = {
  36        init: function (selector, context) {
  37            // Make sure that a selection was provided
  38            selector = selector || document;
  39
  40            // Handle $(DOMElement)
  41            if (selector.nodeType) {
  42                this[0] = selector;
  43                this.length = 1;
  44                this.context = selector;
  45                return this;
  46            }
  47            // Handle HTML strings
  48            if (typeof selector === "string") {
  49                // Are we dealing with HTML string or an ID?
  50                var match = quickExpr.exec(selector);
  51
  52                // Verify a match, and that no context was specified for #id
  53                if (match && (match[1] || !context)) {
  54
  55                    // HANDLE: $(html) -> $(array)
  56                    if (match[1])
  57                        selector = jQuery.clean([match[1]], context);
  58
  59                    // HANDLE: $("#id")
  60                    else {
  61                        var elem = document.getElementById(match[3]);
  62
  63                        // Handle the case where IE and Opera return items
  64                        // by name instead of ID
  65                        if (elem && elem.id != match[3])
  66                            return jQuery().find(selector);
  67
  68                        // Otherwise, we inject the element directly into the jQuery object
  69                        var ret = jQuery(elem || []);
  70                        ret.context = document;
  71                        ret.selector = selector;
  72                        return ret;
  73                    }
  74
  75                    // HANDLE: $(expr, [context])
  76                    // (which is just equivalent to: $(content).find(expr)
  77                } else
  78                    return jQuery(context).find(selector);
  79
  80                // HANDLE: $(function)
  81                // Shortcut for document ready
  82            } else if (jQuery.isFunction(selector))
  83                return jQuery(document).ready(selector);
  84
  85            // Make sure that old selector state is passed along
  86            if (selector.selector && selector.context) {
  87                this.selector = selector.selector;
  88                this.context = selector.context;
  89            }
  90
  91            return this.setArray(jQuery.isArray(selector) ?
  92			selector :
  93			jQuery.makeArray(selector));
  94        },
  95
  96        // Start with an empty selector
  97        selector: "",
  98
  99        // The current version of jQuery being used
 100        jquery: "1.3.2",
 101
 102        // The number of elements contained in the matched element set
 103        size: function () {
 104            return this.length;
 105        },
 106
 107        // Get the Nth element in the matched element set OR
 108        // Get the whole matched element set as a clean array
 109        get: function (num) {
 110            return num === undefined ?
 111
 112            // Return a 'clean' array
 113			Array.prototype.slice.call(this) :
 114
 115            // Return just the object
 116			this[num];
 117        },
 118
 119        // Take an array of elements and push it onto the stack
 120        // (returning the new matched element set)
 121        pushStack: function (elems, name, selector) {
 122            // Build a new jQuery matched element set
 123            var ret = jQuery(elems);
 124
 125            // Add the old object onto the stack (as a reference)
 126            ret.prevObject = this;
 127
 128            ret.context = this.context;
 129
 130            if (name === "find")
 131                ret.selector = this.selector + (this.selector ? " " : "") + selector;
 132            else if (name)
 133                ret.selector = this.selector + "." + name + "(" + selector + ")";
 134
 135            // Return the newly-formed element set
 136            return ret;
 137        },
 138
 139        // Force the current matched set of elements to become
 140        // the specified array of elements (destroying the stack in the process)
 141        // You should use pushStack() in order to do this, but maintain the stack
 142        setArray: function (elems) {
 143            // Resetting the length to 0, then using the native Array push
 144            // is a super-fast way to populate an object with array-like properties
 145            this.length = 0;
 146            Array.prototype.push.apply(this, elems);
 147
 148            return this;
 149        },
 150
 151        // Execute a callback for every element in the matched set.
 152        // (You can seed the arguments with an array of args, but this is
 153        // only used internally.)
 154        each: function (callback, args) {
 155            return jQuery.each(this, callback, args);
 156        },
 157
 158        // Determine the position of an element within
 159        // the matched set of elements
 160        index: function (elem) {
 161            // Locate the position of the desired element
 162            return jQuery.inArray(
 163            // If it receives a jQuery object, the first element is used
 164			elem && elem.jquery ? elem[0] : elem
 165		, this);
 166        },
 167
 168        attr: function (name, value, type) {
 169            var options = name;
 170
 171            // Look for the case where we're accessing a style value
 172            if (typeof name === "string")
 173                if (value === undefined)
 174                    return this[0] && jQuery[type || "attr"](this[0], name);
 175
 176                else {
 177                    options = {};
 178                    options[name] = value;
 179                }
 180
 181            // Check to see if we're setting style values
 182            return this.each(function (i) {
 183                // Set all the styles
 184                for (name in options)
 185                    jQuery.attr(
 186					type ?
 187						this.style :
 188						this,
 189					name, jQuery.prop(this, options[name], type, i, name)
 190				);
 191            });
 192        },
 193
 194        css: function (key, value) {
 195            // ignore negative width and height values
 196            if ((key == 'width' || key == 'height') && parseFloat(value) < 0)
 197                value = undefined;
 198            return this.attr(key, value, "curCSS");
 199        },
 200
 201        text: function (text) {
 202            if (typeof text !== "object" && text != null)
 203                return this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(text));
 204
 205            var ret = "";
 206
 207            jQuery.each(text || this, function () {
 208                jQuery.each(this.childNodes, function () {
 209                    if (this.nodeType != 8)
 210                        ret += this.nodeType != 1 ?
 211						this.nodeValue :
 212						jQuery.fn.text([this]);
 213                });
 214            });
 215
 216            return ret;
 217        },
 218
 219        wrapAll: function (html) {
 220            if (this[0]) {
 221                // The elements to wrap the target around
 222                var wrap = jQuery(html, this[0].ownerDocument).clone();
 223
 224                if (this[0].parentNode)
 225                    wrap.insertBefore(this[0]);
 226
 227                wrap.map(function () {
 228                    var elem = this;
 229
 230                    while (elem.firstChild)
 231                        elem = elem.firstChild;
 232
 233                    return elem;
 234                }).append(this);
 235            }
 236
 237            return this;
 238        },
 239
 240        wrapInner: function (html) {
 241            return this.each(function () {
 242                jQuery(this).contents().wrapAll(html);
 243            });
 244        },
 245
 246        wrap: function (html) {
 247            return this.each(function () {
 248                jQuery(this).wrapAll(html);
 249            });
 250        },
 251
 252        append: function () {
 253            return this.domManip(arguments, true, function (elem) {
 254                if (this.nodeType == 1)
 255                    this.appendChild(elem);
 256            });
 257        },
 258
 259        prepend: function () {
 260            return this.domManip(arguments, true, function (elem) {
 261                if (this.nodeType == 1)
 262                    this.insertBefore(elem, this.firstChild);
 263            });
 264        },
 265
 266        before: function () {
 267            return this.domManip(arguments, false, function (elem) {
 268                this.parentNode.insertBefore(elem, this);
 269            });
 270        },
 271
 272        after: function () {
 273            return this.domManip(arguments, false, function (elem) {
 274                this.parentNode.insertBefore(elem, this.nextSibling);
 275            });
 276        },
 277
 278        end: function () {
 279            return this.prevObject || jQuery([]);
 280        },
 281
 282        // For internal use only.
 283        // Behaves like an Array's method, not like a jQuery method.
 284        push: [].push,
 285        sort: [].sort,
 286        splice: [].splice,
 287
 288        find: function (selector) {
 289            if (this.length === 1) {
 290                var ret = this.pushStack([], "find", selector);
 291                ret.length = 0;
 292                jQuery.find(selector, this[0], ret);
 293                return ret;
 294            } else {
 295                return this.pushStack(jQuery.unique(jQuery.map(this, function (elem) {
 296                    return jQuery.find(selector, elem);
 297                })), "find", selector);
 298            }
 299        },
 300
 301        clone: function (events) {
 302            // Do the clone
 303            var ret = this.map(function () {
 304                if (!jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this)) {
 305                    // IE copies events bound via attachEvent when
 306                    // using cloneNode. Calling detachEvent on the
 307                    // clone will also remove the events from the orignal
 308                    // In order to get around this, we use innerHTML.
 309                    // Unfortunately, this means some modifications to
 310                    // attributes in IE that are actually only stored
 311                    // as properties will not be copied (such as the
 312                    // the name attribute on an input).
 313                    var html = this.outerHTML;
 314                    if (!html) {
 315                        var div = this.ownerDocument.createElement("div");
 316                        div.appendChild(this.cloneNode(true));
 317                        html = div.innerHTML;
 318                    }
 319
 320                    return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];
 321                } else
 322                    return this.cloneNode(true);
 323            });
 324
 325            // Copy the events from the original to the clone
 326            if (events === true) {
 327                var orig = this.find("*").andSelf(), i = 0;
 328
 329                ret.find("*").andSelf().each(function () {
 330                    if (this.nodeName !== orig[i].nodeName)
 331                        return;
 332
 333                    var events = jQuery.data(orig[i], "events");
 334
 335                    for (var type in events) {
 336                        for (var handler in events[type]) {
 337                            jQuery.event.add(this, type, events[type][handler], events[type][handler].data);
 338                        }
 339                    }
 340
 341                    i++;
 342                });
 343            }
 344
 345            // Return the cloned set
 346            return ret;
 347        },
 348
 349        filter: function (selector) {
 350            return this.pushStack(
 351			jQuery.isFunction(selector) &&
 352			jQuery.grep(this, function (elem, i) {
 353			    return selector.call(elem, i);
 354			}) ||
 355
 356			jQuery.multiFilter(selector, jQuery.grep(this, function (elem) {
 357			    return elem.nodeType === 1;
 358			})), "filter", selector);
 359        },
 360
 361        closest: function (selector) {
 362            var pos = jQuery.expr.match.POS.test(selector) ? jQuery(selector) : null,
 363			closer = 0;
 364
 365            return this.map(function () {
 366                var cur = this;
 367                while (cur && cur.ownerDocument) {
 368                    if (pos ? pos.index(cur) > -1 : jQuery(cur).is(selector)) {
 369                        jQuery.data(cur, "closest", closer);
 370                        return cur;
 371                    }
 372                    cur = cur.parentNode;
 373                    closer++;
 374                }
 375            });
 376        },
 377
 378        not: function (selector) {
 379            if (typeof selector === "string")
 380            // test special case where just one selector is passed in
 381                if (isSimple.test(selector))
 382                    return this.pushStack(jQuery.multiFilter(selector, this, true), "not", selector);
 383                else
 384                    selector = jQuery.multiFilter(selector, this);
 385
 386            var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
 387            return this.filter(function () {
 388                return isArrayLike ? jQuery.inArray(this, selector) < 0 : this != selector;
 389            });
 390        },
 391
 392        add: function (selector) {
 393            return this.pushStack(jQuery.unique(jQuery.merge(
 394			this.get(),
 395			typeof selector === "string" ?
 396				jQuery(selector) :
 397				jQuery.makeArray(selector)
 398		)));
 399        },
 400
 401        is: function (selector) {
 402            return !!selector && jQuery.multiFilter(selector, this).length > 0;
 403        },
 404
 405        hasClass: function (selector) {
 406            return !!selector && this.is("." + selector);
 407        },
 408
 409        val: function (value) {
 410            if (value === undefined) {
 411                var elem = this[0];
 412
 413                if (elem) {
 414                    if (jQuery.nodeName(elem, 'option'))
 415                        return (elem.attributes.value || {}).specified ? elem.value : elem.text;
 416
 417                    // We need to handle select boxes special
 418                    if (jQuery.nodeName(elem, "select")) {
 419                        var index = elem.selectedIndex,
 420						values = [],
 421						options = elem.options,
 422						one = elem.type == "select-one";
 423
 424                        // Nothing was selected
 425                        if (index < 0)
 426                            return null;
 427
 428                        // Loop through all the selected options
 429                        for (var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++) {
 430                            var option = options[i];
 431
 432                            if (option.selected) {
 433                                // Get the specifc value for the option
 434                                value = jQuery(option).val();
 435
 436                                // We don't need an array for one selects
 437                                if (one)
 438                                    return value;
 439
 440                                // Multi-Selects return an array
 441                                values.push(value);
 442                            }
 443                        }
 444
 445                        return values;
 446                    }
 447
 448                    // Everything else, we just grab the value
 449                    return (elem.value || "").replace(/\r/g, "");
 450
 451                }
 452
 453                return undefined;
 454            }
 455
 456            if (typeof value === "number")
 457                value += '';
 458
 459            return this.each(function () {
 460                if (this.nodeType != 1)
 461                    return;
 462
 463                if (jQuery.isArray(value) && /radio|checkbox/.test(this.type))
 464                    this.checked = (jQuery.inArray(this.value, value) >= 0 ||
 465					jQuery.inArray(this.name, value) >= 0);
 466
 467                else if (jQuery.nodeName(this, "select")) {
 468                    var values = jQuery.makeArray(value);
 469
 470                    jQuery("option", this).each(function () {
 471                        this.selected = (jQuery.inArray(this.value, values) >= 0 ||
 472						jQuery.inArray(this.text, values) >= 0);
 473                    });
 474
 475                    if (!values.length)
 476                        this.selectedIndex = -1;
 477
 478                } else
 479                    this.value = value;
 480            });
 481        },
 482
 483        html: function (value) {
 484            return value === undefined ?
 485			(this[0] ?
 486				this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :
 487				null) :
 488			this.empty().append(value);
 489        },
 490
 491        replaceWith: function (value) {
 492            return this.after(value).remove();
 493        },
 494
 495        eq: function (i) {
 496            return this.slice(i, +i + 1);
 497        },
 498
 499        slice: function () {
 500            return this.pushStack(Array.prototype.slice.apply(this, arguments),
 501			"slice", Array.prototype.slice.call(arguments).join(","));
 502        },
 503
 504        map: function (callback) {
 505            return this.pushStack(jQuery.map(this, function (elem, i) {
 506                return callback.call(elem, i, elem);
 507            }));
 508        },
 509
 510        andSelf: function () {
 511            return this.add(this.prevObject);
 512        },
 513
 514        domManip: function (args, table, callback) {
 515            if (this[0]) {
 516                var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
 517				scripts = jQuery.clean(args, (this[0].ownerDocument || this[0]), fragment),
 518				first = fragment.firstChild;
 519
 520                if (first)
 521                    for (var i = 0, l = this.length; i < l; i++)
 522                        callback.call(root(this[i], first), this.length > 1 || i > 0 ?
 523							fragment.cloneNode(true) : fragment);
 524
 525                if (scripts)
 526                    jQuery.each(scripts, evalScript);
 527            }
 528
 529            return this;
 530
 531            function root(elem, cur) {
 532                return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
 533				(elem.getElementsByTagName("tbody")[0] ||
 534				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
 535				elem;
 536            }
 537        }
 538    };
 539
 540    // Give the init function the jQuery prototype for later instantiation
 541    jQuery.fn.init.prototype = jQuery.fn;
 542
 543    function evalScript(i, elem) {
 544        if (elem.src)
 545            jQuery.ajax({
 546                url: elem.src,
 547                async: false,
 548                dataType: "script"
 549            });
 550
 551        else
 552            jQuery.globalEval(elem.text || elem.textContent || elem.innerHTML || "");
 553
 554        if (elem.parentNode)
 555            elem.parentNode.removeChild(elem);
 556    }
 557
 558    function now() {
 559        return +new Date;
 560    }
 561
 562    jQuery.extend = jQuery.fn.extend = function () {
 563        // copy reference to target object
 564        var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
 565
 566        // Handle a deep copy situation
 567        if (typeof target === "boolean") {
 568            deep = target;
 569            target = arguments[1] || {};
 570            // skip the boolean and the target
 571            i = 2;
 572        }
 573
 574        // Handle case when target is a string or something (possible in deep copy)
 575        if (typeof target !== "object" && !jQuery.isFunction(target))
 576            target = {};
 577
 578        // extend jQuery itself if only one argument is passed
 579        if (length == i) {
 580            target = this;
 581            --i;
 582        }
 583
 584        for (; i < length; i++)
 585        // Only deal with non-null/undefined values
 586            if ((options = arguments[i]) != null)
 587            // Extend the base object
 588                for (var name in options) {
 589                    var src = target[name], copy = options[name];
 590
 591                    // Prevent never-ending loop
 592                    if (target === copy)
 593                        continue;
 594
 595                    // Recurse if we're merging object values
 596                    if (deep && copy && typeof copy === "object" && !copy.nodeType)
 597                        target[name] = jQuery.extend(deep,
 598                    // Never move original objects, clone them
 599						src || (copy.length != null ? [] : {})
 600					, copy);
 601
 602                    // Don't bring in undefined values
 603                    else if (copy !== undefined)
 604                        target[name] = copy;
 605
 606                }
 607
 608        // Return the modified object
 609        return target;
 610    };
 611
 612    // exclude the following css properties to add px
 613    var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
 614    // cache defaultView
 615	defaultView = document.defaultView || {},
 616	toString = Object.prototype.toString;
 617
 618    jQuery.extend({
 619        noConflict: function (deep) {
 620            window.$ = _$;
 621
 622            if (deep)
 623                window.jQuery = _jQuery;
 624
 625            return jQuery;
 626        },
 627
 628        // See test/unit/core.js for details concerning isFunction.
 629        // Since version 1.3, DOM methods and functions like alert
 630        // aren't supported. They return false on IE (#2968).
 631        isFunction: function (obj) {
 632            return toString.call(obj) === "[object Function]";
 633        },
 634
 635        isArray: function (obj) {
 636            return toString.call(obj) === "[object Array]";
 637        },
 638
 639        // check if an element is in a (or is an) XML document
 640        isXMLDoc: function (elem) {
 641            return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
 642			!!elem.ownerDocument && jQuery.isXMLDoc(elem.ownerDocument);
 643        },
 644
 645        // Evalulates a script in a global context
 646        globalEval: function (data) {
 647            if (data && /\S/.test(data)) {
 648                // Inspired by code by Andrea Giammarchi
 649                // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
 650                var head = document.getElementsByTagName("head")[0] || document.documentElement,
 651				script = document.createElement("script");
 652
 653                script.type = "text/javascript";
 654                if (jQuery.support.scriptEval)
 655                    script.appendChild(document.createTextNode(data));
 656                else
 657                    script.text = data;
 658
 659                // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
 660                // This arises when a base node is used (#2709).
 661                head.insertBefore(script, head.firstChild);
 662                head.removeChild(script);
 663            }
 664        },
 665
 666        nodeName: function (elem, name) {
 667            return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
 668        },
 669
 670        // args is for internal usage only
 671        each: function (object, callback, args) {
 672            var name, i = 0, length = object.length;
 673
 674            if (args) {
 675                if (length === undefined) {
 676                    for (name in object)
 677                        if (callback.apply(object[name], args) === false)
 678                            break;
 679                } else
 680                    for (; i < length; )
 681                        if (callback.apply(object[i++], args) === false)
 682                            break;
 683
 684                // A special, fast, case for the most common use of each
 685            } else {
 686                if (length === undefined) {
 687                    for (name in object)
 688                        if (callback.call(object[name], name, object[name]) === false)
 689                            break;
 690                } else
 691                    for (var value = object[0];
 692					i < length && callback.call(value, i, value) !== false; value = object[++i]) { }
 693            }
 694
 695            return object;
 696        },
 697
 698        prop: function (elem, value, type, i, name) {
 699            // Handle executable functions
 700            if (jQuery.isFunction(value))
 701                value = value.call(elem, i);
 702
 703            // Handle passing in a number to a CSS property
 704            return typeof value === "number" && type == "curCSS" && !exclude.test(name) ?
 705			value + "px" :
 706			value;
 707        },
 708
 709        className: {
 710            // internal only, use addClass("class")
 711            add: function (elem, classNames) {
 712                jQuery.each((classNames || "").split(/\s+/), function (i, className) {
 713                    if (elem.nodeType == 1 && !jQuery.className.has(elem.className, className))
 714                        elem.className += (elem.className ? " " : "") + className;
 715                });
 716            },
 717
 718            // internal only, use removeClass("class")
 719            remove: function (elem, classNames) {
 720                if (elem.nodeType == 1)
 721                    elem.className = classNames !== undefined ?
 722					jQuery.grep(elem.className.split(/\s+/), function (className) {
 723					    return !jQuery.className.has(classNames, className);
 724					}).join(" ") :
 725					"";
 726            },
 727
 728            // internal only, use hasClass("class")
 729            has: function (elem, className) {
 730                return elem && jQuery.inArray(className, (elem.className || elem).toString().split(/\s+/)) > -1;
 731            }
 732        },
 733
 734        // A method for quickly swapping in/out CSS properties to get correct calculations
 735        swap: function (elem, options, callback) {
 736            var old = {};
 737            // Remember the old values, and insert the new ones
 738            for (var name in options) {
 739                old[name] = elem.style[name];
 740                elem.style[name] = options[name];
 741            }
 742
 743            callback.call(elem);
 744
 745            // Revert the old values
 746            for (var name in options)
 747                elem.style[name] = old[name];
 748        },
 749
 750        css: function (elem, name, force, extra) {
 751            if (name == "width" || name == "height") {
 752                var val, props = { position: "absolute", visibility: "hidden", display: "block" }, which = name == "width" ? ["Left", "Right"] : ["Top", "Bottom"];
 753
 754                function getWH() {
 755                    val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
 756
 757                    if (extra === "border")
 758                        return;
 759
 760                    jQuery.each(which, function () {
 761                        if (!extra)
 762                            val -= parseFloat(jQuery.curCSS(elem, "padding" + this, true)) || 0;
 763                        if (extra === "margin")
 764                            val += parseFloat(jQuery.curCSS(elem, "margin" + this, true)) || 0;
 765                        else
 766                            val -= parseFloat(jQuery.curCSS(elem, "border" + this + "Width", true)) || 0;
 767                    });
 768                }
 769
 770                if (elem.offsetWidth !== 0)
 771                    getWH();
 772                else
 773                    jQuery.swap(elem, props, getWH);
 774
 775                return Math.max(0, Math.round(val));
 776            }
 777
 778            return jQuery.curCSS(elem, name, force);
 779        },
 780
 781        curCSS: function (elem, name, force) {
 782            var ret, style = elem.style;
 783
 784            // We need to handle opacity special in IE
 785            if (name == "opacity" && !jQuery.support.opacity) {
 786                ret = jQuery.attr(style, "opacity");
 787
 788                return ret == "" ?
 789				"1" :
 790				ret;
 791            }
 792
 793            // Make sure we're using the right name for getting the float value
 794            if (name.match(/float/i))
 795                name = styleFloat;
 796
 797            if (!force && style && style[name])
 798                ret = style[name];
 799
 800            else if (defaultView.getComputedStyle) {
 801
 802                // Only "float" is needed here
 803                if (name.match(/float/i))
 804                    name = "float";
 805
 806                name = name.replace(/([A-Z])/g, "-$1").toLowerCase();
 807
 808                var computedStyle = defaultView.getComputedStyle(elem, null);
 809
 810                if (computedStyle)
 811                    ret = computedStyle.getPropertyValue(name);
 812
 813                // We should always get a number back from opacity
 814                if (name == "opacity" && ret == "")
 815                    ret = "1";
 816
 817            } else if (elem.currentStyle) {
 818                var camelCase = name.replace(/\-(\w)/g, function (all, letter) {
 819                    return letter.toUpperCase();
 820                });
 821
 822                ret = elem.currentStyle[name] || elem.currentStyle[camelCase];
 823
 824                // From the awesome hack by Dean Edwards
 825                // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
 826
 827                // If we're not dealing with a regular pixel number
 828                // but a number that has a weird ending, we need to convert it to pixels
 829                if (!/^\d+(px)?$/i.test(ret) && /^\d/.test(ret)) {
 830                    // Remember the original values
 831                    var left = style.left, rsLeft = elem.runtimeStyle.left;
 832
 833                    // Put in the new values to get a computed value out
 834                    elem.runtimeStyle.left = elem.currentStyle.left;
 835                    style.left = ret || 0;
 836                    ret = style.pixelLeft + "px";
 837
 838                    // Revert the changed values
 839                    style.left = left;
 840                    elem.runtimeStyle.left = rsLeft;
 841                }
 842            }
 843
 844            return ret;
 845        },
 846
 847        clean: function (elems, context, fragment) {
 848            context = context || document;
 849
 850            // !context.createElement fails in IE with an error but returns typeof 'object'
 851            if (typeof context.createElement === "undefined")
 852                context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
 853
 854            // If a single string is passed in and it's a single tag
 855            // just do a createElement and skip the rest
 856            if (!fragment && elems.length === 1 && typeof elems[0] === "string") {
 857                var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
 858                if (match)
 859                    return [context.createElement(match[1])];
 860            }
 861
 862            var ret = [], scripts = [], div = context.createElement("div");
 863
 864            jQuery.each(elems, function (i, elem) {
 865                if (typeof elem === "number")
 866                    elem += '';
 867
 868                if (!elem)
 869                    return;
 870
 871                // Convert html string into DOM nodes
 872                if (typeof elem === "string") {
 873                    // Fix "XHTML"-style tags in all browsers
 874                    elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function (all, front, tag) {
 875                        return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
 876						all :
 877						front + "></" + tag + ">";
 878                    });
 879
 880                    // Trim whitespace, otherwise indexOf won't work as expected
 881                    var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();
 882
 883                    var wrap =
 884                    // option or optgroup
 885					!tags.indexOf("<opt") &&
 886					[1, "<select multiple='multiple'>", "</select>"] ||
 887
 888					!tags.indexOf("<leg") &&
 889					[1, "<fieldset>", "</fieldset>"] ||
 890
 891					tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
 892					[1, "<table>", "</table>"] ||
 893
 894					!tags.indexOf("<tr") &&
 895					[2, "<table><tbody>", "</tbody></table>"] ||
 896
 897                    // <thead> matched above
 898					(!tags.indexOf("<td") || !tags.indexOf("<th")) &&
 899					[3, "<table><tbody><tr>", "</tr></tbody></table>"] ||
 900
 901					!tags.indexOf("<col") &&
 902					[2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"] ||
 903
 904                    // IE can't serialize <link> and <script> tags normally
 905					!jQuery.support.htmlSerialize &&
 906					[1, "div<div>", "</div>"] ||
 907
 908					[0, "", ""];
 909
 910                    // Go to html and back, then peel off extra wrappers
 911                    div.innerHTML = wrap[1] + elem + wrap[2];
 912
 913                    // Move to the right depth
 914                    while (wrap[0]--)
 915                        div = div.lastChild;
 916
 917                    // Remove IE's autoinserted <tbody> from table fragments
 918                    if (!jQuery.support.tbody) {
 919
 920                        // String was a <table>, *may* have spurious <tbody>
 921                        var hasBody = /<tbody/i.test(elem),
 922						tbody = !tags.indexOf("<table") && !hasBody ?
 923							div.firstChild && div.firstChild.childNodes :
 924
 925                        // String was a bare <thead> or <tfoot>
 926						wrap[1] == "<table>" && !hasBody ?
 927							div.childNodes :
 928							[];
 929
 930                        for (var j = tbody.length - 1; j >= 0; --j)
 931                            if (jQuery.nodeName(tbody[j], "tbody") && !tbody[j].childNodes.length)
 932                                tbody[j].parentNode.removeChild(tbody[j]);
 933
 934                    }
 935
 936                    // IE completely kills leading whitespace when innerHTML is used
 937                    if (!jQuery.support.leadingWhitespace && /^\s/.test(elem))
 938                        div.insertBefore(context.createTextNode(elem.match(/^\s*/)[0]), div.firstChild);
 939
 940                    elem = jQuery.makeArray(div.childNodes);
 941                }
 942
 943                if (elem.nodeType)
 944                    ret.push(elem);
 945                else
 946                    ret = jQuery.merge(ret, elem);
 947
 948            });
 949
 950            if (fragment) {
 951                for (var i = 0; ret[i]; i++) {
 952                    if (jQuery.nodeName(ret[i], "script") && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript")) {
 953                        scripts.push(ret[i].parentNode ? ret[i].parentNode.removeChild(ret[i]) : ret[i]);
 954                    } else {
 955                        if (ret[i].nodeType === 1)
 956                            ret.splice.apply(ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))));
 957                        fragment.appendChild(ret[i]);
 958                    }
 959                }
 960
 961                return scripts;
 962            }
 963
 964            return ret;
 965        },
 966
 967        attr: function (elem, name, value) {
 968            // don't set attributes on text and comment nodes
 969            if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
 970                return undefined;
 971
 972            var notxml = !jQuery.isXMLDoc(elem),
 973            // Whether we are setting (or getting)
 974			set = value !== undefined;
 975
 976            // Try to normalize/fix the name
 977            name = notxml && jQuery.props[name] || name;
 978
 979            // Only do all the following if this is a node (faster for style)
 980            // IE elem.getAttribute passes even for style
 981            if (elem.tagName) {
 982
 983                // These attributes require special treatment
 984                var special = /href|src|style/.test(name);
 985
 986                // Safari mis-reports the default selected property of a hidden option
 987                // Accessing the parent's selectedIndex property fixes it
 988                if (name == "selected" && elem.parentNode)
 989                    elem.parentNode.selectedIndex;
 990
 991                // If applicable, access the attribute via the DOM 0 way
 992                if (name in elem && notxml && !special) {
 993                    if (set) {
 994                        // We can't allow the type property to be changed (since it causes problems in IE)
 995                        if (name == "type" && jQuery.nodeName(elem, "input") && elem.parentNode)
 996                            throw "type property can't be changed";
 997
 998                        elem[name] = value;
 999                    }
1000
1001                    // browsers index elements by id/name on forms, give priority to attributes.
1002                    if (jQuery.nodeName(elem, "form") && elem.getAttributeNode(name))
1003                        return elem.getAttributeNode(name).nodeValue;
1004
1005                    // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1006                    // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1007                    if (name == "tabIndex") {
1008                        var attributeNode = elem.getAttributeNode("tabIndex");
1009                        return attributeNode && attributeNode.specified
1010						? attributeNode.value
1011						: elem.nodeName.match(/(button|input|object|select|textarea)/i)
1012							? 0
1013							: elem.nodeName.match(/^(a|area)$/i) && elem.href
1014								? 0
1015								: undefined;
1016                    }
1017
1018                    return elem[name];
1019                }
1020
1021                if (!jQuery.support.style && notxml && name == "style")
1022                    return jQuery.attr(elem.style, "cssText", value);
1023
1024                if (set)
1025                // convert the value to a string (all browsers do this but IE) see #1070
1026                    elem.setAttribute(name, "" + value);
1027
1028                var attr = !jQuery.support.hrefNormalized && notxml && special
1029                // Some attributes require a special call on IE
1030					? elem.getAttribute(name, 2)
1031					: elem.getAttribute(name);
1032
1033                // Non-existent attributes return null, we normalize to undefined
1034                return attr === null ? undefined : attr;
1035            }
1036
1037            // elem is actually elem.style ... set the style
1038
1039            // IE uses filters for opacity
1040            if (!jQuery.support.opacity && name == "opacity") {
1041                if (set) {
1042                    // IE has trouble with opacity if it does not have layout
1043                    // Force it by setting the zoom level
1044                    elem.zoom = 1;
1045
1046                    // Set the alpha filter to set the opacity
1047                    elem.filter = (elem.filter || "").replace(/alpha\([^)]*\)/, "") +
1048					(parseInt(value) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1049                }
1050
1051                return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1052				(parseFloat(elem.filter.match(/opacity=([^)]*)/)[1]) / 100) + '' :
1053				"";
1054            }
1055
1056            name = name.replace(/-([a-z])/ig, function (all, letter) {
1057                return letter.toUpperCase();
1058            });
1059
1060            if (set)
1061                elem[name] = value;
1062
1063            return elem[name];
1064        },
1065
1066        trim: function (text) {
1067            return (text || "").replace(/^\s+|\s+$/g, "");
1068        },
1069
1070        makeArray: function (array) {
1071            var ret = [];
1072
1073            if (array != null) {
1074                var i = array.length;
1075                // The window, strings (and functions) also have 'length'
1076                if (i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval)
1077                    ret[0] = array;
1078                else
1079                    while (i)
1080                        ret[--i] = array[i];
1081            }
1082
1083            return ret;
1084        },
1085
1086        inArray: function (elem, array) {
1087            for (var i = 0, length = array.length; i < length; i++)
1088            // Use === because on IE, window == document
1089                if (array[i] === elem)
1090                    return i;
1091
1092            return -1;
1093        },
1094
1095        merge: function (first, second) {
1096            // We have to loop this way because IE & Opera overwrite the length
1097            // expando of getElementsByTagName
1098            var i = 0, elem, pos = first.length;
1099            // Also, we need to make sure that the correct elements are being returned
1100            // (IE returns comment nodes in a '*' query)
1101            if (!jQuery.support.getAll) {
1102                while ((elem = second[i++]) != null)
1103                    if (elem.nodeType != 8)
1104                        first[pos++] = elem;
1105
1106            } else
1107                while ((elem = second[i++]) != null)
1108                    first[pos++] = elem;
1109
1110            return first;
1111        },
1112
1113        unique: function (array) {
1114            var ret = [], done = {};
1115
1116            try {
1117
1118                for (var i = 0, length = array.length; i < length; i++) {
1119                    var id = jQuery.data(array[i]);
1120
1121                    if (!done[id]) {
1122                        done[id] = true;
1123                        ret.push(array[i]);
1124                    }
1125                }
1126
1127            } catch (e) {
1128                ret = array;
1129            }
1130
1131            return ret;
1132        },
1133
1134        grep: function (elems, callback, inv) {
1135            var ret = [];
1136
1137            // Go through the array, only saving the items
1138            // that pass the validator function
1139            for (var i = 0, length = elems.length; i < length; i++)
1140                if (!inv != !callback(elems[i], i))
1141                    ret.push(elems[i]);
1142
1143            return ret;
1144        },
1145
1146        map: function (elems, callback) {
1147            var ret = [];
1148
1149            // Go through the array, translating each of the items to their
1150            // new value (or values).
1151            for (var i = 0, length = elems.length; i < length; i++) {
1152                var value = callback(elems[i], i);
1153
1154                if (value != null)
1155                    ret[ret.length] = value;
1156            }
1157
1158            return ret.concat.apply([], ret);
1159        }
1160    });
1161
1162    // Use of jQuery.browser is deprecated.
1163    // It's included for backwards compatibility and plugins,
1164    // although they should work to migrate away.
1165
1166    var userAgent = navigator.userAgent.toLowerCase();
1167
1168    // Figure out what browser is being used
1169    jQuery.browser = {
1170        version: (userAgent.match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [0, '0'])[1],
1171        safari: /webkit/.test(userAgent),
1172        opera: /opera/.test(userAgent),
1173        msie: /msie/.test(userAgent) && !/opera/.test(userAgent),
1174        mozilla: /mozilla/.test(userAgent) && !/(compatible|webkit)/.test(userAgent)
1175    };
1176
1177    jQuery.each({
1178        parent: function (elem) { return elem.parentNode; },
1179        parents: function (elem) { return jQuery.dir(elem, "parentNode"); },
1180        next: function (elem) { return jQuery.nth(elem, 2, "nextSibling"); },
1181        prev: function (elem) { return jQuery.nth(elem, 2, "previousSibling"); },
1182        nextAll: function (elem) { return jQuery.dir(elem, "nextSibling"); },
1183        prevAll: function (elem) { return jQuery.dir(elem, "previousSibling"); },
1184        siblings: function (elem) { return jQuery.sibling(elem.parentNode.firstChild, elem); },
1185        children: function (elem) { return jQuery.sibling(elem.firstChild); },
1186        contents: function (elem) { return jQuery.nodeName(elem, "iframe") ? elem.contentDocument || elem.contentWindow.document : jQuery.makeArray(elem.childNodes); }
1187    }, function (name, fn) {
1188        jQuery.fn[name] = function (selector) {
1189            var ret = jQuery.map(this, fn);
1190
1191            if (selector && typeof selector == "string")
1192                ret = jQuery.multiFilter(selector, ret);
1193
1194            return this.pushStack(jQuery.unique(ret), name, selector);
1195        };
1196    });
1197
1198    jQuery.each({
1199        appendTo: "append",
1200        prependTo: "prepend",
1201        insertBefore: "before",
1202        insertAfter: "after",
1203        replaceAll: "replaceWith"
1204    }, function (name, original) {
1205        jQuery.fn[name] = function (selector) {
1206            var ret = [], insert = jQuery(selector);
1207
1208            for (var i = 0, l = insert.length; i < l; i++) {
1209                var elems = (i > 0 ? this.clone(true) : this).get();
1210                jQuery.fn[original].apply(jQuery(insert[i]), elems);
1211                ret = ret.concat(elems);
1212            }
1213
1214            return this.pushStack(ret, name, selector);
1215        };
1216    });
1217
1218    jQuery.each({
1219        removeAttr: function (name) {
1220            jQuery.attr(this, name, "");
1221            if (this.nodeType == 1)
1222                this.removeAttribute(name);
1223        },
1224
1225        addClass: function (classNames) {
1226            jQuery.className.add(this, classNames);
1227        },
1228
1229        removeClass: function (classNames) {
1230            jQuery.className.remove(this, classNames);
1231        },
1232
1233        toggleClass: function (classNames, state) {
1234            if (typeof state !== "boolean")
1235                state = !jQuery.className.has(this, classNames);
1236            jQuery.className[state ? "add" : "remove"](this, classNames);
1237        },
1238
1239        remove: function (selector) {
1240            if (!selector || jQuery.filter(selector, [this]).length) {
1241                // Prevent memory leaks
1242                jQuery("*", this).add([this]).each(function () {
1243                    jQuery.event.remove(this);
1244                    jQuery.removeData(this);
1245                });
1246                if (this.parentNode)
1247                    this.parentNode.removeChild(this);
1248            }
1249        },
1250
1251        empty: function () {
1252            // Remove element nodes and prevent memory leaks
1253            jQuery(this).children().remove();
1254
1255            // Remove any remaining nodes
1256            while (this.firstChild)
1257                this.removeChild(this.firstChild);
1258        }
1259    }, function (name, fn) {
1260        jQuery.fn[name] = function () {
1261            return this.each(fn, arguments);
1262        };
1263    });
1264
1265    // Helper function used by the dimensions and offset modules
1266    function num(elem, prop) {
1267        return elem[0] && parseInt(jQuery.curCSS(elem[0], prop, true), 10) || 0;
1268    }
1269    var expando = "jQuery" + now(), uuid = 0, windowData = {};
1270
1271    jQuery.extend({
1272        cache: {},
1273
1274        data: function (elem, name, data) {
1275            elem = elem == window ?
1276			windowData :
1277			elem;
1278
1279            var id = elem[expando];
1280
1281            // Compute a unique ID for the element
1282            if (!id)
1283                id = elem[expando] = ++uuid;
1284
1285            // Only generate the data cache if we're
1286            // trying to access or manipulate it
1287            if (name && !jQuery.cache[id])
1288                jQuery.cache[id] = {};
1289
1290            // Prevent overriding the named cache with undefined values
1291            if (data !== undefined)
1292                jQuery.cache[id][name] = data;
1293
1294            // Return the named cache data, or the ID for the element
1295            return name ?
1296			jQuery.cache[id][name] :
1297			id;
1298        },
1299
1300        removeData: function (elem, name) {
1301            elem = elem == window ?
1302			windowData :
1303			elem;
1304
1305            var id = elem[expando];
1306
1307            // If we want to remove a specific section of the element's data
1308            if (name) {
1309                if (jQuery.cache[id]) {
1310                    // Remove the section of cache data
1311                    delete jQuery.cache[id][name];
1312
1313                    // If we've removed all the data, remove the element's cache
1314                    name = "";
1315
1316                    for (name in jQuery.cache[id])
1317                        break;
1318
1319                    if (!name)
1320                        jQuery.removeData(elem);
1321                }
1322
1323                // Otherwise, we want to remove all of the element's data
1324            } else {
1325                // Clean up the element expando
1326                try {
1327                    delete elem[expando];
1328                } catch (e) {
1329                    // IE has trouble directly removing the expando
1330                    // but it's ok with using removeAttribute
1331                    if (elem.removeAttribute)
1332                        elem.removeAttribute(expando);
1333                }
1334
1335                // Completely remove the data cache
1336                delete jQuery.cache[id];
1337            }
1338        },
1339        queue: function (elem, type, data) {
1340            if (elem) {
1341
1342                type = (type || "fx") + "queue";
1343
1344                var q = jQuery.data(elem, type);
1345
1346                if (!q || jQuery.isArray(data))
1347                    q = jQuery.data(elem, type, jQuery.makeArray(data));
1348                else if (data)
1349                    q.push(data);
1350
1351            }
1352            return q;
1353        },
1354
1355        dequeue: function (elem, type) {
1356            var queue = jQuery.queue(elem, type),
1357			fn = queue.shift();
1358
1359            if (!type || type === "fx")
1360                fn = queue[0];
1361
1362            if (fn !== undefined)
1363                fn.call(elem);
1364        }
1365    });
1366
1367    jQuery.fn.extend({
1368        data: function (key, value) {
1369            var parts = key.split(".");
1370            parts[1] = parts[1] ? "." + parts[1] : "";
1371
1372            if (value === undefined) {
1373                var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1374
1375                if (data === undefined && this.length)
1376                    data = jQuery.data(this[0], key);
1377
1378                return data === undefined && parts[1] ?
1379				this.data(parts[0]) :
1380				data;
1381            } else
1382                return this.trigger("setDa

Large files files are truncated, but you can click here to view the full file