| blob | a9f2ec7d2d2fecb8b3eb10d5901ca08b8ee03b7c |
1 /*!
2 * jQuery JavaScript Library v1.4.4
3 * http://jquery.com/
4 *
5 * Copyright 2010, John Resig
6 * Dual licensed under the MIT or GPL Version 2 licenses.
7 * http://jquery.org/license
8 *
9 * Includes Sizzle.js
10 * http://sizzlejs.com/
11 * Copyright 2010, The Dojo Foundation
12 * Released under the MIT, BSD, and GPL Licenses.
13 *
14 * Date: Thu Nov 11 19:04:53 2010 -0500
15 */
18 // Use the correct document accordingly with window argument (sandbox)
22 // Define a local copy of jQuery
24 // The jQuery object is actually just the init constructor 'enhanced'
26 },
28 // Map over jQuery in case of overwrite
31 // Map over the $ in case of overwrite
34 // A central reference to the root jQuery(document)
35 rootjQuery,
37 // A simple way to check for HTML strings or ID strings
38 // (both of which we optimize for)
41 // Is it a simple selector
44 // Check if a string has a non-whitespace character in it
48 // Used for trimming whitespace
52 // Check for non-word characters
55 // Check for digits
58 // Match a standalone tag
61 // JSON RegExp
67 // Useragent RegExp
73 // Keep a UserAgent string for use with jQuery.browser
76 // For matching the engine and version of the browser
77 browserMatch,
79 // Has the ready events already been bound?
82 // The functions to execute on DOM ready
83 readyList = [],
85 // The ready event handler
86 DOMContentLoaded,
88 // Save a reference to some core methods
96 // [[Class]] -> type pairs
97 class2type = {};
103 // Handle $(""), $(null), or $(undefined)
106 }
108 // Handle $(DOMElement)
113 }
115 // The body element only exists once, optimize finding it
122 }
124 // Handle HTML strings
126 // Are we dealing with HTML string or an ID?
129 // Verify a match, and that no context was specified for #id
132 // HANDLE: $(html) -> $(array)
136 // If a single string is passed in and it's a single tag
137 // just do a createElement and skip the rest
147 }
152 }
156 // HANDLE: $("#id")
160 // Check parentNode to catch when Blackberry 4.6 returns
161 // nodes that are no longer in the document #6963
163 // Handle the case where IE and Opera return items
164 // by name instead of ID
167 }
169 // Otherwise, we inject the element directly into the jQuery object
172 }
177 }
179 // HANDLE: $("TAG")
186 // HANDLE: $(expr, $(...))
190 // HANDLE: $(expr, context)
191 // (which is just equivalent to: $(context).find(expr)
194 }
196 // HANDLE: $(function)
197 // Shortcut for document ready
200 }
205 }
208 },
210 // Start with an empty selector
213 // The current version of jQuery being used
216 // The default length of a jQuery object is 0
219 // The number of elements contained in the matched element set
222 },
226 },
228 // Get the Nth element in the matched element set OR
229 // Get the whole matched element set as a clean array
233 // Return a 'clean' array
236 // Return just the object
238 },
240 // Take an array of elements and push it onto the stack
241 // (returning the new matched element set)
243 // Build a new jQuery matched element set
251 }
253 // Add the old object onto the stack (as a reference)
262 }
264 // Return the newly-formed element set
266 },
268 // Execute a callback for every element in the matched set.
269 // (You can seed the arguments with an array of args, but this is
270 // only used internally.)
273 },
276 // Attach the listeners
279 // If the DOM is already ready
281 // Execute the function immediately
284 // Otherwise, remember the function for later
286 // Add the function to the wait list
288 }
291 },
297 },
301 },
305 },
310 },
315 }));
316 },
320 },
322 // For internal use only.
323 // Behaves like an Array's method, not like a jQuery method.
326 splice: [].splice
327 };
329 // Give the init function the jQuery prototype for later instantiation
339 // Handle a deep copy situation
343 // skip the boolean and the target
345 }
347 // Handle case when target is a string or something (possible in deep copy)
349 target = {};
350 }
352 // extend jQuery itself if only one argument is passed
356 }
359 // Only deal with non-null/undefined values
361 // Extend the base object
366 // Prevent never-ending loop
369 }
371 // Recurse if we're merging plain objects or arrays
379 }
381 // Never move original objects, clone them
384 // Don't bring in undefined values
387 }
388 }
389 }
390 }
392 // Return the modified object
394 };
402 }
405 },
407 // Is the DOM ready to be used? Set to true once it occurs.
410 // A counter to track how many items to wait for before
411 // the ready event fires. See #6781
414 // Handle when the DOM is ready
416 // A third-party is pushing the ready event forwards
419 }
421 // Make sure that the DOM is not already loaded
423 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
426 }
428 // Remember that the DOM is ready
431 // If a normal DOM Ready event fired, decrement, and wait if need be
434 }
436 // If there are functions bound, to execute
438 // Execute all of them
443 // Reset the list of functions
448 }
450 // Trigger any bound ready events
453 }
454 }
455 }
456 },
461 }
465 // Catch cases where $(document).ready() is called after the
466 // browser event has already occurred.
468 // Handle it asynchronously to allow scripts the opportunity to delay ready
470 }
472 // Mozilla, Opera and webkit nightlies currently support this event
474 // Use the handy event callback
477 // A fallback to window.onload, that will always work
480 // If IE event model is used
482 // ensure firing before onload,
483 // maybe late but safe also for iframes
486 // A fallback to window.onload, that will always work
489 // If IE and not a frame
490 // continually check to see if the document is ready
499 }
500 }
501 },
503 // See test/unit/core.js for details concerning isFunction.
504 // Since version 1.3, DOM methods and functions like alert
505 // aren't supported. They return false on IE (#2968).
508 },
512 },
514 // A crude way of determining if an object is a window
517 },
521 },
527 },
530 // Must be an Object.
531 // Because of IE, we also have to check the presence of the constructor property.
532 // Make sure that DOM nodes and window objects don't pass through, as well
535 }
537 // Not own constructor property must be Object
542 }
544 // Own properties are enumerated firstly, so to speed up,
545 // if last one is own, then all properties are own.
551 },
556 }
558 },
562 },
567 }
569 // Make sure leading/trailing whitespace is removed (IE can't handle it)
572 // Make sure the incoming data is actual JSON
573 // Logic borrowed from http://json.org/json2.js
578 // Try to use the native JSON parser first
585 }
586 },
590 // Evalulates a script in a global context
593 // Inspired by code by Andrea Giammarchi
594 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
604 }
606 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
607 // This arises when a base node is used (#2709).
610 }
611 },
615 },
617 // args is for internal usage only
628 }
629 }
634 }
635 }
636 }
638 // A special, fast, case for the most common use of each
644 }
645 }
649 }
650 }
653 },
655 // Use native String.trim function wherever possible
661 } :
663 // Otherwise use our own trimming functionality
668 },
670 // results is for internal usage only
675 // The window, strings (and functions) also have 'length'
676 // The extra typeof function check is to prevent crashes
677 // in Safari 2 (See: #3039)
678 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
681 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
685 }
686 }
689 },
694 }
699 }
700 }
703 },
712 }
717 }
718 }
723 },
729 // Go through the array, only saving the items
730 // that pass the validator function
735 }
736 }
739 },
741 // arg is for internal usage only
745 // Go through the array, translating each of the items to their
746 // new value (or values).
752 }
753 }
756 },
758 // A global GUID counter for objects
771 }
772 }
777 };
778 }
780 // Set the guid of unique handler to the same of original handler, so it can be removed
783 }
785 // So proxy can be declared as an argument
787 },
789 // Mutifunctional method to get and set values to a collection
790 // The value/s can be optionally by executed if its a function
794 // Setting many attributes
798 }
800 }
802 // Setting one attribute
804 // Optionally, function values get executed if exec is true
809 }
812 }
814 // Getting an attribute
816 },
820 },
822 // Use of jQuery.browser is frowned upon.
823 // More details: http://docs.jquery.com/Utilities/jQuery.browser
831 [];
834 },
836 browser: {}
837 });
839 // Populate the class2type map
840 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
842 });
848 }
850 // Deprecated, use jQuery.browser.webkit instead
853 }
858 };
859 }
861 // Verify that \s matches non-breaking spaces
862 // (IE fails on this test)
866 }
868 // All jQuery objects should point back to these
871 // Cleanup functions for the document ready method
876 };
880 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
884 }
885 };
886 }
888 // The DOM ready check for Internet Explorer
892 }
895 // If IE is used, use the trick by Diego Perini
896 // http://javascript.nwbox.com/IEContentLoaded/
901 }
903 // and execute any waiting functions
905 }
907 // Expose jQuery to the global object
910 })();
923 div.innerHTML = " <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
930 // Can't get basic test support
933 }
936 // IE strips leading whitespace when .innerHTML is used
939 // Make sure that tbody elements aren't automatically inserted
940 // IE will insert them into empty tables
943 // Make sure that link elements get serialized correctly by innerHTML
944 // This requires a wrapper element in IE
947 // Get the style information from getAttribute
948 // (IE uses .cssText insted)
951 // Make sure that URLs aren't manipulated
952 // (IE normalizes it by default)
955 // Make sure that element opacity exists
956 // (IE uses filter instead)
957 // Use a regex to work around a WebKit issue. See #5145
960 // Verify style float existence
961 // (IE uses styleFloat instead of cssFloat)
964 // Make sure that if no value is specified for a checkbox
965 // that it defaults to "on".
966 // (WebKit defaults to "" instead)
969 // Make sure that a selected-by-default option has a working selected property.
970 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
973 // Will be defined later
983 };
985 // Make sure that the options inside disabled selects aren't marked as disabled
986 // (WebKit marks them as diabled)
997 // Make sure that the execution of code works by injecting a script
998 // tag with appendChild/createTextNode
999 // (IE doesn't support this, fails, and uses .text instead)
1003 }
1005 // Test to see if it's possible to delete an expando from an element
1006 // Fails in Internet Explorer
1012 }
1018 // Cloning a node shouldn't copy over any
1019 // bound event handlers (IE does this)
1022 });
1024 }
1032 // WebKit doesn't clone checked state correctly in fragments
1035 // Figure out if the W3C box model works as expected
1036 // document.body must exist before we can do this
1041 // Frameset documents with no body should not run this code
1044 }
1051 // Check if natively block-level elements act like inline-block
1052 // elements when setting their display to 'inline' and giving
1053 // them layout
1054 // (IE < 8 does this)
1059 // Check if elements with layout shrink-wrap their children
1060 // (IE 6 does this)
1064 }
1069 // Check if table cells still have offsetWidth/Height when they are set
1070 // to display:none and there are still other visible table cells in a
1071 // table row; if so, offsetWidth/Height are not reliable for use when
1072 // determining if an element has been hidden directly using
1073 // display:none (it is still safe to use offsets if a parent element is
1074 // hidden; don safety goggles and see bug #4512 for more information).
1075 // (only IE 8 fails this test)
1081 // Check if empty table cells still have offsetWidth/Height
1082 // (IE < 8 fail this test)
1083 jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1088 });
1090 // Technique from Juriy Zaytsev
1091 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1100 }
1104 };
1109 // release memory in IE
1111 })();
1119 cache: {},
1121 // Please use with caution
1124 // Unique for each copy of jQuery on the page
1127 // The following elements throw uncatchable exceptions if you
1128 // attempt to add expando properties to them.
1129 noData: {
1131 // Ban all objects except for Flash (which handle expandos)
1134 },
1139 }
1142 windowData :
1143 elem;
1151 }
1153 // Get the data from the object directly
1157 // Compute a unique ID for the element
1160 }
1162 // Avoid generating a new cache unless none exists and we
1163 // want to manipulate it.
1170 }
1174 }
1178 // Prevent overriding the named cache with undefined values
1181 }
1184 },
1189 }
1192 windowData :
1193 elem;
1200 // If we want to remove a specific section of the element's data
1203 // Remove the section of cache data
1206 // If we've removed all the data, remove the element's cache
1209 }
1210 }
1212 // Otherwise, we want to remove all of the element's data
1220 // Completely remove the data cache
1224 // Remove all fields from the object
1228 }
1229 }
1230 }
1231 },
1233 // A method for determining if a DOM node can handle the data expando
1240 }
1241 }
1244 }
1245 });
1262 }
1263 }
1264 }
1271 });
1272 }
1280 // Try to fetch any internally stored data first
1284 }
1288 data;
1298 });
1299 }
1300 },
1305 });
1306 }
1307 });
1310 // If nothing was found internally, try to fetch any
1311 // data from the HTML5 data-* attribute
1322 data;
1325 // Make sure we set the data so it isn't changed later
1330 }
1331 }
1334 }
1343 }
1348 // Speed up dequeue by getting out quickly if this is just a lookup
1351 }
1358 }
1361 },
1369 // If the fx queue is dequeued, always remove the progress sentinel
1372 }
1375 // Add a progress sentinel to prevent the fx queue from being
1376 // automatically dequeued
1379 }
1383 });
1384 }
1385 }
1386 });
1393 }
1397 }
1403 }
1404 });
1405 },
1409 });
1410 },
1412 // Based off of the plugin by Clint Helfers, with permission.
1413 // http://blindsignals.com/index.php/2009/07/jquery-delay/
1423 });
1424 },
1428 }
1429 });
1454 };
1459 },
1466 }
1467 });
1468 },
1475 });
1476 }
1495 }
1496 }
1498 }
1499 }
1500 }
1501 }
1504 },
1511 });
1512 }
1525 }
1530 }
1531 }
1532 }
1533 }
1536 },
1546 });
1547 }
1551 // toggle individual class names
1559 // check each className given, space seperated list
1562 }
1566 // store className if set
1568 }
1570 // toggle whole className
1571 this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1572 }
1573 });
1574 },
1581 }
1582 }
1585 },
1593 // attributes.value is undefined in Blackberry 4.7 but
1594 // uses .value. See #6932
1597 }
1599 // We need to handle select boxes special
1602 values = [],
1606 // Nothing was selected
1609 }
1611 // Loop through all the selected options
1615 // Don't return options that are disabled or in a disabled optgroup
1616 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
1619 // Get the specific value for the option
1622 // We don't need an array for one selects
1625 }
1627 // Multi-Selects return an array
1629 }
1630 }
1633 }
1635 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1638 }
1641 // Everything else, we just grab the value
1644 }
1647 }
1656 }
1660 }
1662 // Treat null/undefined as ""; convert numbers to string
1670 });
1671 }
1681 });
1685 }
1689 }
1690 });
1691 }
1692 });
1695 attrFn: {
1704 },
1707 // don't set attributes on text and comment nodes
1710 }
1714 }
1717 // Whether we are setting (or getting)
1720 // Try to normalize/fix the name
1723 // These attributes require special treatment
1726 // Safari mis-reports the default selected property of an option
1727 // Accessing the parent's selectedIndex property fixes it
1733 // Make sure that it also works with optgroups, see #5701
1736 }
1737 }
1738 }
1740 // If applicable, access the attribute via the DOM 0 way
1741 // 'in' checks fail in Blackberry 4.7 #6931
1744 // We can't allow the type property to be changed (since it causes problems in IE)
1747 }
1752 }
1756 }
1757 }
1759 // browsers index elements by id/name on forms, give priority to attributes.
1762 }
1764 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1765 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1774 }
1777 }
1782 }
1785 }
1788 // convert the value to a string (all browsers do this but IE) see #1070
1790 }
1792 // Ensure that missing attributes return undefined
1793 // Blackberry 4.7 returns "" from getAttribute #6938
1796 }
1799 // Some attributes require a special call on IE
1803 // Non-existent attributes return null, we normalize to undefined
1805 }
1806 });
1818 },
1821 /*
1822 * A number of helper functions used for managing events.
1823 * Many of the ideas behind this code originated from
1824 * Dean Edwards' addEvent library.
1825 */
1828 // Bind an event to an element
1829 // Original by Dean Edwards
1833 }
1835 // For whatever reason, IE has trouble passing the window object
1836 // around, causing it to be cloned in the process
1839 }
1844 // Fixes bug #7229. Fix recommended by jdalton
1846 }
1853 }
1855 // Make sure that the function being executed has a unique ID
1858 }
1860 // Init the element's event structure
1863 // If no elemData is found then we must be trying to bind to one of the
1864 // banned noData elements
1867 }
1869 // Use a key less likely to result in collisions for plain JS objects.
1870 // Fixes bug #7150.
1876 // On plain objects events is a fn that holds the the data
1877 // which prevents this data from being JSON serialized
1878 // the function does not need to be called, it just contains the data
1884 // On plain objects, create a fn that acts as the holder
1885 // of the values to avoid JSON serialization of event data
1887 }
1890 }
1894 // Handle the second event of a trigger and when
1895 // an event is called after a page has unloaded
1899 };
1900 }
1902 // Add elem as a property of the handle function
1903 // This is to prevent a memory leak with non-native events in IE.
1906 // Handle multiple events separated by a space
1907 // jQuery(...).bind("mouseover mouseout", fn);
1917 // Namespaced event handlers
1924 namespaces = [];
1926 }
1931 }
1933 // Get the current list of functions bound to this event
1937 // Init the event handler queue
1941 // Check for a special event handler
1942 // Only use addEventListener/attachEvent if the special
1943 // events handler returns false
1945 // Bind the global event handler to the element
1951 }
1952 }
1953 }
1960 }
1961 }
1963 // Add the function to the element's handler list
1966 // Keep track of which events have been used, for global triggering
1968 }
1970 // Nullify elem to prevent memory leaks in IE
1972 },
1974 global: {},
1976 // Detach an event or set of events from an element
1978 // don't do events on text and comment nodes
1981 }
1985 }
1987 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
1994 }
1999 }
2001 // types is actually an event object here
2005 }
2007 // Unbind all events for the element
2013 }
2016 }
2018 // Handle multiple events separated by a space
2019 // jQuery(...).unbind("mouseover mouseout", fn);
2026 namespaces = [];
2029 // Namespaced event handlers
2035 }
2041 }
2050 }
2051 }
2054 }
2062 // remove the given handler for the given type
2066 }
2070 }
2071 }
2075 }
2076 }
2077 }
2079 // remove generic event handler if no more handlers exist
2083 }
2087 }
2088 }
2090 // Remove the expando if it's no longer used
2095 }
2105 }
2106 }
2107 },
2109 // bubbling is internal
2111 // Event object or event type
2117 // jQuery.Event object
2119 // Object literal
2121 // Just the event type (string)
2127 }
2129 // Handle a global trigger
2131 // Don't bubble custom events when global (to avoid too much overhead)
2134 // Only trigger if we've ever bound an event for it
2139 }
2140 });
2141 }
2142 }
2144 // Handle triggering a single element
2146 // don't do events on text and comment nodes
2149 }
2151 // Clean up in case it is reused
2155 // Clone the incoming data, if any
2158 }
2162 // Trigger the event, it is assumed that "handle" is a function
2169 }
2173 // Trigger an inline bound script
2179 }
2180 }
2182 // prevent IE from throwing an error for some elements with some event types, see #3533
2200 // Make sure that we don't accidentally re-trigger the onFOO events
2205 }
2209 }
2211 // prevent IE from throwing an error for some elements with some event types, see #3533
2216 }
2219 }
2220 }
2221 },
2225 namespace_sort = [],
2231 // Namespaced event handlers
2239 }
2247 }
2252 // Clone the handlers to prevent manipulation
2258 // Filter the functions by class
2260 // Pass in a reference to the handler function itself
2261 // So that we can later remove it
2273 }
2274 }
2278 }
2279 }
2280 }
2281 }
2284 },
2286 props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2291 }
2293 // store a copy of the original event object
2294 // and "clone" to set read-only properties
2301 }
2303 // Fix target property, if necessary
2305 // Fixes #1925 where srcElement might not be defined either
2307 }
2309 // check if target is a textnode (safari)
2312 }
2314 // Add relatedTarget, if necessary
2316 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2317 }
2319 // Calculate pageX/Y if missing and clientX/Y available
2324 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2325 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
2326 }
2328 // Add which for key events
2331 }
2333 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2336 }
2338 // Add which for click: 1 === left; 2 === middle; 3 === right
2339 // Note: button is not normalized, so don't use it
2341 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2342 }
2345 },
2347 // Deprecated, use jQuery.guid instead
2350 // Deprecated, use jQuery.proxy instead
2353 special: {
2354 ready: {
2355 // Make sure the ready event is setup
2358 },
2360 live: {
2365 },
2369 }
2370 },
2372 beforeunload: {
2374 // We only want to do this special case on windows
2377 }
2378 },
2383 }
2384 }
2385 }
2386 }
2387 };
2393 }
2394 } :
2398 }
2399 };
2402 // Allow instantiation without the 'new' keyword
2405 }
2407 // Event object
2411 // Event type
2414 }
2416 // timeStamp is buggy for some events on Firefox(#3843)
2417 // So we won't rely on the native value
2420 // Mark it as fixed
2422 };
2426 }
2429 }
2431 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2432 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2440 }
2442 // if preventDefault exists run it on the original event
2446 // otherwise set the returnValue property of the original event to false (IE)
2449 }
2450 },
2457 }
2458 // if stopPropagation exists run it on the original event
2461 }
2462 // otherwise set the cancelBubble property of the original event to true (IE)
2464 },
2468 },
2471 isImmediatePropagationStopped: returnFalse
2472 };
2474 // Checks if an event happened on an element within another element
2475 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2477 // Check if mouse(over|out) are still within the same parent element
2480 // Firefox sometimes assigns relatedTarget a XUL element
2481 // which we cannot access the parentNode property of
2483 // Traverse up the tree
2486 }
2489 // set the correct event type
2492 // handle event if we actually just moused on to a non sub-element
2494 }
2496 // assuming we've left the element since we most likely mousedover a xul element
2498 },
2500 // In case of event delegation, we only need to rename the event.type,
2501 // liveHandler will take care of the rest.
2505 };
2507 // Create mouseenter and mouseleave events
2515 },
2518 }
2519 };
2520 });
2522 // submit delegation
2535 }
2536 });
2542 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2545 }
2546 });
2550 }
2551 },
2555 }
2556 };
2558 }
2560 // change delegation, happens here so we have bind.
2580 }
2583 },
2590 }
2595 // the current data will be also retrieved by beforeactivate
2598 }
2602 }
2608 }
2609 };
2612 filters: {
2622 }
2623 },
2625 // Change has to be called before submit
2626 // Keydown will be called before keypress, which is used in submit-event delegation
2634 }
2635 },
2637 // Beforeactivate happens also before the previous element is blurred
2638 // with this event you can't trigger a change event, but you can store
2639 // information
2643 }
2644 },
2649 }
2653 }
2656 },
2662 }
2663 };
2667 // Handle when the input is .focus()'d
2669 }
2674 }
2676 // Create "bubbling" focus and blur events
2683 }
2684 },
2688 }
2689 }
2690 };
2696 }
2697 });
2698 }
2702 // Handle object literals
2706 }
2708 }
2713 }
2726 }
2727 }
2730 };
2731 });
2735 // Handle object literals
2739 }
2744 }
2745 }
2748 },
2752 },
2760 }
2761 },
2766 });
2767 },
2776 }
2777 },
2780 // Save reference to arguments for access in closure
2784 // link all the functions, so any of them can unbind this click handler
2787 }
2790 // Figure out which function to execute
2794 // Make sure that clicks stop
2797 // and execute the function
2799 }));
2800 },
2804 }
2805 });
2812 };
2823 }
2826 }
2831 }
2842 }
2847 }
2857 }
2860 // bind live handler
2863 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
2864 }
2867 // unbind live handler
2869 }
2870 }
2873 };
2874 });
2878 elems = [],
2879 selectors = [],
2884 }
2886 // Make sure we avoid non-left-click bubbling in Firefox (#3861)
2887 if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
2889 }
2892 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
2893 }
2907 }
2908 }
2918 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) {
2922 // Those two events require additional checking
2926 }
2930 }
2931 }
2932 }
2933 }
2940 }
2953 }
2956 }
2957 }
2958 }
2961 }
2964 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
2965 }
2971 // Handle event binding
2976 }
2981 };
2985 }
2986 });
2988 // Prevent memory leaks in IE
2989 // Window isn't included so as not to unbind existing unload events
2990 // More info:
2991 // - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2996 // Try/Catch is to handle iframes being unloaded, see #4280
3000 }
3001 }
3002 });
3003 }
3006 /*!
3007 * Sizzle CSS Selector Engine - v1.0
3008 * Copyright 2009, The Dojo Foundation
3009 * Released under the MIT, BSD, and GPL Licenses.
3010 * More information: http://sizzlejs.com/
3011 */
3014 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3020 // Here we check if the JavaScript engine is using some sort of
3021 // optimization where it does not always call our comparision
3022 // function. If that is the case, discard the hasDuplicate value.
3023 // Thus far that includes Google Chrome.
3027 });
3037 }
3041 }
3046 parts = [],
3049 // Reset the position of the chunker regexp (start from head)
3062 }
3063 }
3081 }
3084 }
3085 }
3088 // Take a shortcut and set the context if the root selector is an ID
3089 // (but not if it'll be faster if the inner selector is an ID)
3097 }
3102 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3113 }
3123 }
3127 }
3130 }
3134 }
3135 }
3139 }
3143 }
3151 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3153 }
3154 }
3160 }
3161 }
3162 }
3166 }
3171 }
3174 };
3185 }
3186 }
3187 }
3188 }
3191 };
3195 };
3199 };
3206 }
3223 }
3224 }
3225 }
3226 }
3230 }
3233 };
3238 result = [],
3255 }
3258 result = [];
3259 }
3269 }
3270 }
3284 }
3289 }
3290 }
3291 }
3292 }
3297 }
3303 }
3306 }
3307 }
3308 }
3310 // Improper expression
3317 }
3318 }
3321 }
3324 };
3328 };
3333 match: {
3342 },
3344 leftMatch: {},
3346 attrMap: {
3349 },
3351 attrHandle: {
3354 }
3355 },
3357 relative: {
3365 }
3374 }
3375 }
3379 }
3380 },
3397 }
3398 }
3408 }
3409 }
3413 }
3414 }
3415 },
3426 }
3429 },
3440 }
3443 }
3444 },
3446 find: {
3450 // Check parentNode to catch when Blackberry 4.6 returns
3451 // nodes that are no longer in the document #6963
3453 }
3454 },
3464 }
3465 }
3468 }
3469 },
3473 }
3474 },
3475 preFilter: {
3481 }
3485 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
3488 }
3492 }
3493 }
3494 }
3497 },
3501 },
3505 },
3509 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3514 // calculate the numbers (first)n+(last) including if they are negative
3517 }
3519 // TODO: Move to normal caching system
3523 },
3530 }
3534 }
3537 },
3541 // If we're dealing with a complex expression, or a simple one
3550 }
3553 }
3557 }
3560 },
3566 }
3567 },
3569 filters: {
3572 },
3576 },
3580 },
3583 // Accessing this property makes selected-by-default
3584 // options in Safari work properly
3588 },
3592 },
3596 },
3600 },
3604 },
3608 },
3611 },
3615 },
3619 },
3622 },
3626 },
3630 },
3634 },
3638 },
3642 }
3643 },
3644 setFilters: {
3647 },
3651 },
3655 },
3659 },
3663 },
3667 },
3671 },
3675 }
3676 },
3677 filter: {
3686 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
3694 }
3695 }
3701 }
3702 },
3714 }
3715 }
3719 }
3727 }
3728 }
3738 }
3749 }
3750 }
3753 }
3762 }
3763 }
3764 },
3768 },
3772 },
3777 },
3809 },
3817 }
3818 }
3819 }
3820 };
3825 };
3828 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
3829 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
3830 }
3838 }
3841 };
3843 // Perform a simple check to determine if the browser is capable of
3844 // converting a NodeList to an array using builtin methods.
3845 // Also verifies that the returned array holds DOM nodes
3846 // (which is not the case in the Blackberry browser)
3850 // Provide a fallback method if it does not work
3863 }
3868 }
3869 }
3870 }
3873 };
3874 }
3883 }
3887 }
3890 };
3895 ap = [],
3896 bp = [],
3901 // The nodes are identical, we can exit early
3906 // If the nodes are siblings (or identical) we can do a quick check
3910 // If no parents were found then the nodes are disconnected
3916 }
3918 // Otherwise they're somewhere else in the tree so we need
3919 // to build up a full list of the parentNodes for comparison
3923 }
3930 }
3935 // Start walking down the tree looking for a discrepancy
3939 }
3940 }
3942 // We ended someplace up the tree so do a sibling check
3946 };
3951 }
3958 }
3961 }
3964 };
3965 }
3967 // Utility function for retreiving the text value of an array of DOM nodes
3974 // Get the text from text nodes and CDATA nodes
3978 // Traverse everything else, except comment nodes
3981 }
3982 }
3985 };
3987 // Check to see if the browser returns elements by name when
3988 // querying by getElementById (and provide a workaround)
3990 // We're going to inject a fake input element with a specified name
3997 // Inject it into the root element, check its status, and remove it quickly
4000 // The workaround has to do additional checks after a getElementById
4001 // Which slows things down for other browsers (hence the branching)
4008 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4011 [];
4012 }
4013 };
4019 };
4020 }
4024 // release memory in IE
4026 })();
4029 // Check to see if the browser returns only elements
4030 // when doing getElementsByTagName("*")
4032 // Create a fake element
4036 // Make sure no comments are found
4041 // Filter out possible comments
4048 }
4049 }
4052 }
4055 };
4056 }
4058 // Check to see if an attribute returns normalized href attributes
4066 };
4067 }
4069 // release memory in IE
4071 })();
4081 // Safari can't handle uppercase or unicode characters when
4082 // in quirks mode.
4085 }
4090 // Make sure that attribute selectors are quoted
4093 // Only use querySelectorAll on non-XML documents
4094 // (ID selectors don't work in non-HTML documents)
4101 // qSA works strangely on Element-rooted queries
4102 // We can work around this by specifying an extra ID on the root
4103 // and working up from there (Thanks to Andrew Dupont for the technique)
4104 // IE 8 doesn't work on object elements
4111 }
4120 }
4121 }
4122 }
4123 }
4126 };
4130 }
4132 // release memory in IE
4134 })();
4135 }
4139 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
4143 // This should fail with an exception
4144 // Gecko does not error, returns false instead
4149 }
4153 // Make sure that attribute selectors are quoted
4160 }
4162 }
4165 };
4166 }
4167 })();
4174 // Opera can't find a second classname (in 9.6)
4175 // Also, make sure that getElementsByClassName actually exists
4178 }
4180 // Safari caches class attributes, doesn't catch changes (in 3.2)
4185 }
4191 }
4192 };
4194 // release memory in IE
4196 })();
4211 }
4216 }
4221 }
4224 }
4227 }
4228 }
4229 }
4244 }
4250 }
4256 }
4261 }
4262 }
4265 }
4268 }
4269 }
4270 }
4275 };
4280 };
4285 };
4286 }
4289 // documentElement is verified for cases where it doesn't yet exist
4290 // (such as loading iframes in IE - #4833)
4294 };
4298 tmpSet = [],
4302 // Position selectors must be done after the filter
4303 // And so must :not(positional) so we move all PSEUDOs to the end
4307 }
4313 }
4316 };
4318 // EXPOSE
4328 })();
4333 // Note: This RegExp should be improved, or likely pulled from Sizzle
4334 rmultiselector = /,/,
4349 // Make sure that the results are unique
4355 }
4356 }
4357 }
4358 }
4359 }
4362 },
4370 }
4371 }
4372 });
4373 },
4377 },
4381 },
4385 },
4392 matches = {},
4402 selector;
4403 }
4404 }
4412 }
4413 }
4416 level++;
4417 }
4418 }
4421 }
4438 }
4439 }
4440 }
4441 }
4446 },
4448 // Determine the position of an element within
4449 // the matched set of elements
4453 // If it receives a string, the selector is used
4454 // If it receives nothing, the siblings are used
4456 }
4457 // Locate the position of the desired element
4459 // If it receives a jQuery object, the first element is used
4461 },
4470 all :
4472 },
4476 }
4477 });
4479 // A painfully simple check to see if an element is disconnected
4480 // from a document (should be improved, where feasible).
4483 }
4489 },
4492 },
4495 },
4498 },
4501 },
4504 },
4507 },
4510 },
4513 },
4516 },
4519 },
4524 }
4531 }
4535 }
4541 }
4544 };
4545 });
4551 }
4556 },
4562 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
4565 }
4567 }
4569 },
4578 }
4579 }
4582 },
4590 }
4591 }
4594 }
4595 });
4597 // Implement the identical functionality for filter and not
4603 });
4608 });
4613 });
4619 }
4620 }
4624 });
4625 }
4637 // checked="checked" or checked (html5)
4640 wrapMap = {
4649 };
4655 // IE can't serialize <link> and <script> tags normally
4658 }
4667 });
4668 }
4671 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4672 }
4675 },
4681 });
4682 }
4685 // The elements to wrap the target around
4690 }
4697 }
4701 }
4704 },
4710 });
4711 }
4722 }
4723 });
4724 },
4729 });
4730 },
4736 }
4738 },
4744 }
4745 });
4746 },
4752 }
4753 });
4754 },
4760 });
4765 }
4766 },
4772 });
4777 }
4778 },
4780 // keepData is for internal use only--do not document
4787 }
4791 }
4792 }
4793 }
4796 },
4800 // Remove element nodes and prevent memory leaks
4803 }
4805 // Remove any remaining nodes
4808 }
4809 }
4812 },
4815 // Do the clone
4818 // IE copies events bound via attachEvent when
4819 // using cloneNode. Calling detachEvent on the
4820 // clone will also remove the events from the orignal
4821 // In order to get around this, we use innerHTML.
4822 // Unfortunately, this means some modifications to
4823 // attributes in IE that are actually only stored
4824 // as properties will not be copied (such as the
4825 // the name attribute on an input).
4833 }
4836 // Handle the case in IE 8 where action=/test/> self-closes a tag
4841 }
4842 });
4844 // Copy the events from the original to the clone
4848 }
4850 // Return the cloned set
4852 },
4860 // See if we can take a shortcut and just use innerHTML
4869 // Remove element nodes and prevent memory leaks
4873 }
4874 }
4876 // If using innerHTML throws an exception, use the fallback method
4879 }
4886 });
4890 }
4893 },
4897 // Make sure that the elements are removed from the DOM before they are inserted
4898 // this can help fix replacing a parent with child elements
4903 });
4904 }
4908 }
4920 }
4921 });
4923 return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4924 }
4925 },
4929 },
4934 scripts = [];
4936 // We can't cloneNode fragments that contain checked, in WebKit
4937 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4940 });
4941 }
4948 });
4949 }
4954 // If we're in a fragment, just use that instead of building a new one
4955 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
4960 }
4968 }
4975 table ?
4980 fragment
4981 );
4982 }
4983 }
4987 }
4988 }
4991 }
4992 });
4998 elem;
4999 }
5007 }
5020 }
5021 }
5022 }
5023 });
5024 }
5030 // Only cache "small" (1/2 KB) strings that are associated with the main document
5031 // Cloning options loses the selected state, so don't cache them
5032 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5033 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5034 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5042 }
5043 }
5044 }
5049 }
5053 }
5056 };
5072 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5081 }
5084 }
5085 };
5086 });
5092 // !context.createElement fails in IE with an error but returns typeof 'object'
5095 }
5102 }
5106 }
5108 // Convert html string into DOM nodes
5113 // Fix "XHTML"-style tags in all browsers
5116 // Trim whitespace, otherwise indexOf won't work as expected
5122 // Go to html and back, then peel off extra wrappers
5125 // Move to the right depth
5128 }
5130 // Remove IE's autoinserted <tbody> from table fragments
5133 // String was a <table>, *may* have spurious <tbody>
5138 // String was a bare <thead> or <tfoot>
5141 [];
5146 }
5147 }
5149 }
5151 // IE completely kills leading whitespace when innerHTML is used
5153 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
5154 }
5157 }
5163 }
5164 }
5168 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
5173 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
5174 }
5176 }
5177 }
5178 }
5181 },
5191 }
5205 }
5206 }
5207 }
5214 }
5217 }
5218 }
5219 }
5220 });
5228 });
5231 }
5235 }
5236 }
5251 curCSS,
5253 getComputedStyle,
5254 currentStyle,
5258 };
5261 // Setting 'undefined' is a no-op
5264 }
5270 });
5271 };
5274 // Add in style property hooks for overriding the default
5275 // behavior of getting and setting a style property
5276 cssHooks: {
5277 opacity: {
5280 // We should always get a number back from opacity
5286 }
5287 }
5288 }
5289 },
5291 // Exclude the following css properties to add px
5292 cssNumber: {
5298 },
5300 // Add in properties whose names you wish to fix before
5301 // setting or getting the value
5302 cssProps: {
5303 // normalize float css property
5305 },
5307 // Get and set the style property on a DOM Node
5309 // Don't set styles on text and comment nodes
5312 }
5314 // Make sure that we're working with the right name
5320 // Check if we're setting a value
5322 // Make sure that NaN and null values aren't set. See: #7116
5325 }
5327 // If a number was passed in, add 'px' to the (except for certain CSS properties)
5330 }
5332 // If a hook was provided, use that value, otherwise just set the specified value
5334 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
5335 // Fixes bug #5509
5339 }
5342 // If a hook was provided get the non-computed value from there
5345 }
5347 // Otherwise just get the value from the style object
5349 }
5350 },
5353 // Make sure that we're working with the right name
5359 // If a hook was provided get the computed value from there
5363 // Otherwise, if a way to get the computed value exists, use that
5366 }
5367 },
5369 // A method for quickly swapping in/out CSS properties to get correct calculations
5373 // Remember the old values, and insert the new ones
5377 }
5381 // Revert the old values
5384 }
5385 },
5389 }
5390 });
5392 // DEPRECATED, Use jQuery.css() instead
5407 });
5408 }
5415 }
5418 // Should return "auto" instead of 0, use 0 for
5419 // temporary backwards-compat
5421 }
5422 }
5427 // Should return "auto" instead of 0, use 0 for
5428 // temporary backwards-compat
5430 }
5433 }
5434 },
5438 // ignore negative width and height values #1599
5443 }
5447 }
5448 }
5449 };
5450 });
5455 // IE uses filters for opacity
5456 return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
5459 },
5464 // IE has trouble with opacity if it does not have layout
5465 // Force it by setting the zoom level
5468 // Set the alpha filter to set the opacity
5477 }
5478 };
5479 }
5489 }
5495 }
5496 }
5499 };
5500 }
5508 // From the awesome hack by Dean Edwards
5509 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
5511 // If we're not dealing with a regular pixel number
5512 // but a number that has a weird ending, we need to convert it to pixels
5514 // Remember the original values
5518 // Put in the new values to get a computed value out
5523 // Revert the changed values
5526 }
5529 };
5530 }
5540 }
5545 }
5552 }
5553 });
5556 }
5563 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
5564 };
5568 };
5569 }
5577 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
5587 // Keep a copy of the old load method
5595 // Don't do a request if no elements are being requested
5598 }
5604 }
5606 // Default to a GET request
5609 // If the second parameter was provided
5611 // If it's a function
5613 // We assume that it's the callback
5617 // Otherwise, build a param string
5621 }
5622 }
5626 // Request the remote document
5633 // If successful, inject the HTML into all the matched elements
5635 // See if a selector was specified
5637 // Create a dummy div to hold the results
5639 // inject the contents of the document in, removing the scripts
5640 // to avoid any 'Permission Denied' errors in IE
5643 // Locate the specified elements
5646 // If not, just inject the full result
5648 }
5652 }
5653 }
5654 });
5657 },
5661 },
5666 })
5671 })
5680 }) :
5683 }
5684 });
5686 // Attach a bunch of functions for handling common AJAX events
5687 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
5690 };
5691 });
5695 // shift arguments if data argument was omited
5700 }
5707 dataType: type
5708 });
5709 },
5713 },
5717 },
5720 // shift arguments if data argument was omited
5724 data = {};
5725 }
5732 dataType: type
5733 });
5734 },
5738 },
5740 ajaxSettings: {
5747 /*
5748 timeout: 0,
5749 data: null,
5750 username: null,
5751 password: null,
5752 traditional: false,
5753 */
5754 // This function can be overriden by calling jQuery.ajaxSetup
5757 },
5758 accepts: {
5765 }
5766 },
5774 // Use original (not extended) context object if it was provided
5777 // convert data if not already a string
5780 }
5782 // Handle JSONP Parameter Callbacks
5787 }
5790 }
5792 }
5794 // Build temporary JSONP function
5798 // Replace the =? sequence both in the query string and the data
5801 }
5805 // We need to make sure
5806 // that a JSONP style response is executed properly
5809 // Handle JSONP-style loading
5817 // Garbage collect
5823 }
5831 }
5832 };
5833 }
5837 }
5842 // try replacing _= if it is there
5845 // if nothing was replaced, add timestamp to the end
5847 }
5849 // If data is available, append data to url for GET/HEAD requests
5852 }
5854 // Watch for a new set of requests
5857 }
5859 // Matches an absolute URL, and saves the domain
5861 remote = parts && (parts[1] && parts[1].toLowerCase() !== location.protocol || parts[2].toLowerCase() !== location.host);
5863 // If we're requesting a remote document
5864 // and trying to load JSON or Script with a GET
5870 }
5873 // Handle Script loading
5877 // Attach handlers for all browsers
5885 // Handle memory leak in IE
5889 }
5890 }
5891 };
5892 }
5894 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
5895 // This arises when a base node is used (#2709 and #4378).
5898 // We handle everything using the script element injection
5900 }
5904 // Create the request object
5909 }
5911 // Open the socket
5912 // Passing null username, generates a login popup on Opera (#2865)
5917 }
5919 // Need an extra try/catch for cross domain requests in Firefox 3
5921 // Set content-type if data specified and content-body is valid for this type
5924 }
5926 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
5930 }
5934 }
5935 }
5937 // Set header so the called script knows that it's an XMLHttpRequest
5938 // Only send the header if it's not a remote XHR
5941 }
5943 // Set the Accepts header for the server, depending on the dataType
5949 // Allow custom headers/mimetypes and early abort
5951 // Handle the global AJAX counter
5954 }
5956 // close opended socket
5959 }
5963 }
5965 // Wait for a response to come back
5967 // The request was aborted
5969 // Opera doesn't call onreadystatechange before this point
5970 // so we simulate the call
5973 }
5978 }
5980 // The transfer is complete and the data is available, or the request timed out
5996 // Watch for, and catch, XML document parse errors
5998 // process the data (runs the xml through httpData regardless of callback)
6003 }
6004 }
6006 // Make sure that the request was successful or notmodified
6008 // JSONP handles its own success callback
6011 }
6014 }
6016 // Fire the complete handlers
6019 }
6023 }
6025 // Stop memory leaks
6028 }
6029 }
6030 };
6032 // Override the abort handler, if we can (IE 6 doesn't allow it, but that's OK)
6033 // Opera doesn't fire onreadystatechange at all on abort
6038 // oldAbort has no call property in IE7 so
6039 // just do it this way, which works in all
6040 // browsers
6042 }
6045 };
6048 // Timeout checker
6051 // Check to see if the request is still happening
6054 }
6056 }
6058 // Send the data
6065 // Fire the complete handlers
6067 }
6069 // firefox 1.5 doesn't fire statechange for sync requests
6072 }
6074 // return XMLHttpRequest to allow aborting the request etc.
6076 },
6078 // Serialize an array of form elements or a set of
6079 // key/values into a query string
6083 // If value is a function, invoke it and return its value
6086 };
6088 // Set traditional to true for jQuery <= 1.3.2 behavior.
6091 }
6093 // If an array was passed in, assume that it is an array of form elements.
6095 // Serialize the form elements
6098 });
6101 // If traditional, encode the "old" way (the way 1.3.2 or older
6102 // did it), otherwise encode params recursively.
6105 }
6106 }
6108 // Return the resulting serialization
6110 }
6111 });
6115 // Serialize array item.
6118 // Treat each array item as a scalar.
6122 // If array item is non-scalar (array or object), encode its
6123 // numeric index to resolve deserialization ambiguity issues.
6124 // Note that rack (as of 1.0.0) can't currently deserialize
6125 // nested arrays properly, and attempting to do so may cause
6126 // a server error. Possible fixes are to modify rack's
6127 // deserialization algorithm or to provide an option or flag
6128 // to force array serialization to be shallow.
6129 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
6130 }
6131 });
6137 // Serialize object item.
6141 });
6142 }
6145 // Serialize scalar item.
6147 }
6148 }
6150 // This is still on the jQuery object... for now
6151 // Want to move this to jQuery.ajax some day
6154 // Counter for holding the number of active queries
6157 // Last-Modified header cache for next request
6158 lastModified: {},
6159 etag: {},
6162 // If a local callback was specified, fire it
6165 }
6167 // Fire the global callback
6170 }
6171 },
6174 // If a local callback was specified, fire it and pass it the data
6177 }
6179 // Fire the global callback
6182 }
6183 },
6186 // Process result
6189 }
6191 // The request was completed
6194 }
6196 // Handle the global AJAX counter
6199 }
6200 },
6204 },
6206 // Determines if an XMLHttpRequest was successful or not
6209 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
6216 },
6218 // Determines if an XMLHttpRequest returns NotModified
6225 }
6229 }
6232 },
6241 }
6243 // Allow a pre-filtering function to sanitize the response
6244 // s is checked to keep backwards compatibility
6247 }
6249 // The filter can actually parse the response
6251 // Get the JavaScript object, if JSON is used.
6255 // If the type is "script", eval it in global context
6258 }
6259 }
6262 }
6264 });
6266 /*
6267 * Create the request object; Microsoft failed to properly
6268 * implement the XMLHttpRequest in IE7 (can't request local files),
6269 * so we use the ActiveXObject when it is available
6270 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
6271 * we need a fallback.
6272 */
6279 }
6284 };
6285 }
6287 // Does this browser support XHR requests?
6296 timerId,
6297 fxAttrs = [
6298 // height animations
6300 // width animations
6302 // opacity animations
6304 ];
6318 // Reset the inline display of this element to learn if it is
6319 // being hidden by cascaded rules or not
6322 }
6324 // Set elements which have been overridden with display: none
6325 // in a stylesheet to whatever the default browser style is
6326 // for such an element
6329 }
6330 }
6332 // Set the display of most of the elements in a second loop
6333 // to avoid the constant reflow
6340 }
6341 }
6344 }
6345 },
6357 }
6358 }
6360 // Set the display of the elements in a second loop
6361 // to avoid the constant reflow
6364 }
6367 }
6368 },
6370 // Save the old toggle function
6383 });
6387 }
6390 },
6395 },
6402 }
6405 // XXX 'this' does not always have a nodeName when running the
6406 // test suite
6420 }
6424 }
6427 // Make sure that nothing sneaks out
6428 // Record all 3 overflow attributes because IE does not
6429 // change the overflow attribute when overflowX and
6430 // overflowY are set to the same value
6433 // Set display property to inline-block for height/width
6434 // animations on inline elements that are having width/height
6435 // animated
6444 // inline-level elements accept inline-block;
6445 // block-level elements need to be inline with layout
6452 }
6453 }
6454 }
6455 }
6458 // Create (if needed) and add to specialEasing
6461 }
6462 }
6466 }
6484 // We need to compute starting value
6489 }
6491 // If a +=/-= token was provided, we're doing a relative animation
6494 }
6500 }
6501 }
6502 });
6504 // For JS strict compliance
6506 });
6507 },
6514 }
6517 // go in reverse order so anything added to the queue during the loop is ignored
6521 // force the next step to be the last
6523 }
6526 }
6527 }
6528 });
6530 // start the next in the queue if the last step wasn't forced
6533 }
6536 }
6538 });
6545 });
6548 }
6550 // Generate shortcuts for custom animations
6561 };
6562 });
6571 };
6576 // Queueing
6581 }
6584 }
6585 };
6588 },
6590 easing: {
6593 },
6596 }
6597 },
6599 timers: [],
6608 }
6609 }
6611 });
6614 // Simple function for setting a style value
6618 }
6621 },
6623 // Get the current size
6625 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
6627 }
6631 },
6633 // Start an animation from one number to another
6647 }
6653 }
6654 },
6656 // Simple 'show' function
6658 // Remember where we started, so that we can go back to it later
6662 // Begin the animation
6663 // Make sure that we start at a small width/height to avoid any
6664 // flash of content
6667 // Start by showing the element
6669 },
6671 // Simple 'hide' function
6673 // Remember where we started, so that we can go back to it later
6677 // Begin the animation
6679 },
6681 // Each step of an animation
6695 }
6696 }
6699 // Reset the overflow
6706 } );
6707 }
6709 // Hide the element if the "hide" operation was done
6712 }
6714 // Reset the properties, if the item has been hidden or shown
6718 }
6719 }
6721 // Execute the complete function
6723 }
6731 // Perform the easing function, defaults to swing
6734 this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
6737 // Perform the next step of the animation
6739 }
6742 }
6743 };
6752 }
6753 }
6757 }
6758 },
6765 },
6767 speeds: {
6770 // Default speed
6772 },
6774 step: {
6777 },
6781 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
6784 }
6785 }
6786 }
6787 });
6794 };
6795 }
6806 }
6809 }
6812 }
6827 });
6828 }
6832 }
6836 }
6845 // Make sure we're not dealing with a disconnected DOM node
6848 }
6854 scrollTop = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop ),
6855 scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft),
6860 };
6869 });
6870 }
6874 }
6878 }
6889 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
6896 }
6906 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
6909 }
6913 }
6915 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
6918 }
6921 }
6926 }
6931 }
6934 };
6935 }
6939 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
6940 html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
6942 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
6956 // safari subtracts parent border width here which is 5px
6970 },
6981 }
6984 },
6989 // set position first, in-case top/left are set even on static elem
6992 }
6998 calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1),
7001 // need to be able to calculate position if either top or left is auto and position is absolute
7004 }
7011 }
7015 }
7018 }
7024 }
7025 }
7026 };
7033 }
7037 // Get *real* offsetParent
7040 // Get correct offsets
7042 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
7044 // Subtract element margins
7045 // note: when an element has margin: auto the offsetLeft and marginLeft
7046 // are the same in Safari causing offset.left to incorrectly be 0
7050 // Add offsetParent borders
7054 // Subtract the two offsets
7058 };
7059 },
7064 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
7066 }
7068 });
7069 }
7070 });
7073 // Create scrollLeft and scrollTop methods
7082 }
7085 // Set the scroll offset
7093 );
7097 }
7098 });
7102 // Return the scroll offset
7107 }
7108 };
7109 });
7113 elem :
7117 }
7122 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
7127 // innerHeight and innerWidth
7132 };
7134 // outerHeight and outerWidth
7139 };
7142 // Get window width or height
7146 }
7152 });
7153 }
7156 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
7157 return elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
7160 // Get document width or height
7162 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
7167 );
7169 // Get or set width or height on the element
7176 // Set the width or height on the element (default to pixels if value is unitless)
7179 }
7180 };
7182 });