| blob | d4f3bb38cdab24303efed50e482aecc949fcdb53 |
1 /*!
2 * jQuery JavaScript Library v1.8.2
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2012 jQuery Foundation and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time)
13 */
15 var
16 // A central reference to the root jQuery(document)
17 rootjQuery,
19 // The deferred used on DOM ready
20 readyList,
22 // Use the correct document accordingly with window argument (sandbox)
27 // Map over jQuery in case of overwrite
30 // Map over the $ in case of overwrite
33 // Save a reference to some core methods
41 // Define a local copy of jQuery
43 // The jQuery object is actually just the init constructor 'enhanced'
45 },
47 // Used for matching numbers
50 // Used for detecting and trimming whitespace
54 // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
57 // A simple way to check for HTML strings
58 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
61 // Match a standalone tag
64 // JSON RegExp
70 // Matches dashed string for camelizing
74 // Used by jQuery.camelCase as callback to replace()
77 },
79 // The ready event handler and self cleanup method
85 // we're here because readyState === "complete" in oldIE
86 // which is good enough for us to call the dom ready!
89 }
90 },
92 // [[Class]] -> type pairs
93 class2type = {};
100 // Handle $(""), $(null), $(undefined), $(false)
103 }
105 // Handle $(DOMElement)
110 }
112 // Handle HTML strings
114 if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
115 // Assume that strings that start and end with <> are HTML and skip the regex check
120 }
122 // Match html or make sure no context is specified for #id
125 // HANDLE: $(html) -> $(array)
130 // scripts is true for back-compat
134 }
138 // HANDLE: $(#id)
142 // Check parentNode to catch when Blackberry 4.6 returns
143 // nodes that are no longer in the document #6963
145 // Handle the case where IE and Opera return items
146 // by name instead of ID
149 }
151 // Otherwise, we inject the element directly into the jQuery object
154 }
159 }
161 // HANDLE: $(expr, $(...))
165 // HANDLE: $(expr, context)
166 // (which is just equivalent to: $(context).find(expr)
169 }
171 // HANDLE: $(function)
172 // Shortcut for document ready
175 }
180 }
183 },
185 // Start with an empty selector
188 // The current version of jQuery being used
191 // The default length of a jQuery object is 0
194 // The number of elements contained in the matched element set
197 },
201 },
203 // Get the Nth element in the matched element set OR
204 // Get the whole matched element set as a clean array
208 // Return a 'clean' array
211 // Return just the object
213 },
215 // Take an array of elements and push it onto the stack
216 // (returning the new matched element set)
219 // Build a new jQuery matched element set
222 // Add the old object onto the stack (as a reference)
231 }
233 // Return the newly-formed element set
235 },
237 // Execute a callback for every element in the matched set.
238 // (You can seed the arguments with an array of args, but this is
239 // only used internally.)
242 },
245 // Add the callback
249 },
256 },
260 },
264 },
269 },
274 }));
275 },
279 },
281 // For internal use only.
282 // Behaves like an Array's method, not like a jQuery method.
285 splice: [].splice
286 };
288 // Give the init function the jQuery prototype for later instantiation
298 // Handle a deep copy situation
302 // skip the boolean and the target
304 }
306 // Handle case when target is a string or something (possible in deep copy)
308 target = {};
309 }
311 // extend jQuery itself if only one argument is passed
315 }
318 // Only deal with non-null/undefined values
320 // Extend the base object
325 // Prevent never-ending loop
328 }
330 // Recurse if we're merging plain objects or arrays
338 }
340 // Never move original objects, clone them
343 // Don't bring in undefined values
346 }
347 }
348 }
349 }
351 // Return the modified object
353 };
359 }
363 }
366 },
368 // Is the DOM ready to be used? Set to true once it occurs.
371 // A counter to track how many items to wait for before
372 // the ready event fires. See #6781
375 // Hold (or release) the ready event
381 }
382 },
384 // Handle when the DOM is ready
387 // Abort if there are pending holds or we're already ready
390 }
392 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
395 }
397 // Remember that the DOM is ready
400 // If a normal DOM Ready event fired, decrement, and wait if need be
403 }
405 // If there are functions bound, to execute
408 // Trigger any bound ready events
411 }
412 },
414 // See test/unit/core.js for details concerning isFunction.
415 // Since version 1.3, DOM methods and functions like alert
416 // aren't supported. They return false on IE (#2968).
419 },
423 },
427 },
431 },
437 },
440 // Must be an Object.
441 // Because of IE, we also have to check the presence of the constructor property.
442 // Make sure that DOM nodes and window objects don't pass through, as well
445 }
448 // Not own constructor property must be Object
453 }
455 // IE8,9 Will throw exceptions on certain host objects #9897
457 }
459 // Own properties are enumerated firstly, so to speed up,
460 // if last one is own, then all properties are own.
466 },
472 }
474 },
478 },
480 // data: string of html
481 // context (optional): If specified, the fragment will be created in this context, defaults to document
482 // scripts (optional): If true, will include scripts passed in the html string
487 }
491 }
494 // Single tag
497 }
502 },
507 }
509 // Make sure leading/trailing whitespace is removed (IE can't handle it)
512 // Attempt to parse using the native JSON parser first
515 }
517 // Make sure the incoming data is actual JSON
518 // Logic borrowed from http://json.org/json2.js
525 }
527 },
529 // Cross-browser xml parsing
534 }
543 }
546 }
549 }
551 },
555 // Evaluates a script in a global context
556 // Workarounds based on findings by Jim Driscoll
557 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
560 // We use execScript on Internet Explorer
561 // We use an anonymous function so that context is window
562 // rather than jQuery in Firefox
566 }
567 },
569 // Convert dashed to camelCase; used by the css and data modules
570 // Microsoft forgot to hump their vendor prefix (#9572)
573 },
577 },
579 // args is for internal usage only
591 }
592 }
597 }
598 }
599 }
601 // A special, fast, case for the most common use of each
607 }
608 }
613 }
614 }
615 }
616 }
619 },
621 // Use native String.trim function wherever possible
627 } :
629 // Otherwise use our own trimming functionality
634 },
636 // results is for internal usage only
642 // The window, strings (and functions) also have 'length'
643 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
646 if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
650 }
651 }
654 },
662 }
668 // Skip accessing in sparse arrays
671 }
672 }
673 }
676 },
686 }
691 }
692 }
697 },
701 ret = [],
706 // Go through the array, only saving the items
707 // that pass the validator function
712 }
713 }
716 },
718 // arg is for internal usage only
721 ret = [],
724 // jquery objects are treated as arrays
725 isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
727 // Go through the array, translating each of the items to their
734 }
735 }
737 // Go through every key on the object,
744 }
745 }
746 }
748 // Flatten any nested arrays
750 },
752 // A global GUID counter for objects
755 // Bind a function to a context, optionally partially applying any
756 // arguments.
764 }
766 // Quick check to determine if target is callable, in the spec
767 // this throws a TypeError, but we will just return undefined.
770 }
772 // Simulated bind
776 };
778 // Set the guid of unique handler to the same of original handler, so it can be removed
782 },
784 // Multifunctional method to get and set values of a collection
785 // The value/s can optionally be executed if it's a function
792 // Sets many values
796 }
799 // Sets one value
801 // Optionally, function values get executed if exec is true
805 // Bulk operations only iterate when executing function values
810 };
812 // Otherwise they run against the entire set
816 }
817 }
822 }
823 }
826 }
829 elems :
831 // Gets
832 bulk ?
835 },
839 }
840 });
847 // Catch cases where $(document).ready() is called after the browser event has already occurred.
848 // we once tried to use readyState "interactive" here, but it caused issues like the one
849 // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
851 // Handle it asynchronously to allow scripts the opportunity to delay ready
854 // Standards-based browsers support DOMContentLoaded
856 // Use the handy event callback
859 // A fallback to window.onload, that will always work
862 // If IE event model is used
864 // Ensure firing before onload, maybe late but safe also for iframes
867 // A fallback to window.onload, that will always work
870 // If IE and not a frame
871 // continually check to see if the document is ready
883 // Use the trick by Diego Perini
884 // http://javascript.nwbox.com/IEContentLoaded/
888 }
890 // and execute any waiting functions
892 }
893 })();
894 }
895 }
896 }
898 };
900 // Populate the class2type map
901 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
903 });
905 // All jQuery objects should point back to these
907 // String to Object options format cache
910 // Convert String-formatted options into Object-formatted ones and store in cache
915 });
917 }
919 /*
920 * Create a callback list using the following parameters:
921 *
922 * options: an optional list of space-separated options that will change how
923 * the callback list behaves or a more traditional option object
924 *
925 * By default a callback list will act like an event callback list and can be
926 * "fired" multiple times.
927 *
928 * Possible options:
929 *
930 * once: will ensure the callback list can only be fired once (like a Deferred)
931 *
932 * memory: will keep track of previous values and will call any callback added
933 * after the list has been fired right away with the latest "memorized"
934 * values (like a Deferred)
935 *
936 * unique: will ensure a callback can only be added once (no duplicate in the list)
937 *
938 * stopOnFalse: interrupt callings when a callback returns false
939 *
940 */
943 // Convert options from String-formatted to Object-formatted if needed
944 // (we check in cache first)
950 memory,
951 // Flag to know if list was already fired
952 fired,
953 // Flag to know if list is currently firing
954 firing,
955 // First callback to fire (used internally by add and fireWith)
956 firingStart,
957 // End of the loop when firing
958 firingLength,
959 // Index of currently firing callback (modified by remove if needed)
960 firingIndex,
961 // Actual callback list
962 list = [],
963 // Stack of fire calls for repeatable lists
965 // Fire callbacks
977 }
978 }
984 }
986 list = [];
989 }
990 }
991 },
992 // Actual Callbacks object
993 self = {
994 // Add a callback or a collection of callbacks to the list
997 // First, we save the current length
1005 // Inspect recursively
1007 }
1008 });
1010 // Do we need to add the callbacks to the
1011 // current firing batch?
1014 // With memory, if we're not firing then
1015 // we should call right away
1019 }
1020 }
1022 },
1023 // Remove a callback from the list
1030 // Handle firing indexes
1033 firingLength--;
1034 }
1036 firingIndex--;
1037 }
1038 }
1039 }
1040 });
1041 }
1043 },
1044 // Control if a given callback is in the list
1047 },
1048 // Remove all callbacks from the list
1050 list = [];
1052 },
1053 // Have the list do nothing anymore
1057 },
1058 // Is it disabled?
1061 },
1062 // Lock the list in its current state
1067 }
1069 },
1070 // Is it locked?
1073 },
1074 // Call all callbacks with the given context and arguments
1083 }
1084 }
1086 },
1087 // Call all the callbacks with the given arguments
1091 },
1092 // To know if the callbacks have already been called at least once
1095 }
1096 };
1099 };
1104 // action, add listener, listener list, final state
1108 ],
1110 promise = {
1113 },
1117 },
1124 // deferred[ done | fail | progress ] for forwarding actions to newDefer
1135 }
1136 } :
1138 );
1139 });
1142 },
1143 // Get a promise for this deferred
1144 // If obj is provided, the promise aspect is added to the object
1147 }
1148 },
1149 deferred = {};
1151 // Keep pipe for back-compat
1154 // Add list-specific methods
1159 // promise[ done | fail | progress ] = list.add
1162 // Handle state
1165 // state = [ resolved | rejected ]
1168 // [ reject_list | resolve_list ].disable; progress_list.lock
1170 }
1172 // deferred[ resolve | reject | notify ] = list.fire
1175 });
1177 // Make the deferred a promise
1180 // Call given func if any
1183 }
1185 // All done!
1187 },
1189 // Deferred helper
1195 // the count of uncompleted subordinates
1196 remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
1198 // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
1201 // Update function for both resolve and progress values
1210 }
1211 };
1212 },
1216 // add listeners to Deferred subordinates; treat others as resolved
1229 }
1230 }
1231 }
1233 // if we're not waiting on anything, resolve the master
1236 }
1239 }
1240 });
1244 all,
1245 a,
1246 select,
1247 opt,
1248 input,
1249 fragment,
1250 eventName,
1251 i,
1252 isSupported,
1253 clickFn,
1256 // Preliminary tests
1264 // Can't get basic test support
1267 }
1269 // First batch of supports tests
1274 support = {
1275 // IE strips leading whitespace when .innerHTML is used
1278 // Make sure that tbody elements aren't automatically inserted
1279 // IE will insert them into empty tables
1282 // Make sure that link elements get serialized correctly by innerHTML
1283 // This requires a wrapper element in IE
1286 // Get the style information from getAttribute
1287 // (IE uses .cssText instead)
1290 // Make sure that URLs aren't manipulated
1291 // (IE normalizes it by default)
1294 // Make sure that element opacity exists
1295 // (IE uses filter instead)
1296 // Use a regex to work around a WebKit issue. See #5145
1299 // Verify style float existence
1300 // (IE uses styleFloat instead of cssFloat)
1303 // Make sure that if no value is specified for a checkbox
1304 // that it defaults to "on".
1305 // (WebKit defaults to "" instead)
1308 // Make sure that a selected-by-default option has a working selected property.
1309 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1312 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1315 // Tests for enctype support on a form(#6743)
1318 // Makes sure cloning an html5 element does not cause problems
1319 // Where outerHTML is undefined, this still works
1322 // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
1325 // Will be defined later
1336 };
1338 // Make sure checked status is properly cloned
1342 // Make sure that the options inside disabled selects aren't marked as disabled
1343 // (WebKit marks them as disabled)
1347 // Test to see if it's possible to delete an expando from an element
1348 // Fails in Internet Explorer
1353 }
1357 // Cloning a node shouldn't copy over any
1358 // bound event handlers (IE does this)
1360 });
1363 }
1365 // Check if a radio maintains its value
1366 // after being appended to the DOM
1374 // #11217 - WebKit loses check when the name is after the checked attribute
1381 // WebKit doesn't clone checked state correctly in fragments
1384 // Check if a disconnected checkbox will retain its checked
1385 // value of true after appended to the DOM (IE6/7)
1391 // Technique from Juriy Zaytsev
1392 // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1393 // We only care about the case where non-standard event systems
1394 // are used, namely in IE. Short-circuiting here helps us to
1395 // avoid an eval call (in setAttribute) which can cause CSP
1396 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1402 }) {
1408 }
1410 }
1411 }
1413 // Run tests that need a body at doc ready
1420 // Return for frameset docs that don't have a body
1422 }
1425 container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
1428 // Construct the test element
1432 // Check if table cells still have offsetWidth/Height when they are set
1433 // to display:none and there are still other visible table cells in a
1434 // table row; if so, offsetWidth/Height are not reliable for use when
1435 // determining if an element has been hidden directly using
1436 // display:none (it is still safe to use offsets if a parent element is
1437 // hidden; don safety goggles and see bug #4512 for more information).
1438 // (only IE 8 fails this test)
1447 // Check if empty table cells still have offsetWidth/Height
1448 // (IE <= 8 fail this test)
1451 // Check box-sizing and margin behavior
1453 div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
1457 // NOTE: To any future maintainer, we've window.getComputedStyle
1458 // because jsdom on node.js will break without it.
1461 support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
1463 // Check if div with explicit width and no margin-right incorrectly
1464 // gets computed margin-right based on width of container. For more
1465 // info see bug #3333
1466 // Fails in WebKit before Feb 2011 nightlies
1467 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1475 }
1478 // Check if natively block-level elements act like inline-block
1479 // elements when setting their display to 'inline' and giving
1480 // them layout
1481 // (IE < 8 does this)
1486 // Check if elements with layout shrink-wrap their children
1487 // (IE 6 does this)
1495 }
1497 // Null elements to avoid leaks in IE
1500 });
1502 // Null elements to avoid leaks in IE
1507 })();
1512 cache: {},
1514 deletedIds: [],
1516 // Remove at next major release (1.9/2.0)
1519 // Unique for each copy of jQuery on the page
1520 // Non-digits removed to match rinlinejQuery
1523 // The following elements throw uncatchable exceptions if you
1524 // attempt to add expando properties to them.
1525 noData: {
1527 // Ban all objects except for Flash (which handle expandos)
1530 },
1535 },
1540 }
1546 // We have to handle DOM nodes and JS objects differently because IE6-7
1547 // can't GC object references properly across the DOM-JS boundary
1550 // Only DOM nodes need the global jQuery cache; JS object data is
1551 // attached directly to the object so GC can occur automatically
1554 // Only defining an ID for JS objects if its cache already exists allows
1555 // the code to shortcut on the same path as a DOM node with no cache
1558 // Avoid doing any more work than we need to when trying to get data on an
1559 // object that has no data at all
1562 }
1565 // Only DOM nodes need a new unique ID for each element since their data
1566 // ends up in the global cache
1571 }
1572 }
1577 // Avoids exposing jQuery metadata on plain JS objects when the object
1578 // is serialized using JSON.stringify
1581 }
1582 }
1584 // An object can be passed to jQuery.data instead of a key/value pair; this gets
1585 // shallow copied over onto the existing cache
1591 }
1592 }
1596 // jQuery data() is stored in a separate object inside the object's internal data
1597 // cache in order to avoid key collisions between internal data and user-defined
1598 // data.
1602 }
1605 }
1609 }
1611 // Check for both converted-to-camel and non-converted data property names
1612 // If a data property was specified
1615 // First Try to find as-is property data
1618 // Test for null|undefined property data
1621 // Try to find the camelCased property
1623 }
1626 }
1629 },
1634 }
1640 // See jQuery.data for more information
1644 // If there is already no cache entry for this object, there is no
1645 // purpose in continuing
1648 }
1656 // Support array or space separated string names for data keys
1659 // try the string as a key before any manipulation
1664 // split the camel cased version by spaces unless a key with the spaces exists
1670 }
1671 }
1672 }
1676 }
1678 // If there is no data left in the cache, we want to continue
1679 // and let the cache object itself get destroyed
1682 }
1683 }
1684 }
1686 // See jQuery.data for more information
1690 // Don't destroy the parent cache unless the internal data object
1691 // had been the only thing left in it
1694 }
1695 }
1697 // Destroy the cache
1701 // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
1705 // When all else fails, null
1708 }
1709 },
1711 // For internal use only.
1714 },
1716 // A method for determining if a DOM node can handle the data expando
1720 // nodes accept data unless otherwise specified; rejection can be conditional
1722 }
1723 });
1732 // Gets all values
1746 }
1747 }
1749 }
1750 }
1753 }
1755 // Sets multiple values
1759 });
1760 }
1771 // Try to fetch any internally stored data first
1775 }
1779 data;
1780 }
1789 });
1791 },
1796 });
1797 }
1798 });
1801 // If nothing was found internally, try to fetch any
1802 // data from the HTML5 data-* attribute
1814 // Only convert to a number if it doesn't change the string
1817 data;
1820 // Make sure we set the data so it isn't changed later
1825 }
1826 }
1829 }
1831 // checks a cache object for emptiness
1836 // if the public data object is empty, the private is still empty
1839 }
1842 }
1843 }
1846 }
1855 // Speed up dequeue by getting out quickly if this is just a lookup
1861 }
1862 }
1864 }
1865 },
1876 };
1878 // If the fx queue is dequeued, always remove the progress sentinel
1881 startLength--;
1882 }
1886 // Add a progress sentinel to prevent the fx queue from being
1887 // automatically dequeued
1890 }
1892 // clear up the last queue stop function
1895 }
1899 }
1900 },
1902 // not intended for public consumption - generates a queueHooks object, or returns the current one
1909 })
1910 });
1911 }
1912 });
1921 setter--;
1922 }
1926 }
1933 // ensure a hooks for this queue
1938 }
1939 });
1940 },
1944 });
1945 },
1946 // Based off of the plugin by Clint Helfers, with permission.
1947 // http://blindsignals.com/index.php/2009/07/jquery-delay/
1956 };
1957 });
1958 },
1961 },
1962 // Get a promise resolved when queues of a certain type
1963 // are emptied (fx is the type by default)
1973 }
1974 };
1979 }
1985 count++;
1987 }
1988 }
1991 }
1992 });
1999 rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2005 },
2010 });
2011 },
2015 },
2020 // try/catch handles cases where IE balks (such as removing a property on window)
2025 });
2026 },
2035 });
2036 }
2054 }
2055 }
2057 }
2058 }
2059 }
2060 }
2063 },
2071 });
2072 }
2082 // loop over each item in the removal list
2084 // Remove until there is nothing to remove,
2087 }
2088 }
2090 }
2091 }
2092 }
2095 },
2104 });
2105 }
2109 // toggle individual class names
2117 // check each className given, space separated list
2120 }
2124 // store className if set
2126 }
2128 // toggle whole className
2129 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2130 }
2131 });
2132 },
2139 if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
2141 }
2142 }
2145 },
2157 }
2162 // handle most common string cases
2164 // handle cases where value is null/undef or number
2166 }
2169 }
2179 }
2185 }
2187 // Treat null/undefined as ""; convert numbers to string
2195 });
2196 }
2200 // If set returns undefined, fall back to normal setting
2203 }
2204 });
2205 }
2206 });
2209 valHooks: {
2210 option: {
2212 // attributes.value is undefined in Blackberry 4.7 but
2213 // uses .value. See #6932
2216 }
2217 },
2218 select: {
2222 values = [],
2226 // Nothing was selected
2229 }
2231 // Loop through all the selected options
2237 // Don't return options that are disabled or in a disabled optgroup
2238 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2241 // Get the specific value for the option
2244 // We don't need an array for one selects
2247 }
2249 // Multi-Selects return an array
2251 }
2252 }
2254 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2257 }
2260 },
2267 });
2271 }
2273 }
2274 }
2275 },
2277 // Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
2278 attrFn: {},
2284 // don't get/set attributes on text, comment and attribute nodes
2287 }
2291 }
2293 // Fallback to prop when attributes are not supported
2296 }
2300 // All attributes are lowercase
2301 // Grab necessary hook if one is defined
2305 }
2313 } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2319 }
2328 // Non-existent attributes return null, we normalize to undefined
2331 ret;
2332 }
2333 },
2350 // See #9699 for explanation of this approach (setting first, then removal)
2351 // Do not do this for boolean attributes (see #10870)
2354 }
2357 // Set corresponding property to false for boolean attributes
2360 }
2361 }
2362 }
2363 }
2364 },
2366 attrHooks: {
2367 type: {
2369 // We can't allow the type property to be changed (since it causes problems in IE)
2372 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2373 // Setting the type on a radio button after the value resets the value in IE6-9
2374 // Reset value to it's default in case type is set after value
2375 // This is for element creation
2380 }
2382 }
2383 }
2384 },
2385 // Use the value property for back compat
2386 // Use the nodeHook for button elements in IE6/7 (#1954)
2387 value: {
2391 }
2395 },
2399 }
2400 // Does not return so that setAttribute is also used
2402 }
2403 }
2404 },
2406 propFix: {
2419 },
2425 // don't get/set properties on text, comment and attribute nodes
2428 }
2433 // Fix name and attach hooks
2436 }
2444 }
2452 }
2453 }
2454 },
2456 propHooks: {
2457 tabIndex: {
2459 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2460 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2468 }
2469 }
2470 }
2471 });
2473 // Hook for boolean attributes
2474 boolHook = {
2476 // Align boolean attributes with corresponding properties
2477 // Fall back to attribute presence where some booleans are not supported
2480 return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2483 },
2487 // Remove boolean attributes when set to false
2490 // value is true since we know at this point it's type boolean and not false
2491 // Set boolean attributes to the same name and set the DOM property
2494 // Only set the IDL specifically if it already exists on the element
2496 }
2499 }
2501 }
2502 };
2504 // IE6/7 do not support getting/setting some attributes with get/setAttribute
2507 fixSpecified = {
2511 };
2513 // Use this for any attribute in IE6/7
2514 // This fixes almost every IE6/7 issue
2522 },
2524 // Set the existing or create a new attribute node
2529 }
2531 }
2532 };
2534 // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2535 // This is for removals
2542 }
2543 }
2544 });
2545 });
2547 // Set contenteditable to false on removals(#10429)
2548 // Setting to empty string throws an error as an invalid value
2554 }
2556 }
2557 };
2558 }
2561 // Some attributes require a special call on IE
2568 }
2569 });
2570 });
2571 }
2576 // Return undefined in the case of empty string
2577 // Normalize to lowercase since IE uppercases css property names
2579 },
2582 }
2583 };
2584 }
2586 // Safari mis-reports the default selected property of an option
2587 // Accessing the parent's selectedIndex property fixes it
2596 // Make sure that it also works with optgroups, see #5701
2599 }
2600 }
2602 }
2603 });
2604 }
2606 // IE6/7 call enctype encoding
2609 }
2611 // Radios and checkboxes getter/setter
2616 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2618 }
2619 };
2620 });
2621 }
2627 }
2628 }
2629 });
2630 });
2638 return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2639 };
2641 /*
2642 * Helper functions for managing events -- not part of the public interface.
2643 * Props to Dean Edwards' addEvent library for many of the ideas.
2644 */
2653 // Don't attach events to noData or text/comment nodes (allow plain objects tho)
2654 if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2656 }
2658 // Caller can pass in an object of custom data in lieu of the handler
2663 }
2665 // Make sure that the handler has a unique ID, used to find/remove it later
2668 }
2670 // Init the element's event structure and main handler, if this is the first
2674 }
2678 // Discard the second event of a jQuery.event.trigger() and
2679 // when an event is called after a page has unloaded
2683 };
2684 // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2686 }
2688 // Handle multiple events separated by a space
2689 // jQuery(...).bind("mouseover mouseout", fn);
2697 // If event changes its type, use the special event handlers for the changed type
2700 // If selector defined, determine special event api type, otherwise given type
2703 // Update special based on newly reset type
2706 // handleObj is passed to all event handlers
2718 // Init the event handler queue if we're the first
2724 // Only use addEventListener/attachEvent if the special events handler returns false
2726 // Bind the global event handler to the element
2732 }
2733 }
2734 }
2741 }
2742 }
2744 // Add to the element's handler list, delegates in front
2749 }
2751 // Keep track of which events have ever been used, for event optimization
2753 }
2755 // Nullify elem to prevent memory leaks in IE
2757 },
2759 global: {},
2761 // Detach an event or set of events from an element
2770 }
2772 // Once for each type.namespace in types; type may be omitted
2779 // Unbind all events (on this namespace, if provided) for the element
2783 }
2785 }
2791 namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
2793 // Remove matching events
2800 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2805 }
2808 }
2809 }
2810 }
2812 // Remove generic event handler if we removed something and no more handlers exist
2813 // (avoids potential for endless recursion during removal of special event handlers)
2815 if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
2817 }
2820 }
2821 }
2823 // Remove the expando if it's no longer used
2827 // removeData also checks for emptiness and clears the expando if empty
2828 // so use it instead of delete
2830 }
2831 },
2833 // Events that are safe to short-circuit if no handlers are attached.
2834 // Native DOM events should not be added, they may have inline handlers.
2835 customEvent: {
2839 },
2842 // Don't do events on text and comment nodes
2845 }
2847 // Event object or event type
2850 namespaces = [];
2852 // focus/blur morphs to focusin/out; ensure we're not firing them right now
2855 }
2858 // Exclusive events trigger only for the exact event (no namespaces)
2861 }
2864 // Namespaced trigger; create a regexp to match event type in handle()
2868 }
2871 // No jQuery handlers for this event type, and it can't have inline handlers
2873 }
2875 // Caller can pass in an Event, Object, or just an event type string
2877 // jQuery.Event object
2879 // Object literal
2881 // Just the event type (string)
2888 event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
2891 // Handle a global trigger
2894 // TODO: Stop taunting the data cache; remove global events and always attach to document
2899 }
2900 }
2902 }
2904 // Clean up the event in case it is being reused
2908 }
2910 // Clone any incoming data and prepend the event, creating the handler arg list
2914 // Allow special events to draw outside the lines
2918 }
2920 // Determine event propagation path in advance, per W3C events spec (#9951)
2921 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
2930 }
2932 // Only add window if we got to document (e.g., not plain obj or detached DOM)
2935 }
2936 }
2938 // Fire handlers on the event path
2944 handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
2947 }
2948 // Note that this is a bare JS function and not a jQuery handler
2950 if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
2952 }
2953 }
2956 // If nobody prevented the default action, do it now
2962 // Call a native DOM method on the target with the same name name as the event.
2963 // Can't use an .isFunction() check here because IE6/7 fails that test.
2964 // Don't do default actions on window, that's where global variables be (#6170)
2965 // IE<9 dies on focus/blur to hidden element (#1486)
2966 if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
2968 // Don't re-trigger an onFOO event when we call its FOO() method
2973 }
2975 // Prevent re-triggering of the same event, since we already bubbled it above
2982 }
2983 }
2984 }
2985 }
2988 },
2992 // Make a writable jQuery.Event from the native event object
3001 handlerQueue = [];
3003 // Use the fix-ed jQuery.Event rather than the (read-only) native event
3007 // Call the preDispatch hook for the mapped type, and let it bail if desired
3010 }
3012 // Determine handlers that should run if there are delegated events
3013 // Avoid non-left-click bubbling in Firefox (#3861)
3018 // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
3020 selMatch = {};
3021 matches = [];
3030 }
3033 }
3034 }
3037 }
3038 }
3039 }
3040 }
3042 // Add the remaining (directly-bound) handlers
3045 }
3047 // Run delegates first; they may want to stop propagation beneath us
3055 // Triggered event must either 1) be non-exclusive and have no namespace, or
3056 // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3057 if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3070 }
3071 }
3072 }
3073 }
3074 }
3076 // Call the postDispatch hook for the mapped type
3079 }
3082 },
3084 // Includes some event props shared by KeyEvent and MouseEvent
3085 // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3086 props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3088 fixHooks: {},
3090 keyHooks: {
3094 // Add which for key events
3097 }
3100 }
3101 },
3103 mouseHooks: {
3104 props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3110 // Calculate pageX/Y if missing and clientX/Y available
3116 event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3117 event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );
3118 }
3120 // Add relatedTarget, if necessary
3123 }
3125 // Add which for click: 1 === left; 2 === middle; 3 === right
3126 // Note: button is not normalized, so don't use it
3129 }
3132 }
3133 },
3138 }
3140 // Create a writable copy of the event object and normalize some properties
3151 }
3153 // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3156 }
3158 // Target should not be a text node (#504, Safari)
3161 }
3163 // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
3167 },
3169 special: {
3170 load: {
3171 // Prevent triggered image.load events from bubbling to window.load
3173 },
3175 focus: {
3177 },
3178 blur: {
3180 },
3182 beforeunload: {
3184 // We only want to do this special case on windows
3187 }
3188 },
3193 }
3194 }
3195 }
3196 },
3199 // Piggyback on a donor event to simulate a different one.
3200 // Fake originalEvent to avoid donor's stopPropagation, but if the
3201 // simulated event prevents default then we do the same on the donor.
3204 event,
3207 originalEvent: {}
3208 }
3209 );
3214 }
3217 }
3218 }
3219 };
3221 // Some plugins are using, but it's undocumented/deprecated and will be removed.
3222 // The 1.7 special event interface should provide all the hooks needed now.
3229 }
3230 } :
3236 // #8545, #7054, preventing memory leaks for custom events in IE6-8 –
3237 // detachEvent needed property on element, by name of that event, to properly expose it to GC
3240 }
3243 }
3244 };
3247 // Allow instantiation without the 'new' keyword
3250 }
3252 // Event object
3257 // Events bubbling up the document may have been marked as prevented
3258 // by a handler lower down the tree; reflect the correct value.
3262 // Event type
3265 }
3267 // Put explicitly provided properties onto the event object
3270 }
3272 // Create a timestamp if incoming event doesn't have one
3275 // Mark it as fixed
3277 };
3281 }
3284 }
3286 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3287 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3295 }
3297 // if preventDefault exists run it on the original event
3301 // otherwise set the returnValue property of the original event to false (IE)
3304 }
3305 },
3312 }
3313 // if stopPropagation exists run it on the original event
3316 }
3317 // otherwise set the cancelBubble property of the original event to true (IE)
3319 },
3323 },
3326 isImmediatePropagationStopped: returnFalse
3327 };
3329 // Create mouseenter/leave events using mouseover/out and event-time checks
3345 // For mousenter/leave call the handler if related is outside the target.
3346 // NB: No relatedTarget if the mouse left/entered the browser window
3351 }
3353 }
3354 };
3355 });
3357 // IE submit delegation
3362 // Only need this for delegated form submit events
3365 }
3367 // Lazy-add a submit handler when a descendant form may potentially be submitted
3369 // Node name check avoids a VML-related crash in IE (#9807)
3371 form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3375 });
3377 }
3378 });
3379 // return undefined since we don't need an event listener
3380 },
3383 // If form was submitted by the user, bubble the event up the tree
3388 }
3389 }
3390 },
3393 // Only need this for delegated form submit events
3396 }
3398 // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3400 }
3401 };
3402 }
3404 // IE change delegation and checkbox/radio fix
3412 // IE doesn't fire change on a check/radio until blur; trigger it on click
3413 // after a propertychange. Eat the blur-change in special.change.handle.
3414 // This still fires onchange a second time for check/radio after blur.
3419 }
3420 });
3424 }
3425 // Allow triggered, simulated change events (#11500)
3427 });
3428 }
3430 }
3431 // Delegated event; lazy-add a change handler on descendant inputs
3439 }
3440 });
3442 }
3443 });
3444 },
3449 // Swallow native change events from checkbox/radio, we already triggered them above
3450 if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3452 }
3453 },
3459 }
3460 };
3461 }
3463 // Create "bubbling" focus and blur events
3467 // Attach a single capturing handler while someone wants focusin/focusout
3471 };
3477 }
3478 },
3482 }
3483 }
3484 };
3485 });
3486 }
3493 // Types can be a map of types/handlers
3495 // ( types-Object, selector, data )
3497 // ( types-Object, data )
3500 }
3503 }
3505 }
3508 // ( types, fn )
3513 // ( types, selector, fn )
3517 // ( types, data, fn )
3521 }
3522 }
3527 }
3532 // Can use an empty set, since event contains the info
3535 };
3536 // Use same guid so caller can remove using origFn
3538 }
3541 });
3542 },
3545 },
3549 // ( event ) dispatched jQuery.Event
3554 handleObj.handler
3555 );
3557 }
3559 // ( types-object [, selector] )
3562 }
3564 }
3566 // ( types [, fn] )
3569 }
3572 }
3575 });
3576 },
3580 },
3583 },
3588 },
3592 },
3596 },
3598 // ( namespace ) or ( selector, types [, fn] )
3599 return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
3600 },
3605 });
3606 },
3610 }
3611 },
3614 // Save reference to arguments for access in closure
3619 // Figure out which function to execute
3623 // Make sure that clicks stop
3626 // and execute the function
3628 };
3630 // link all the functions, so any of them can unbind this click handler
3634 }
3637 },
3641 }
3642 });
3646 "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3648 // Handle event binding
3653 }
3658 };
3662 }
3666 }
3667 });
3668 /*!
3669 * Sizzle CSS Selector Engine
3670 * Copyright 2012 jQuery Foundation and other contributors
3671 * Released under the MIT license
3672 * http://sizzlejs.com/
3673 */
3677 assertGetIdNotName,
3678 Expr,
3679 getText,
3680 isXML,
3681 contains,
3682 compile,
3683 sortOrder,
3684 hasDuplicate,
3685 outermostContext,
3700 // Use a stripped-down indexOf if a native one is unavailable
3707 }
3708 }
3710 },
3712 // Augment a function for special use by Sizzle
3716 },
3720 keys = [];
3723 // Only keep the most recent entries
3726 }
3730 },
3736 // Regex
3738 // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
3740 // http://www.w3.org/TR/css3-syntax/#characters
3743 // Loosely modeled on CSS identifier characters
3744 // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
3745 // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
3748 // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
3751 "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
3753 // Prefer arguments not in parens/brackets,
3754 // then attribute selectors and non-pseudos (denoted by :),
3755 // then anything else
3756 // These preferences are here to reduce the number of selectors
3757 // needing tokenize in the PSEUDO preFilter
3758 pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)",
3760 // For matchExpr.POS and matchExpr.needsContext
3764 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
3765 rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
3768 rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
3771 // Easily-parseable/retrievable ID or TAG or CLASS selectors
3783 matchExpr = {
3794 // For use in libraries implementing .is()
3796 },
3798 // Support
3800 // Used for testing something on an element
3809 // release memory in IE
3811 }
3812 },
3814 // Check if getElementsByTagName("*") returns only elements
3818 }),
3820 // Check if getAttribute returns normalized href attributes
3825 }),
3827 // Check if attributes should be retrieved by attribute nodes
3831 // IE8 returns a string for some attributes even when not present
3833 }),
3835 // Check if getElementsByClassName can be trusted
3837 // Opera can't find a second classname (in 9.6)
3841 }
3843 // Safari 3.2 caches class attributes and doesn't catch changes
3846 }),
3848 // Check if getElementById returns elements by name
3849 // Check if getElementsByName privileges form controls or returns elements by ID
3851 // Inject content
3856 // Test
3858 // buggy browsers will return fewer than the correct 2
3860 // buggy browsers will return more than the correct 0
3864 // Cleanup
3868 });
3870 // If slice is not available, provide a backup
3876 results = [];
3879 }
3881 };
3882 }
3892 }
3896 }
3902 // Speed-up: Sizzle("#ID")
3906 // Check parentNode to catch when Blackberry 4.6 returns
3907 // nodes that are no longer in the document #6963
3909 // Handle the case where IE, Opera, and Webkit return items
3910 // by name instead of ID
3914 }
3917 }
3919 // Context is not a document
3924 }
3925 }
3927 // Speed-up: Sizzle("TAG")
3932 // Speed-up: Sizzle(".CLASS")
3936 }
3937 }
3938 }
3940 // All others
3942 }
3946 };
3950 };
3952 // Returns a function to use in pseudos for input types
3957 };
3958 }
3960 // Returns a function to use in pseudos for buttons
3965 };
3966 }
3968 // Returns a function to use in pseudos for positionals
3977 // Match elements found at the specified indexes
3981 }
3982 }
3983 });
3984 });
3985 }
3987 /**
3988 * Utility function for retrieving the text value of an array of DOM nodes
3989 * @param {Array|Element} elem
3990 */
3999 // Use textContent for elements
4000 // innerText usage removed for consistency of new lines (see #11153)
4004 // Traverse its children
4007 }
4008 }
4011 }
4012 // Do not include comment or processing instruction nodes
4015 // If no nodeType, this is expected to be an array
4017 // Do not traverse comment nodes
4019 }
4020 }
4022 };
4025 // documentElement is verified for cases where it doesn't yet exist
4026 // (such as loading iframes in IE - #4833)
4029 };
4031 // Element contains another
4037 } :
4041 } :
4046 }
4047 }
4049 };
4057 }
4060 }
4063 }
4070 };
4074 // Can be adjusted by the user
4081 // IE6/7 return a modified href
4083 {} :
4084 {
4087 },
4090 }
4091 },
4093 find: {
4098 // Check parentNode to catch when Blackberry 4.6 returns
4099 // nodes that are no longer in the document #6963
4101 }
4102 } :
4108 m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
4111 [];
4112 }
4113 },
4119 }
4120 } :
4124 // Filter out possible comments
4127 tmp = [],
4133 }
4134 }
4137 }
4139 },
4144 }
4145 },
4150 }
4151 }
4152 },
4154 relative: {
4159 },
4161 preFilter: {
4165 // Move the given value to match[3] whether quoted or unquoted
4170 }
4173 },
4176 /* matches from matchExpr["CHILD"]
4177 1 type (only|nth|...)
4178 2 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
4179 3 xn-component of xn+y argument ([+-]?\d*n|)
4180 4 sign of xn-component
4181 5 x of xn-component
4182 6 sign of y-component
4183 7 y of y-component
4184 */
4188 // nth-child requires argument
4191 }
4193 // numeric x and y parameters for Expr.filter.CHILD
4194 // remember that false/true cast respectively to 0/1
4195 match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) );
4198 // other types prohibit arguments
4201 }
4204 },
4210 }
4215 // Only check arguments that contain a pseudo
4217 // Get excess from tokenize (recursively)
4219 // advance to the next closing parenthesis
4222 // excess is a negative index
4225 }
4227 }
4229 // Return only captures needed by the pseudo filter method (type and argument)
4231 }
4232 },
4234 filter: {
4240 };
4241 } :
4247 };
4248 },
4253 }
4258 };
4259 },
4264 pattern = classCache( className, new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)") );
4265 }
4267 return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
4268 };
4269 },
4277 }
4280 }
4292 };
4293 },
4304 }
4310 diff++;
4313 }
4314 }
4315 }
4316 }
4318 // Incorporate the offset (or cast to NaN), then check against cycle size
4321 };
4322 }
4333 }
4334 }
4338 }
4342 /* falls through */
4347 }
4348 }
4351 }
4352 };
4353 },
4356 // pseudo-class names are case-insensitive
4357 // http://www.w3.org/TR/selectors/#pseudo-classes
4358 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
4359 // Remember that setFilters inherits from pseudos
4364 // The user may use createPseudo to indicate that
4365 // arguments are needed to create the filter function
4366 // just as Sizzle does
4369 }
4371 // But maintain support for old signatures
4382 }
4383 }) :
4386 };
4387 }
4390 }
4391 },
4393 pseudos: {
4395 // Trim the selector passed to compile
4396 // to avoid treating leading and trailing
4397 // spaces as combinators
4399 results = [],
4408 // Match elements unmatched by `matcher`
4412 }
4413 }
4414 }) :
4419 };
4420 }),
4425 };
4426 }),
4431 };
4432 }),
4436 },
4440 },
4443 // In CSS3, :checked should return both checked and selected elements
4444 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
4447 },
4450 // Accessing this property makes selected-by-default
4451 // options in Safari work properly
4454 }
4457 },
4461 },
4464 // http://www.w3.org/TR/selectors/#empty-pseudo
4465 // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
4466 // not comment, processing instructions, or others
4467 // Thanks to Diego Perini for the nodeName shortcut
4468 // Greater than "@" means alpha characters (specifically not starting with "#" or "?")
4474 }
4476 }
4478 },
4482 },
4486 // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4487 // use getAttribute instead to test this case
4491 },
4493 // Input types
4506 },
4510 },
4514 return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href);
4515 },
4519 },
4521 // Positional types
4524 }),
4528 }),
4532 }),
4537 }
4539 }),
4544 }
4546 }),
4551 }
4553 }),
4558 }
4560 })
4561 }
4562 };
4567 }
4574 }
4577 }
4580 }
4587 }
4593 } :
4595 // The nodes are identical, we can exit early
4600 // Fallback to using sourceIndex (in IE) if it's available on both nodes
4603 }
4606 ap = [],
4607 bp = [],
4612 // If the nodes are siblings (or identical) we can do a quick check
4616 // If no parents were found then the nodes are disconnected
4622 }
4624 // Otherwise they're somewhere else in the tree so we need
4625 // to build up a full list of the parentNodes for comparison
4629 }
4636 }
4641 // Start walking down the tree looking for a discrepancy
4645 }
4646 }
4648 // We ended someplace up the tree so do a sibling check
4652 };
4654 // Always assume the presence of duplicates if sort doesn't
4655 // pass them to our comparison function (as in Google Chrome).
4659 // Document sorting and removing duplicates
4671 }
4672 }
4673 }
4676 };
4680 };
4688 }
4691 groups = [];
4696 // Comma and first run
4700 }
4702 }
4706 // Combinators
4711 // Cast descendant combinators to space
4713 }
4715 // Filters
4718 // The last two arguments here are (context, xml) for backCompat
4725 }
4726 }
4730 }
4731 }
4733 // Return the length of the invalid excess
4734 // if we're just parsing
4735 // Otherwise, throw an error or return tokens
4738 soFar ?
4740 // Cache the tokens
4742 }
4750 // Check against closest ancestor/preceding element
4755 }
4756 }
4757 } :
4759 // Check against all ancestor/preceding elements
4761 // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
4773 }
4779 }
4781 }
4782 }
4783 }
4789 }
4790 }
4791 }
4792 }
4793 };
4794 }
4803 }
4804 }
4806 } :
4808 }
4812 newUnmatched = [],
4823 }
4824 }
4825 }
4826 }
4829 }
4834 }
4837 }
4839 // Positional selectors apply to seed elements, so it is invalid to follow them with relative ones
4842 }
4845 preMap = [],
4846 postMap = [],
4849 // Get initial elements from seed or context
4850 elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [], seed ),
4852 // Prefilter to get matcher input, preserving a map for seed-results synchronization
4855 elems,
4858 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
4861 // ...intermediate processing is necessary
4862 [] :
4864 // ...otherwise use results directly
4865 results :
4866 matcherIn;
4868 // Find primary matches
4871 }
4873 // Apply postFilter
4878 // Un-match failing elements by moving them back to matcherIn
4883 }
4884 }
4885 }
4887 // Keep seed and results synchronized
4889 // Ignore postFinder because it can't coexist with seed
4894 }
4895 }
4900 matcherOut
4901 );
4906 }
4907 }
4908 });
4909 }
4918 // The foundational matcher ensures that elements are reachable from top-level context(s)
4930 } ];
4936 // The concatenated values are (context, xml) for backCompat
4939 // Return special upon seeing a positional matcher
4941 // Find the next relative operator (if any) for proper handling
4946 }
4947 }
4951 matcher,
4955 );
4956 }
4958 }
4959 }
4962 }
4969 setMatched = [],
4975 // We must always have either seed elements or context
4976 elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
4977 // Nested matchers should use non-integer dirruns
4983 }
4985 // Add elements passing elementMatchers directly to results
4992 }
4993 }
4997 }
4998 }
5000 // Track unmatched elements for set filters
5002 // They will have gone through all possible matchers
5004 matchedCount--;
5005 }
5007 // Lengthen the array for every element, matched or not
5010 }
5011 }
5012 }
5014 // Apply set filters to unmatched elements
5019 }
5022 // Reintegrate element matches to eliminate the need for sorting
5027 }
5028 }
5029 }
5031 // Discard index placeholder values to get only actual matches
5033 }
5035 // Add matches to results
5038 // Seedless set matches succeeding multiple successful matchers stipulate sorting
5043 }
5044 }
5046 // Override manipulation of globals by nested matchers
5050 }
5053 };
5058 superMatcher;
5059 }
5063 setMatchers = [],
5064 elementMatchers = [],
5068 // Generate a function of recursive functions that can be used to check each element
5071 }
5079 }
5080 }
5082 // Cache the compiled function
5084 }
5086 };
5093 }
5095 }
5103 // Try to minimize operations if there is only one group
5106 // Take a shortcut and set the context if the root selector is an ID
5115 }
5118 }
5120 // Fetch a seed set for right-to-left matching
5124 // Abort if we hit a combinator
5127 }
5129 // Search, expanding context for leading sibling combinators
5133 xml
5134 )) ) {
5136 // If seed is empty or no tokens remain, we can return early
5142 }
5145 }
5146 }
5147 }
5148 }
5149 }
5151 // Compile and execute a filtering function
5152 // Provide `match` to avoid retokenization if we modified the selector above
5154 seed,
5155 context,
5156 xml,
5157 results,
5159 );
5161 }
5170 // qSa(:focus) reports false when true (Chrome 21),
5171 // A support test would require too much code (would include document ready)
5174 // matchesSelector(:focus) reports false when true (Chrome 21),
5175 // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
5176 // A support test would require too much code (would include document ready)
5177 // just skip matchesSelector for :active
5179 matches = docElem.matchesSelector ||
5180 docElem.mozMatchesSelector ||
5181 docElem.webkitMatchesSelector ||
5182 docElem.oMatchesSelector ||
5183 docElem.msMatchesSelector;
5185 // Build QSA regex
5186 // Regex strategy adopted from Diego Perini
5187 assert(function( div ) {
5188 // Select is set to empty string on purpose
5189 // This is to test IE's treatment of not explictly
5190 // setting a boolean content attribute,
5191 // since its presence should be enough
5192 // http://bugs.jquery.com/ticket/12359
5195 // IE8 - Some boolean attributes are not treated correctly
5197 rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
5198 }
5200 // Webkit/Opera - :checked should return selected option elements
5201 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
5202 // IE8 throws error here (do not put tests after this one)
5205 }
5206 });
5208 assert(function( div ) {
5210 // Opera 10-12/IE9 - ^= $= *= and empty values
5211 // Should not select anything
5215 }
5217 // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
5218 // IE8 throws error here (do not put tests after this one)
5222 }
5223 });
5225 // rbuggyQSA always contains :focus, so no need for a length check
5228 select = function( selector, context, results, seed, xml ) {
5229 // Only use querySelectorAll when not filtering,
5230 // when this is not xml,
5231 // and when no QSA bugs apply
5232 if ( !seed && !xml && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
5233 var groups, i,
5234 old = true,
5235 nid = expando,
5236 newContext = context,
5237 newSelector = context.nodeType === 9 && selector;
5239 // qSA works strangely on Element-rooted queries
5240 // We can work around this by specifying an extra ID on the root
5241 // and working up from there (Thanks to Andrew Dupont for the technique)
5242 // IE 8 doesn't work on object elements
5244 groups = tokenize( selector );
5248 } else {
5250 }
5253 i = groups.length;
5254 while ( i-- ) {
5256 }
5257 newContext = rsibling.test( selector ) && context.parentNode || context;
5259 }
5261 if ( newSelector ) {
5262 try {
5263 push.apply( results, slice.call( newContext.querySelectorAll(
5264 newSelector
5265 ), 0 ) );
5266 return results;
5267 } catch(qsaError) {
5268 } finally {
5269 if ( !old ) {
5271 }
5272 }
5273 }
5274 }
5276 return oldSelect( selector, context, results, seed, xml );
5277 };
5279 if ( matches ) {
5280 assert(function( div ) {
5281 // Check to see if it's possible to do matchesSelector
5282 // on a disconnected node (IE 9)
5285 // This should fail with an exception
5286 // Gecko does not error, returns false instead
5287 try {
5290 } catch ( e ) {}
5291 });
5293 // rbuggyMatches always contains :active and :focus, so no need for a length check
5296 Sizzle.matchesSelector = function( elem, expr ) {
5297 // Make sure that attribute selectors are quoted
5300 // rbuggyMatches always contains :active, so no need for an existence check
5301 if ( !isXML( elem ) && !rbuggyMatches.test( expr ) && (!rbuggyQSA || !rbuggyQSA.test( expr )) ) {
5302 try {
5303 var ret = matches.call( elem, expr );
5305 // IE 9's matchesSelector returns false on disconnected nodes
5306 if ( ret || disconnectedMatch ||
5307 // As well, disconnected nodes are said to be in a document
5308 // fragment in IE 9
5309 elem.document && elem.document.nodeType !== 11 ) {
5310 return ret;
5311 }
5312 } catch(e) {}
5313 }
5315 return Sizzle( expr, null, null, [ elem ] ).length > 0;
5316 };
5317 }
5318 })();
5319 }
5321 // Deprecated
5324 // Back-compat
5325 function setFilters() {}
5326 Expr.filters = setFilters.prototype = Expr.pseudos;
5327 Expr.setFilters = new setFilters();
5329 // Override sizzle attribute retrieval
5330 Sizzle.attr = jQuery.attr;
5331 jQuery.find = Sizzle;
5332 jQuery.expr = Sizzle.selectors;
5334 jQuery.unique = Sizzle.uniqueSort;
5335 jQuery.text = Sizzle.getText;
5336 jQuery.isXMLDoc = Sizzle.isXML;
5337 jQuery.contains = Sizzle.contains;
5340 })( window );
5341 var runtil = /Until$/,
5342 rparentsprev = /^(?:parents|prev(?:Until|All))/,
5343 isSimple = /^.[^:#\[\.,]*$/,
5344 rneedsContext = jQuery.expr.match.needsContext,
5345 // methods guaranteed to produce a unique set when starting from a unique set
5346 guaranteedUnique = {
5347 children: true,
5348 contents: true,
5349 next: true,
5350 prev: true
5351 };
5353 jQuery.fn.extend({
5354 find: function( selector ) {
5355 var i, l, length, n, r, ret,
5356 self = this;
5359 return jQuery( selector ).filter(function() {
5360 for ( i = 0, l = self.length; i < l; i++ ) {
5361 if ( jQuery.contains( self[ i ], this ) ) {
5362 return true;
5363 }
5364 }
5365 });
5366 }
5370 for ( i = 0, l = this.length; i < l; i++ ) {
5371 length = ret.length;
5372 jQuery.find( selector, this[i], ret );
5374 if ( i > 0 ) {
5375 // Make sure that the results are unique
5376 for ( n = length; n < ret.length; n++ ) {
5377 for ( r = 0; r < length; r++ ) {
5378 if ( ret[r] === ret[n] ) {
5379 ret.splice(n--, 1);
5380 break;
5381 }
5382 }
5383 }
5384 }
5385 }
5387 return ret;
5388 },
5390 has: function( target ) {
5391 var i,
5392 targets = jQuery( target, this ),
5393 len = targets.length;
5395 return this.filter(function() {
5396 for ( i = 0; i < len; i++ ) {
5397 if ( jQuery.contains( this, targets[i] ) ) {
5398 return true;
5399 }
5400 }
5401 });
5402 },
5404 not: function( selector ) {
5406 },
5408 filter: function( selector ) {
5410 },
5412 is: function( selector ) {
5413 return !!selector && (
5415 // If this is a positional/relative selector, check membership in the returned set
5417 rneedsContext.test( selector ) ?
5418 jQuery( selector, this.context ).index( this[0] ) >= 0 :
5419 jQuery.filter( selector, this ).length > 0 :
5420 this.filter( selector ).length > 0 );
5421 },
5423 closest: function( selectors, context ) {
5424 var cur,
5425 i = 0,
5426 l = this.length,
5427 ret = [],
5429 jQuery( selectors, context || this.context ) :
5430 0;
5432 for ( ; i < l; i++ ) {
5433 cur = this[i];
5435 while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
5436 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5437 ret.push( cur );
5438 break;
5439 }
5440 cur = cur.parentNode;
5441 }
5442 }
5444 ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5447 },
5449 // Determine the position of an element within
5450 // the matched set of elements
5451 index: function( elem ) {
5453 // No argument, return index in parent
5454 if ( !elem ) {
5455 return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
5456 }
5458 // index in selector
5460 return jQuery.inArray( this[0], jQuery( elem ) );
5461 }
5463 // Locate the position of the desired element
5464 return jQuery.inArray(
5465 // If it receives a jQuery object, the first element is used
5466 elem.jquery ? elem[0] : elem, this );
5467 },
5469 add: function( selector, context ) {
5471 jQuery( selector, context ) :
5472 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5473 all = jQuery.merge( this.get(), set );
5475 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
5476 all :
5477 jQuery.unique( all ) );
5478 },
5480 addBack: function( selector ) {
5481 return this.add( selector == null ?
5482 this.prevObject : this.prevObject.filter(selector)
5483 );
5484 }
5485 });
5487 jQuery.fn.andSelf = jQuery.fn.addBack;
5489 // A painfully simple check to see if an element is disconnected
5490 // from a document (should be improved, where feasible).
5491 function isDisconnected( node ) {
5492 return !node || !node.parentNode || node.parentNode.nodeType === 11;
5493 }
5495 function sibling( cur, dir ) {
5496 do {
5497 cur = cur[ dir ];
5498 } while ( cur && cur.nodeType !== 1 );
5500 return cur;
5501 }
5503 jQuery.each({
5504 parent: function( elem ) {
5505 var parent = elem.parentNode;
5506 return parent && parent.nodeType !== 11 ? parent : null;
5507 },
5508 parents: function( elem ) {
5510 },
5511 parentsUntil: function( elem, i, until ) {
5513 },
5514 next: function( elem ) {
5516 },
5517 prev: function( elem ) {
5519 },
5520 nextAll: function( elem ) {
5522 },
5523 prevAll: function( elem ) {
5525 },
5526 nextUntil: function( elem, i, until ) {
5528 },
5529 prevUntil: function( elem, i, until ) {
5531 },
5532 siblings: function( elem ) {
5533 return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
5534 },
5535 children: function( elem ) {
5536 return jQuery.sibling( elem.firstChild );
5537 },
5538 contents: function( elem ) {
5540 elem.contentDocument || elem.contentWindow.document :
5541 jQuery.merge( [], elem.childNodes );
5542 }
5543 }, function( name, fn ) {
5544 jQuery.fn[ name ] = function( until, selector ) {
5545 var ret = jQuery.map( this, fn, until );
5547 if ( !runtil.test( name ) ) {
5548 selector = until;
5549 }
5552 ret = jQuery.filter( selector, ret );
5553 }
5555 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5557 if ( this.length > 1 && rparentsprev.test( name ) ) {
5558 ret = ret.reverse();
5559 }
5562 };
5563 });
5565 jQuery.extend({
5566 filter: function( expr, elems, not ) {
5567 if ( not ) {
5569 }
5571 return elems.length === 1 ?
5572 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5573 jQuery.find.matches(expr, elems);
5574 },
5576 dir: function( elem, dir, until ) {
5577 var matched = [],
5578 cur = elem[ dir ];
5580 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
5581 if ( cur.nodeType === 1 ) {
5582 matched.push( cur );
5583 }
5584 cur = cur[dir];
5585 }
5586 return matched;
5587 },
5589 sibling: function( n, elem ) {
5590 var r = [];
5592 for ( ; n; n = n.nextSibling ) {
5593 if ( n.nodeType === 1 && n !== elem ) {
5594 r.push( n );
5595 }
5596 }
5598 return r;
5599 }
5600 });
5602 // Implement the identical functionality for filter and not
5603 function winnow( elements, qualifier, keep ) {
5605 // Can't pass null or undefined to indexOf in Firefox 4
5606 // Set to 0 to skip string check
5607 qualifier = qualifier || 0;
5609 if ( jQuery.isFunction( qualifier ) ) {
5610 return jQuery.grep(elements, function( elem, i ) {
5611 var retVal = !!qualifier.call( elem, i, elem );
5612 return retVal === keep;
5613 });
5615 } else if ( qualifier.nodeType ) {
5616 return jQuery.grep(elements, function( elem, i ) {
5617 return ( elem === qualifier ) === keep;
5618 });
5621 var filtered = jQuery.grep(elements, function( elem ) {
5622 return elem.nodeType === 1;
5623 });
5625 if ( isSimple.test( qualifier ) ) {
5626 return jQuery.filter(qualifier, filtered, !keep);
5627 } else {
5628 qualifier = jQuery.filter( qualifier, filtered );
5629 }
5630 }
5632 return jQuery.grep(elements, function( elem, i ) {
5633 return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
5634 });
5635 }
5636 function createSafeFragment( document ) {
5638 safeFrag = document.createDocumentFragment();
5640 if ( safeFrag.createElement ) {
5641 while ( list.length ) {
5642 safeFrag.createElement(
5643 list.pop()
5644 );
5645 }
5646 }
5647 return safeFrag;
5648 }
5650 var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
5653 rleadingWhitespace = /^\s+/,
5654 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
5655 rtagName = /<([\w:]+)/,
5656 rtbody = /<tbody/i,
5657 rhtml = /<|&#?\w+;/,
5658 rnoInnerhtml = /<(?:script|style|link)/i,
5659 rnocache = /<(?:script|object|embed|option|style)/i,
5661 rcheckableType = /^(?:checkbox|radio)$/,
5663 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5664 rscriptType = /\/(java|ecma)script/i,
5665 rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,
5666 wrapMap = {
5675 },
5676 safeFragment = createSafeFragment( document ),
5679 wrapMap.optgroup = wrapMap.option;
5680 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5681 wrapMap.th = wrapMap.td;
5683 // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
5684 // unless wrapped in a div with non-breaking characters in front of it.
5685 if ( !jQuery.support.htmlSerialize ) {
5687 }
5689 jQuery.fn.extend({
5690 text: function( value ) {
5691 return jQuery.access( this, function( value ) {
5692 return value === undefined ?
5693 jQuery.text( this ) :
5694 this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
5695 }, null, value, arguments.length );
5696 },
5698 wrapAll: function( html ) {
5699 if ( jQuery.isFunction( html ) ) {
5700 return this.each(function(i) {
5701 jQuery(this).wrapAll( html.call(this, i) );
5702 });
5703 }
5705 if ( this[0] ) {
5706 // The elements to wrap the target around
5707 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5709 if ( this[0].parentNode ) {
5710 wrap.insertBefore( this[0] );
5711 }
5713 wrap.map(function() {
5714 var elem = this;
5716 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5717 elem = elem.firstChild;
5718 }
5720 return elem;
5721 }).append( this );
5722 }
5724 return this;
5725 },
5727 wrapInner: function( html ) {
5728 if ( jQuery.isFunction( html ) ) {
5729 return this.each(function(i) {
5730 jQuery(this).wrapInner( html.call(this, i) );
5731 });
5732 }
5734 return this.each(function() {
5735 var self = jQuery( this ),
5736 contents = self.contents();
5738 if ( contents.length ) {
5739 contents.wrapAll( html );
5741 } else {
5742 self.append( html );
5743 }
5744 });
5745 },
5747 wrap: function( html ) {
5748 var isFunction = jQuery.isFunction( html );
5750 return this.each(function(i) {
5751 jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
5752 });
5753 },
5755 unwrap: function() {
5756 return this.parent().each(function() {
5758 jQuery( this ).replaceWith( this.childNodes );
5759 }
5760 }).end();
5761 },
5763 append: function() {
5764 return this.domManip(arguments, true, function( elem ) {
5765 if ( this.nodeType === 1 || this.nodeType === 11 ) {
5766 this.appendChild( elem );
5767 }
5768 });
5769 },
5771 prepend: function() {
5772 return this.domManip(arguments, true, function( elem ) {
5773 if ( this.nodeType === 1 || this.nodeType === 11 ) {
5774 this.insertBefore( elem, this.firstChild );
5775 }
5776 });
5777 },
5779 before: function() {
5780 if ( !isDisconnected( this[0] ) ) {
5781 return this.domManip(arguments, false, function( elem ) {
5782 this.parentNode.insertBefore( elem, this );
5783 });
5784 }
5786 if ( arguments.length ) {
5787 var set = jQuery.clean( arguments );
5789 }
5790 },
5792 after: function() {
5793 if ( !isDisconnected( this[0] ) ) {
5794 return this.domManip(arguments, false, function( elem ) {
5795 this.parentNode.insertBefore( elem, this.nextSibling );
5796 });
5797 }
5799 if ( arguments.length ) {
5800 var set = jQuery.clean( arguments );
5802 }
5803 },
5805 // keepData is for internal use only--do not document
5806 remove: function( selector, keepData ) {
5807 var elem,
5808 i = 0;
5810 for ( ; (elem = this[i]) != null; i++ ) {
5811 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5812 if ( !keepData && elem.nodeType === 1 ) {
5814 jQuery.cleanData( [ elem ] );
5815 }
5817 if ( elem.parentNode ) {
5818 elem.parentNode.removeChild( elem );
5819 }
5820 }
5821 }
5823 return this;
5824 },
5826 empty: function() {
5827 var elem,
5828 i = 0;
5830 for ( ; (elem = this[i]) != null; i++ ) {
5831 // Remove element nodes and prevent memory leaks
5832 if ( elem.nodeType === 1 ) {
5834 }
5836 // Remove any remaining nodes
5837 while ( elem.firstChild ) {
5838 elem.removeChild( elem.firstChild );
5839 }
5840 }
5842 return this;
5843 },
5845 clone: function( dataAndEvents, deepDataAndEvents ) {
5846 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5847 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5849 return this.map( function () {
5850 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5851 });
5852 },
5854 html: function( value ) {
5855 return jQuery.access( this, function( value ) {
5856 var elem = this[0] || {},
5857 i = 0,
5858 l = this.length;
5860 if ( value === undefined ) {
5861 return elem.nodeType === 1 ?
5863 undefined;
5864 }
5866 // See if we can take a shortcut and just use innerHTML
5868 ( jQuery.support.htmlSerialize || !rnoshimcache.test( value ) ) &&
5869 ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
5874 try {
5875 for (; i < l; i++ ) {
5876 // Remove element nodes and prevent memory leaks
5877 elem = this[i] || {};
5878 if ( elem.nodeType === 1 ) {
5880 elem.innerHTML = value;
5881 }
5882 }
5884 elem = 0;
5886 // If using innerHTML throws an exception, use the fallback method
5887 } catch(e) {}
5888 }
5890 if ( elem ) {
5891 this.empty().append( value );
5892 }
5893 }, null, value, arguments.length );
5894 },
5896 replaceWith: function( value ) {
5897 if ( !isDisconnected( this[0] ) ) {
5898 // Make sure that the elements are removed from the DOM before they are inserted
5899 // this can help fix replacing a parent with child elements
5900 if ( jQuery.isFunction( value ) ) {
5901 return this.each(function(i) {
5902 var self = jQuery(this), old = self.html();
5903 self.replaceWith( value.call( this, i, old ) );
5904 });
5905 }
5908 value = jQuery( value ).detach();
5909 }
5911 return this.each(function() {
5912 var next = this.nextSibling,
5913 parent = this.parentNode;
5915 jQuery( this ).remove();
5917 if ( next ) {
5918 jQuery(next).before( value );
5919 } else {
5920 jQuery(parent).append( value );
5921 }
5922 });
5923 }
5925 return this.length ?
5927 this;
5928 },
5930 detach: function( selector ) {
5931 return this.remove( selector, true );
5932 },
5934 domManip: function( args, table, callback ) {
5936 // Flatten any nested arrays
5937 args = [].concat.apply( [], args );
5939 var results, first, fragment, iNoClone,
5940 i = 0,
5941 value = args[0],
5942 scripts = [],
5943 l = this.length;
5945 // We can't cloneNode fragments that contain checked, in WebKit
5946 if ( !jQuery.support.checkClone && l > 1 && typeof value === "string" && rchecked.test( value ) ) {
5947 return this.each(function() {
5948 jQuery(this).domManip( args, table, callback );
5949 });
5950 }
5952 if ( jQuery.isFunction(value) ) {
5953 return this.each(function(i) {
5954 var self = jQuery(this);
5955 args[0] = value.call( this, i, table ? self.html() : undefined );
5956 self.domManip( args, table, callback );
5957 });
5958 }
5960 if ( this[0] ) {
5961 results = jQuery.buildFragment( args, this, scripts );
5962 fragment = results.fragment;
5963 first = fragment.firstChild;
5965 if ( fragment.childNodes.length === 1 ) {
5966 fragment = first;
5967 }
5969 if ( first ) {
5972 // Use the original fragment for the last item instead of the first because it can end up
5973 // being emptied incorrectly in certain situations (#8070).
5974 // Fragments from the fragment cache must always be cloned and never used in place.
5975 for ( iNoClone = results.cacheable || l - 1; i < l; i++ ) {
5976 callback.call(
5979 this[i],
5980 i === iNoClone ?
5981 fragment :
5982 jQuery.clone( fragment, true, true )
5983 );
5984 }
5985 }
5987 // Fix #11809: Avoid leaking memory
5988 fragment = first = null;
5990 if ( scripts.length ) {
5991 jQuery.each( scripts, function( i, elem ) {
5992 if ( elem.src ) {
5993 if ( jQuery.ajax ) {
5994 jQuery.ajax({
5995 url: elem.src,
5998 async: false,
5999 global: false,
6001 });
6002 } else {
6004 }
6005 } else {
6006 jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "" ) );
6007 }
6009 if ( elem.parentNode ) {
6010 elem.parentNode.removeChild( elem );
6011 }
6012 });
6013 }
6014 }
6016 return this;
6017 }
6018 });
6020 function findOrAppend( elem, tag ) {
6021 return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
6022 }
6024 function cloneCopyEvent( src, dest ) {
6026 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
6027 return;
6028 }
6030 var type, i, l,
6031 oldData = jQuery._data( src ),
6032 curData = jQuery._data( dest, oldData ),
6033 events = oldData.events;
6035 if ( events ) {
6036 delete curData.handle;
6037 curData.events = {};
6039 for ( type in events ) {
6040 for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6041 jQuery.event.add( dest, type, events[ type ][ i ] );
6042 }
6043 }
6044 }
6046 // make the cloned public data object a copy from the original
6047 if ( curData.data ) {
6048 curData.data = jQuery.extend( {}, curData.data );
6049 }
6050 }
6052 function cloneFixAttributes( src, dest ) {
6053 var nodeName;
6055 // We do not need to do anything for non-Elements
6056 if ( dest.nodeType !== 1 ) {
6057 return;
6058 }
6060 // clearAttributes removes the attributes, which we don't want,
6061 // but also removes the attachEvent events, which we *do* want
6062 if ( dest.clearAttributes ) {
6063 dest.clearAttributes();
6064 }
6066 // mergeAttributes, in contrast, only merges back on the
6067 // original attributes, not the events
6068 if ( dest.mergeAttributes ) {
6069 dest.mergeAttributes( src );
6070 }
6072 nodeName = dest.nodeName.toLowerCase();
6075 // IE6-10 improperly clones children of object elements using classid.
6076 // IE10 throws NoModificationAllowedError if parent is null, #12132.
6077 if ( dest.parentNode ) {
6078 dest.outerHTML = src.outerHTML;
6079 }
6081 // This path appears unavoidable for IE9. When cloning an object
6082 // element in IE9, the outerHTML strategy above is not sufficient.
6083 // If the src has innerHTML and the destination does not,
6084 // copy the src.innerHTML into the dest.innerHTML. #10324
6085 if ( jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML)) ) {
6086 dest.innerHTML = src.innerHTML;
6087 }
6090 // IE6-8 fails to persist the checked state of a cloned checkbox
6091 // or radio button. Worse, IE6-7 fail to give the cloned element
6092 // a checked appearance if the defaultChecked value isn't also set
6094 dest.defaultChecked = dest.checked = src.checked;
6096 // IE6-7 get confused and end up setting the value of a cloned
6098 if ( dest.value !== src.value ) {
6099 dest.value = src.value;
6100 }
6102 // IE6-8 fails to return the selected option to the default selected
6103 // state when cloning options
6105 dest.selected = src.defaultSelected;
6107 // IE6-8 fails to set the defaultValue to the correct value when
6108 // cloning other types of input fields
6110 dest.defaultValue = src.defaultValue;
6112 // IE blanks contents when cloning scripts
6114 dest.text = src.text;
6115 }
6117 // Event data gets referenced instead of copied if the expando
6118 // gets copied too
6119 dest.removeAttribute( jQuery.expando );
6120 }
6122 jQuery.buildFragment = function( args, context, scripts ) {
6123 var fragment, cacheable, cachehit,
6124 first = args[ 0 ];
6126 // Set context from what may come in as undefined or a jQuery collection or a node
6127 // Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 &
6128 // also doubles as fix for #8950 where plain objects caused createDocumentFragment exception
6129 context = context || document;
6130 context = !context.nodeType && context[0] || context;
6131 context = context.ownerDocument || context;
6134 // Cloning options loses the selected state, so don't cache them
6135 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
6136 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
6137 // Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
6138 if ( args.length === 1 && typeof first === "string" && first.length < 512 && context === document &&
6140 (jQuery.support.checkClone || !rchecked.test( first )) &&
6141 (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
6143 // Mark cacheable and look for a hit
6144 cacheable = true;
6145 fragment = jQuery.fragments[ first ];
6146 cachehit = fragment !== undefined;
6147 }
6149 if ( !fragment ) {
6150 fragment = context.createDocumentFragment();
6151 jQuery.clean( args, context, fragment, scripts );
6153 // Update the cache, but only store false
6154 // unless this is a second parsing of the same content
6155 if ( cacheable ) {
6156 jQuery.fragments[ first ] = cachehit && fragment;
6157 }
6158 }
6160 return { fragment: fragment, cacheable: cacheable };
6161 };
6163 jQuery.fragments = {};
6165 jQuery.each({
6171 }, function( name, original ) {
6172 jQuery.fn[ name ] = function( selector ) {
6173 var elems,
6174 i = 0,
6175 ret = [],
6176 insert = jQuery( selector ),
6177 l = insert.length,
6178 parent = this.length === 1 && this[0].parentNode;
6180 if ( (parent == null || parent && parent.nodeType === 11 && parent.childNodes.length === 1) && l === 1 ) {
6181 insert[ original ]( this[0] );
6182 return this;
6183 } else {
6184 for ( ; i < l; i++ ) {
6185 elems = ( i > 0 ? this.clone(true) : this ).get();
6186 jQuery( insert[i] )[ original ]( elems );
6187 ret = ret.concat( elems );
6188 }
6190 return this.pushStack( ret, name, insert.selector );
6191 }
6192 };
6193 });
6195 function getAll( elem ) {
6202 } else {
6203 return [];
6204 }
6205 }
6207 // Used in clean, fixes the defaultChecked property
6208 function fixDefaultChecked( elem ) {
6209 if ( rcheckableType.test( elem.type ) ) {
6210 elem.defaultChecked = elem.checked;
6211 }
6212 }
6214 jQuery.extend({
6215 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6216 var srcElements,
6217 destElements,
6218 i,
6219 clone;
6221 if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
6222 clone = elem.cloneNode( true );
6224 // IE<=8 does not properly clone detached, unknown element nodes
6225 } else {
6226 fragmentDiv.innerHTML = elem.outerHTML;
6227 fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
6228 }
6230 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
6231 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6232 // IE copies events bound via attachEvent when using cloneNode.
6233 // Calling detachEvent on the clone will also remove the events
6234 // from the original. In order to get around this, we use some
6235 // proprietary methods to clear the events. Thanks to MooTools
6236 // guys for this hotness.
6238 cloneFixAttributes( elem, clone );
6240 // Using Sizzle here is crazy slow, so we use getElementsByTagName instead
6241 srcElements = getAll( elem );
6242 destElements = getAll( clone );
6244 // Weird iteration because IE will replace the length property
6245 // with an element if you are cloning the body and one of the
6247 for ( i = 0; srcElements[i]; ++i ) {
6248 // Ensure that the destination node is not null; Fixes #9587
6249 if ( destElements[i] ) {
6250 cloneFixAttributes( srcElements[i], destElements[i] );
6251 }
6252 }
6253 }
6255 // Copy the events from the original to the clone
6256 if ( dataAndEvents ) {
6257 cloneCopyEvent( elem, clone );
6259 if ( deepDataAndEvents ) {
6260 srcElements = getAll( elem );
6261 destElements = getAll( clone );
6263 for ( i = 0; srcElements[i]; ++i ) {
6264 cloneCopyEvent( srcElements[i], destElements[i] );
6265 }
6266 }
6267 }
6269 srcElements = destElements = null;
6271 // Return the cloned set
6272 return clone;
6273 },
6275 clean: function( elems, context, fragment, scripts ) {
6276 var i, j, elem, tag, wrap, depth, div, hasBody, tbody, len, handleScript, jsTags,
6277 safe = context === document && safeFragment,
6278 ret = [];
6280 // Ensure that context is a document
6282 context = document;
6283 }
6285 // Use the already-created safe fragment if context permits
6286 for ( i = 0; (elem = elems[i]) != null; i++ ) {
6289 }
6291 if ( !elem ) {
6292 continue;
6293 }
6295 // Convert html string into DOM nodes
6297 if ( !rhtml.test( elem ) ) {
6298 elem = context.createTextNode( elem );
6299 } else {
6300 // Ensure a safe container in which to render the html
6301 safe = safe || createSafeFragment( context );
6303 safe.appendChild( div );
6308 // Go to html and back, then peel off extra wrappers
6310 wrap = wrapMap[ tag ] || wrapMap._default;
6311 depth = wrap[0];
6312 div.innerHTML = wrap[1] + elem + wrap[2];
6314 // Move to the right depth
6315 while ( depth-- ) {
6316 div = div.lastChild;
6317 }
6319 // Remove IE's autoinserted <tbody> from table fragments
6320 if ( !jQuery.support.tbody ) {
6322 // String was a <table>, *may* have spurious <tbody>
6323 hasBody = rtbody.test(elem);
6325 div.firstChild && div.firstChild.childNodes :
6327 // String was a bare <thead> or <tfoot>
6329 div.childNodes :
6330 [];
6332 for ( j = tbody.length - 1; j >= 0 ; --j ) {
6334 tbody[ j ].parentNode.removeChild( tbody[ j ] );
6335 }
6336 }
6337 }
6339 // IE completely kills leading whitespace when innerHTML is used
6340 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6341 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6342 }
6344 elem = div.childNodes;
6346 // Take out of fragment container (we need a fresh div each time)
6347 div.parentNode.removeChild( div );
6348 }
6349 }
6351 if ( elem.nodeType ) {
6352 ret.push( elem );
6353 } else {
6354 jQuery.merge( ret, elem );
6355 }
6356 }
6358 // Fix #11356: Clear elements from safeFragment
6359 if ( div ) {
6360 elem = div = safe = null;
6361 }
6363 // Reset defaultChecked for any radios and checkboxes
6364 // about to be appended to the DOM in IE 6/7 (#8060)
6365 if ( !jQuery.support.appendChecked ) {
6366 for ( i = 0; (elem = ret[i]) != null; i++ ) {
6368 fixDefaultChecked( elem );
6371 }
6372 }
6373 }
6375 // Append elements to a provided document fragment
6376 if ( fragment ) {
6377 // Special handling of each script element
6378 handleScript = function( elem ) {
6379 // Check if we consider it executable
6380 if ( !elem.type || rscriptType.test( elem.type ) ) {
6381 // Detach the script and store it in the scripts array (if provided) or the fragment
6382 // Return truthy to indicate that it has been handled
6383 return scripts ?
6384 scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :
6385 fragment.appendChild( elem );
6386 }
6387 };
6389 for ( i = 0; (elem = ret[i]) != null; i++ ) {
6390 // Check if we're done after handling an executable script
6392 // Append to fragment and handle embedded scripts
6393 fragment.appendChild( elem );
6395 // handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration
6398 // Splice the scripts into ret after their former ancestor and advance our index beyond them
6399 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6400 i += jsTags.length;
6401 }
6402 }
6403 }
6404 }
6406 return ret;
6407 },
6409 cleanData: function( elems, /* internal */ acceptData ) {
6410 var data, id, elem, type,
6411 i = 0,
6412 internalKey = jQuery.expando,
6413 cache = jQuery.cache,
6414 deleteExpando = jQuery.support.deleteExpando,
6415 special = jQuery.event.special;
6417 for ( ; (elem = elems[i]) != null; i++ ) {
6419 if ( acceptData || jQuery.acceptData( elem ) ) {
6421 id = elem[ internalKey ];
6422 data = id && cache[ id ];
6424 if ( data ) {
6425 if ( data.events ) {
6426 for ( type in data.events ) {
6427 if ( special[ type ] ) {
6428 jQuery.event.remove( elem, type );
6430 // This is a shortcut to avoid jQuery.event.remove's overhead
6431 } else {
6432 jQuery.removeEvent( elem, type, data.handle );
6433 }
6434 }
6435 }
6437 // Remove cache only if it was not already removed by jQuery.event.remove
6438 if ( cache[ id ] ) {
6440 delete cache[ id ];
6442 // IE does not allow us to delete expando properties from nodes,
6443 // nor does it have a removeAttribute function on Document nodes;
6444 // we must handle all of these cases
6445 if ( deleteExpando ) {
6446 delete elem[ internalKey ];
6448 } else if ( elem.removeAttribute ) {
6449 elem.removeAttribute( internalKey );
6451 } else {
6452 elem[ internalKey ] = null;
6453 }
6455 jQuery.deletedIds.push( id );
6456 }
6457 }
6458 }
6459 }
6460 }
6461 });
6462 // Limit scope pollution from any deprecated API
6463 (function() {
6465 var matched, browser;
6467 // Use of jQuery.browser is frowned upon.
6468 // More details: http://api.jquery.com/jQuery.browser
6469 // jQuery.uaMatch maintained for back-compat
6470 jQuery.uaMatch = function( ua ) {
6471 ua = ua.toLowerCase();
6473 var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
6474 /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
6475 /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
6476 /(msie) ([\w.]+)/.exec( ua ) ||
6478 [];
6480 return {
6483 };
6484 };
6486 matched = jQuery.uaMatch( navigator.userAgent );
6487 browser = {};
6489 if ( matched.browser ) {
6490 browser[ matched.browser ] = true;
6491 browser.version = matched.version;
6492 }
6494 // Chrome is Webkit, but Webkit is also Safari.
6495 if ( browser.chrome ) {
6496 browser.webkit = true;
6497 } else if ( browser.webkit ) {
6498 browser.safari = true;
6499 }
6501 jQuery.browser = browser;
6503 jQuery.sub = function() {
6504 function jQuerySub( selector, context ) {
6505 return new jQuerySub.fn.init( selector, context );
6506 }
6507 jQuery.extend( true, jQuerySub, this );
6508 jQuerySub.superclass = this;
6509 jQuerySub.fn = jQuerySub.prototype = this();
6510 jQuerySub.fn.constructor = jQuerySub;
6511 jQuerySub.sub = this.sub;
6512 jQuerySub.fn.init = function init( selector, context ) {
6513 if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
6514 context = jQuerySub( context );
6515 }
6517 return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
6518 };
6519 jQuerySub.fn.init.prototype = jQuerySub.fn;
6520 var rootjQuerySub = jQuerySub(document);
6521 return jQuerySub;
6522 };
6524 })();
6525 var curCSS, iframe, iframeDoc,
6526 ralpha = /alpha\([^)]*\)/i,
6527 ropacity = /opacity=([^)]*)/,
6528 rposition = /^(top|right|bottom|left)$/,
6529 // swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
6530 // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6531 rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6532 rmargin = /^margin/,
6536 elemdisplay = {},
6539 cssNormalTransform = {
6540 letterSpacing: 0,
6541 fontWeight: 400
6542 },
6547 eventsToggle = jQuery.fn.toggle;
6549 // return a css property mapped to a potentially vendor prefixed property
6550 function vendorPropName( style, name ) {
6552 // shortcut for names that are not vendor prefixed
6553 if ( name in style ) {
6554 return name;
6555 }
6557 // check for vendor prefixed names
6558 var capName = name.charAt(0).toUpperCase() + name.slice(1),
6559 origName = name,
6560 i = cssPrefixes.length;
6562 while ( i-- ) {
6563 name = cssPrefixes[ i ] + capName;
6564 if ( name in style ) {
6565 return name;
6566 }
6567 }
6569 return origName;
6570 }
6572 function isHidden( elem, el ) {
6573 elem = el || elem;
6574 return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
6575 }
6577 function showHide( elements, show ) {
6578 var elem, display,
6579 values = [],
6580 index = 0,
6581 length = elements.length;
6583 for ( ; index < length; index++ ) {
6584 elem = elements[ index ];
6585 if ( !elem.style ) {
6586 continue;
6587 }
6589 if ( show ) {
6590 // Reset the inline display of this element to learn if it is
6591 // being hidden by cascaded rules or not
6594 }
6596 // Set elements which have been overridden with display: none
6597 // in a stylesheet to whatever the default browser style is
6598 // for such an element
6601 }
6602 } else {
6607 }
6608 }
6609 }
6611 // Set the display of most of the elements in a second loop
6612 // to avoid the constant reflow
6613 for ( index = 0; index < length; index++ ) {
6614 elem = elements[ index ];
6615 if ( !elem.style ) {
6616 continue;
6617 }
6620 }
6621 }
6623 return elements;
6624 }
6626 jQuery.fn.extend({
6627 css: function( name, value ) {
6628 return jQuery.access( this, function( elem, name, value ) {
6629 return value !== undefined ?
6630 jQuery.style( elem, name, value ) :
6631 jQuery.css( elem, name );
6632 }, name, value, arguments.length > 1 );
6633 },
6634 show: function() {
6635 return showHide( this, true );
6636 },
6637 hide: function() {
6638 return showHide( this );
6639 },
6640 toggle: function( state, fn2 ) {
6643 if ( jQuery.isFunction( state ) && jQuery.isFunction( fn2 ) ) {
6644 return eventsToggle.apply( this, arguments );
6645 }
6647 return this.each(function() {
6648 if ( bool ? state : isHidden( this ) ) {
6649 jQuery( this ).show();
6650 } else {
6651 jQuery( this ).hide();
6652 }
6653 });
6654 }
6655 });
6657 jQuery.extend({
6658 // Add in style property hooks for overriding the default
6659 // behavior of getting and setting a style property
6660 cssHooks: {
6661 opacity: {
6662 get: function( elem, computed ) {
6663 if ( computed ) {
6664 // We should always get a number back from opacity
6668 }
6669 }
6670 }
6671 },
6673 // Exclude the following css properties to add px
6674 cssNumber: {
6683 },
6685 // Add in properties whose names you wish to fix before
6686 // setting or getting the value
6687 cssProps: {
6688 // normalize float css property
6690 },
6692 // Get and set the style property on a DOM Node
6693 style: function( elem, name, value, extra ) {
6694 // Don't set styles on text and comment nodes
6695 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6696 return;
6697 }
6699 // Make sure that we're working with the right name
6700 var ret, type, hooks,
6701 origName = jQuery.camelCase( name ),
6702 style = elem.style;
6704 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
6706 // gets hook for the prefixed version
6707 // followed by the unprefixed version
6708 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6710 // Check if we're setting a value
6711 if ( value !== undefined ) {
6712 type = typeof value;
6714 // convert relative number strings (+= or -=) to relative numbers. #7345
6716 value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
6717 // Fixes bug #9237
6719 }
6721 // Make sure that NaN and null values aren't set. See: #7116
6723 return;
6724 }
6726 // If a number was passed in, add 'px' to the (except for certain CSS properties)
6729 }
6731 // If a hook was provided, use that value, otherwise just set the specified value
6732 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
6733 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6734 // Fixes bug #5509
6735 try {
6736 style[ name ] = value;
6737 } catch(e) {}
6738 }
6740 } else {
6741 // If a hook was provided get the non-computed value from there
6743 return ret;
6744 }
6746 // Otherwise just get the value from the style object
6747 return style[ name ];
6748 }
6749 },
6751 css: function( elem, name, numeric, extra ) {
6752 var val, num, hooks,
6753 origName = jQuery.camelCase( name );
6755 // Make sure that we're working with the right name
6756 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
6758 // gets hook for the prefixed version
6759 // followed by the unprefixed version
6760 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6762 // If a hook was provided get the computed value from there
6764 val = hooks.get( elem, true, extra );
6765 }
6767 // Otherwise, if a way to get the computed value exists, use that
6768 if ( val === undefined ) {
6769 val = curCSS( elem, name );
6770 }
6774 val = cssNormalTransform[ name ];
6775 }
6777 // Return, converting to number if forced or a qualifier was provided and val looks numeric
6778 if ( numeric || extra !== undefined ) {
6779 num = parseFloat( val );
6780 return numeric || jQuery.isNumeric( num ) ? num || 0 : val;
6781 }
6782 return val;
6783 },
6785 // A method for quickly swapping in/out CSS properties to get correct calculations
6786 swap: function( elem, options, callback ) {
6787 var ret, name,
6788 old = {};
6790 // Remember the old values, and insert the new ones
6791 for ( name in options ) {
6792 old[ name ] = elem.style[ name ];
6793 elem.style[ name ] = options[ name ];
6794 }
6796 ret = callback.call( elem );
6798 // Revert the old values
6799 for ( name in options ) {
6800 elem.style[ name ] = old[ name ];
6801 }
6803 return ret;
6804 }
6805 });
6807 // NOTE: To any future maintainer, we've window.getComputedStyle
6808 // because jsdom on node.js will break without it.
6809 if ( window.getComputedStyle ) {
6810 curCSS = function( elem, name ) {
6811 var ret, width, minWidth, maxWidth,
6812 computed = window.getComputedStyle( elem, null ),
6813 style = elem.style;
6815 if ( computed ) {
6817 ret = computed[ name ];
6819 ret = jQuery.style( elem, name );
6820 }
6824 // Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
6825 // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
6826 if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
6827 width = style.width;
6828 minWidth = style.minWidth;
6829 maxWidth = style.maxWidth;
6831 style.minWidth = style.maxWidth = style.width = ret;
6832 ret = computed.width;
6834 style.width = width;
6835 style.minWidth = minWidth;
6836 style.maxWidth = maxWidth;
6837 }
6838 }
6840 return ret;
6841 };
6842 } else if ( document.documentElement.currentStyle ) {
6843 curCSS = function( elem, name ) {
6844 var left, rsLeft,
6845 ret = elem.currentStyle && elem.currentStyle[ name ],
6846 style = elem.style;
6848 // Avoid setting ret to empty string here
6849 // so we don't default to auto
6850 if ( ret == null && style && style[ name ] ) {
6851 ret = style[ name ];
6852 }
6854 // From the awesome hack by Dean Edwards
6855 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6857 // If we're not dealing with a regular pixel number
6858 // but a number that has a weird ending, we need to convert it to pixels
6859 // but not position css attributes, as those are proportional to the parent element instead
6861 if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
6863 // Remember the original values
6864 left = style.left;
6865 rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
6867 // Put in the new values to get a computed value out
6868 if ( rsLeft ) {
6869 elem.runtimeStyle.left = elem.currentStyle.left;
6870 }
6874 // Revert the changed values
6875 style.left = left;
6876 if ( rsLeft ) {
6877 elem.runtimeStyle.left = rsLeft;
6878 }
6879 }
6882 };
6883 }
6885 function setPositiveNumber( elem, value, subtract ) {
6886 var matches = rnumsplit.exec( value );
6887 return matches ?
6889 value;
6890 }
6892 function augmentWidthOrHeight( elem, name, extra, isBorderBox ) {
6894 // If we already have the right measurement, avoid augmentation
6895 4 :
6896 // Otherwise initialize for horizontal or vertical properties
6899 val = 0;
6901 for ( ; i < 4; i += 2 ) {
6902 // both box models exclude margin, so add it if we want it
6904 // we use jQuery.css instead of curCSS here
6905 // because of the reliableMarginRight CSS hook!
6906 val += jQuery.css( elem, extra + cssExpand[ i ], true );
6907 }
6909 // From this point on we use curCSS for maximum performance (relevant in animations)
6910 if ( isBorderBox ) {
6911 // border-box includes padding, so remove it if we want content
6914 }
6916 // at this point, extra isn't border nor margin, so remove border
6919 }
6920 } else {
6921 // at this point, extra isn't content, so add padding
6924 // at this point, extra isn't content nor padding, so add border
6927 }
6928 }
6929 }
6931 return val;
6932 }
6934 function getWidthOrHeight( elem, name, extra ) {
6936 // Start with offset property, which is equivalent to the border-box value
6938 valueIsBorderBox = true,
6941 // some non-html elements return undefined for offsetWidth, so check for null/undefined
6942 // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
6943 // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
6944 if ( val <= 0 || val == null ) {
6945 // Fall back to computed then uncomputed css if necessary
6946 val = curCSS( elem, name );
6947 if ( val < 0 || val == null ) {
6948 val = elem.style[ name ];
6949 }
6951 // Computed unit is not pixels. Stop here and return.
6952 if ( rnumnonpx.test(val) ) {
6953 return val;
6954 }
6956 // we need the check for style in case a browser which returns unreliable values
6957 // for getComputedStyle silently falls back to the reliable elem.style
6958 valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] );
6961 val = parseFloat( val ) || 0;
6962 }
6964 // use the active box-sizing model to add/subtract irrelevant styles
6965 return ( val +
6966 augmentWidthOrHeight(
6967 elem,
6968 name,
6970 valueIsBorderBox
6971 )
6973 }
6976 // Try to determine the default display value of an element
6977 function css_defaultDisplay( nodeName ) {
6978 if ( elemdisplay[ nodeName ] ) {
6979 return elemdisplay[ nodeName ];
6980 }
6984 elem.remove();
6986 // If the simple way fails,
6987 // get element's real default display by attaching it to a temp iframe
6989 // Use the already-created iframe if possible
6990 iframe = document.body.appendChild(
6992 frameBorder: 0,
6993 width: 0,
6994 height: 0
6995 })
6996 );
6998 // Create a cacheable copy of the iframe document on first call.
6999 // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
7000 // document to it; WebKit & Firefox won't allow reusing the iframe document.
7001 if ( !iframeDoc || !iframe.createElement ) {
7002 iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
7004 iframeDoc.close();
7005 }
7007 elem = iframeDoc.body.appendChild( iframeDoc.createElement(nodeName) );
7010 document.body.removeChild( iframe );
7011 }
7013 // Store the correct default display
7014 elemdisplay[ nodeName ] = display;
7016 return display;
7017 }
7020 jQuery.cssHooks[ name ] = {
7021 get: function( elem, computed, extra ) {
7022 if ( computed ) {
7023 // certain elements can have dimension info if we invisibly show them
7024 // however, it must have a current display style that would benefit from this
7026 return jQuery.swap( elem, cssShow, function() {
7027 return getWidthOrHeight( elem, name, extra );
7028 });
7029 } else {
7030 return getWidthOrHeight( elem, name, extra );
7031 }
7032 }
7033 },
7035 set: function( elem, value, extra ) {
7036 return setPositiveNumber( elem, value, extra ?
7037 augmentWidthOrHeight(
7038 elem,
7039 name,
7040 extra,
7042 ) : 0
7043 );
7044 }
7045 };
7046 });
7048 if ( !jQuery.support.opacity ) {
7049 jQuery.cssHooks.opacity = {
7050 get: function( elem, computed ) {
7051 // IE uses filters for opacity
7052 return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
7055 },
7057 set: function( elem, value ) {
7058 var style = elem.style,
7059 currentStyle = elem.currentStyle,
7063 // IE has trouble with opacity if it does not have layout
7064 // Force it by setting the zoom level
7065 style.zoom = 1;
7067 // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
7069 style.removeAttribute ) {
7073 // style.removeAttribute is IE Only, but so apparently is this code path...
7076 // if there there is no filter style applied in a css rule, we are done
7077 if ( currentStyle && !currentStyle.filter ) {
7078 return;
7079 }
7080 }
7082 // otherwise, set new filter values
7083 style.filter = ralpha.test( filter ) ?
7084 filter.replace( ralpha, opacity ) :
7086 }
7087 };
7088 }
7090 // These hooks cannot be added until DOM ready because the support test
7091 // for it is not run until after DOM ready
7092 jQuery(function() {
7093 if ( !jQuery.support.reliableMarginRight ) {
7094 jQuery.cssHooks.marginRight = {
7095 get: function( elem, computed ) {
7096 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
7097 // Work around by temporarily setting element display to inline-block
7099 if ( computed ) {
7101 }
7102 });
7103 }
7104 };
7105 }
7107 // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
7108 // getComputedStyle returns percent when specified for top/left/bottom/right
7109 // rather than make the css module depend on the offset module, we just check for it here
7110 if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
7112 jQuery.cssHooks[ prop ] = {
7113 get: function( elem, computed ) {
7114 if ( computed ) {
7115 var ret = curCSS( elem, prop );
7116 // if curCSS returns percentage, fallback to offset
7118 }
7119 }
7120 };
7121 });
7122 }
7124 });
7126 if ( jQuery.expr && jQuery.expr.filters ) {
7127 jQuery.expr.filters.hidden = function( elem ) {
7128 return ( elem.offsetWidth === 0 && elem.offsetHeight === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || curCSS( elem, "display" )) === "none");
7129 };
7131 jQuery.expr.filters.visible = function( elem ) {
7132 return !jQuery.expr.filters.hidden( elem );
7133 };
7134 }
7136 // These hooks are used by animate to expand properties
7137 jQuery.each({
7141 }, function( prefix, suffix ) {
7142 jQuery.cssHooks[ prefix + suffix ] = {
7143 expand: function( value ) {
7144 var i,
7146 // assumes a single number if not a string
7148 expanded = {};
7150 for ( i = 0; i < 4; i++ ) {
7151 expanded[ prefix + cssExpand[ i ] + suffix ] =
7152 parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
7153 }
7155 return expanded;
7156 }
7157 };
7159 if ( !rmargin.test( prefix ) ) {
7160 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
7161 }
7162 });
7163 var r20 = /%20/g,
7164 rbracket = /\[\]$/,
7166 rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
7167 rselectTextarea = /^(?:select|textarea)/i;
7169 jQuery.fn.extend({
7170 serialize: function() {
7171 return jQuery.param( this.serializeArray() );
7172 },
7173 serializeArray: function() {
7174 return this.map(function(){
7175 return this.elements ? jQuery.makeArray( this.elements ) : this;
7176 })
7177 .filter(function(){
7178 return this.name && !this.disabled &&
7179 ( this.checked || rselectTextarea.test( this.nodeName ) ||
7180 rinput.test( this.type ) );
7181 })
7182 .map(function( i, elem ){
7183 var val = jQuery( this ).val();
7185 return val == null ?
7186 null :
7187 jQuery.isArray( val ) ?
7188 jQuery.map( val, function( val, i ){
7190 }) :
7192 }).get();
7193 }
7194 });
7196 //Serialize an array of form elements or a set of
7197 //key/values into a query string
7198 jQuery.param = function( a, traditional ) {
7199 var prefix,
7200 s = [],
7201 add = function( key, value ) {
7202 // If value is a function, invoke it and return its value
7205 };
7207 // Set traditional to true for jQuery <= 1.3.2 behavior.
7208 if ( traditional === undefined ) {
7209 traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
7210 }
7212 // If an array was passed in, assume that it is an array of form elements.
7213 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7214 // Serialize the form elements
7215 jQuery.each( a, function() {
7216 add( this.name, this.value );
7217 });
7219 } else {
7221 // did it), otherwise encode params recursively.
7222 for ( prefix in a ) {
7223 buildParams( prefix, a[ prefix ], traditional, add );
7224 }
7225 }
7227 // Return the resulting serialization
7229 };
7231 function buildParams( prefix, obj, traditional, add ) {
7232 var name;
7234 if ( jQuery.isArray( obj ) ) {
7235 // Serialize array item.
7236 jQuery.each( obj, function( i, v ) {
7237 if ( traditional || rbracket.test( prefix ) ) {
7238 // Treat each array item as a scalar.
7239 add( prefix, v );
7241 } else {
7242 // If array item is non-scalar (array or object), encode its
7243 // numeric index to resolve deserialization ambiguity issues.
7244 // Note that rack (as of 1.0.0) can't currently deserialize
7245 // nested arrays properly, and attempting to do so may cause
7246 // a server error. Possible fixes are to modify rack's
7247 // deserialization algorithm or to provide an option or flag
7248 // to force array serialization to be shallow.
7250 }
7251 });
7254 // Serialize object item.
7255 for ( name in obj ) {
7257 }
7259 } else {
7260 // Serialize scalar item.
7261 add( prefix, obj );
7262 }
7263 }
7264 var
7265 // Document location
7266 ajaxLocParts,
7267 ajaxLocation,
7269 rhash = /#.*$/,
7271 // #7653, #8125, #8152: local protocol detection
7272 rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
7273 rnoContent = /^(?:GET|HEAD)$/,
7274 rprotocol = /^\/\//,
7277 rts = /([?&])_=[^&]*/,
7278 rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
7280 // Keep a copy of the old load method
7281 _load = jQuery.fn.load,
7283 /* Prefilters
7284 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
7285 * 2) These are called:
7286 * - BEFORE asking for a transport
7287 * - AFTER param serialization (s.data is a string if s.processData is true)
7288 * 3) key is the dataType
7291 */
7292 prefilters = {},
7294 /* Transports bindings
7295 * 1) key is the dataType
7298 */
7299 transports = {},
7301 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
7304 // #8138, IE may throw an exception when accessing
7305 // a field from window.location if document.domain has been set
7306 try {
7307 ajaxLocation = location.href;
7308 } catch( e ) {
7309 // Use the href attribute of an A element
7310 // since IE will modify it given document.location
7313 ajaxLocation = ajaxLocation.href;
7314 }
7316 // Segment location into parts
7317 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
7320 function addToPrefiltersOrTransports( structure ) {
7323 return function( dataTypeExpression, func ) {
7326 func = dataTypeExpression;
7328 }
7330 var dataType, list, placeBefore,
7331 dataTypes = dataTypeExpression.toLowerCase().split( core_rspace ),
7332 i = 0,
7333 length = dataTypes.length;
7335 if ( jQuery.isFunction( func ) ) {
7336 // For each dataType in the dataTypeExpression
7337 for ( ; i < length; i++ ) {
7338 dataType = dataTypes[ i ];
7339 // We control if we're asked to add before
7340 // any existing element
7341 placeBefore = /^\+/.test( dataType );
7342 if ( placeBefore ) {
7344 }
7345 list = structure[ dataType ] = structure[ dataType ] || [];
7346 // then we add to the structure accordingly
7348 }
7349 }
7350 };
7351 }
7353 // Base inspection function for prefilters and transports
7354 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
7355 dataType /* internal */, inspected /* internal */ ) {
7357 dataType = dataType || options.dataTypes[ 0 ];
7358 inspected = inspected || {};
7360 inspected[ dataType ] = true;
7362 var selection,
7363 list = structure[ dataType ],
7364 i = 0,
7365 length = list ? list.length : 0,
7366 executeOnly = ( structure === prefilters );
7368 for ( ; i < length && ( executeOnly || !selection ); i++ ) {
7369 selection = list[ i ]( options, originalOptions, jqXHR );
7370 // If we got redirected to another dataType
7371 // we try there if executing only and not done already
7373 if ( !executeOnly || inspected[ selection ] ) {
7374 selection = undefined;
7375 } else {
7376 options.dataTypes.unshift( selection );
7377 selection = inspectPrefiltersOrTransports(
7378 structure, options, originalOptions, jqXHR, selection, inspected );
7379 }
7380 }
7381 }
7382 // If we're only executing or nothing was selected
7383 // we try the catchall dataType if not done already
7385 selection = inspectPrefiltersOrTransports(
7387 }
7388 // unnecessary when only executing (prefilters)
7389 // but it'll be ignored by the caller in that case
7390 return selection;
7391 }
7393 // A special extend for ajax options
7395 // Fixes #9887
7396 function ajaxExtend( target, src ) {
7397 var key, deep,
7398 flatOptions = jQuery.ajaxSettings.flatOptions || {};
7399 for ( key in src ) {
7400 if ( src[ key ] !== undefined ) {
7401 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
7402 }
7403 }
7404 if ( deep ) {
7405 jQuery.extend( true, target, deep );
7406 }
7407 }
7409 jQuery.fn.load = function( url, params, callback ) {
7411 return _load.apply( this, arguments );
7412 }
7414 // Don't do a request if no elements are being requested
7415 if ( !this.length ) {
7416 return this;
7417 }
7419 var selector, type, response,
7420 self = this,
7423 if ( off >= 0 ) {
7424 selector = url.slice( off, url.length );
7425 url = url.slice( 0, off );
7426 }
7428 // If it's a function
7429 if ( jQuery.isFunction( params ) ) {
7431 // We assume that it's the callback
7432 callback = params;
7433 params = undefined;
7435 // Otherwise, build a param string
7438 }
7440 // Request the remote document
7441 jQuery.ajax({
7442 url: url,
7445 type: type,
7447 data: params,
7448 complete: function( jqXHR, status ) {
7449 if ( callback ) {
7450 self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
7451 }
7452 }
7453 }).done(function( responseText ) {
7455 // Save response for use in complete callback
7456 response = arguments;
7458 // See if a selector was specified
7459 self.html( selector ?
7461 // Create a dummy div to hold the results
7464 // inject the contents of the document in, removing the scripts
7465 // to avoid any 'Permission Denied' errors in IE
7468 // Locate the specified elements
7469 .find( selector ) :
7471 // If not, just inject the full result
7472 responseText );
7474 });
7476 return this;
7477 };
7479 // Attach a bunch of functions for handling common AJAX events
7480 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
7481 jQuery.fn[ o ] = function( f ){
7482 return this.on( o, f );
7483 };
7484 });
7487 jQuery[ method ] = function( url, data, callback, type ) {
7488 // shift arguments if data argument was omitted
7489 if ( jQuery.isFunction( data ) ) {
7490 type = type || callback;
7491 callback = data;
7492 data = undefined;
7493 }
7495 return jQuery.ajax({
7496 type: method,
7497 url: url,
7498 data: data,
7499 success: callback,
7500 dataType: type
7501 });
7502 };
7503 });
7505 jQuery.extend({
7507 getScript: function( url, callback ) {
7509 },
7511 getJSON: function( url, data, callback ) {
7513 },
7515 // Creates a full fledged settings object into target
7516 // with both ajaxSettings and settings fields.
7517 // If target is omitted, writes into ajaxSettings.
7518 ajaxSetup: function( target, settings ) {
7519 if ( settings ) {
7520 // Building a settings object
7521 ajaxExtend( target, jQuery.ajaxSettings );
7522 } else {
7523 // Extending ajaxSettings
7524 settings = target;
7525 target = jQuery.ajaxSettings;
7526 }
7527 ajaxExtend( target, settings );
7528 return target;
7529 },
7531 ajaxSettings: {
7532 url: ajaxLocation,
7533 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
7534 global: true,
7537 processData: true,
7538 async: true,
7539 /*
7540 timeout: 0,
7541 data: null,
7542 dataType: null,
7543 username: null,
7544 password: null,
7545 cache: null,
7546 throws: false,
7547 traditional: false,
7548 headers: {},
7549 */
7551 accepts: {
7557 },
7559 contents: {
7560 xml: /xml/,
7561 html: /html/,
7562 json: /json/
7563 },
7565 responseFields: {
7568 },
7570 // List of data converters
7573 converters: {
7575 // Convert anything to text
7578 // Text to html (true = no transformation)
7581 // Evaluate text as a json expression
7584 // Parse text as xml
7586 },
7588 // For options that shouldn't be deep extended:
7589 // you can add your own custom options here if
7590 // and when you create one that shouldn't be
7591 // deep extended (see ajaxExtend)
7592 flatOptions: {
7593 context: true,
7594 url: true
7595 }
7596 },
7598 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
7599 ajaxTransport: addToPrefiltersOrTransports( transports ),
7601 // Main method
7602 ajax: function( url, options ) {
7604 // If url is an object, simulate pre-1.5 signature
7606 options = url;
7607 url = undefined;
7608 }
7610 // Force options to be an object
7611 options = options || {};
7613 var // ifModified key
7614 ifModifiedKey,
7615 // Response headers
7616 responseHeadersString,
7617 responseHeaders,
7618 // transport
7619 transport,
7620 // timeout handle
7621 timeoutTimer,
7622 // Cross-domain detection vars
7623 parts,
7624 // To know if global events are to be dispatched
7625 fireGlobals,
7626 // Loop variable
7627 i,
7628 // Create the final options object
7629 s = jQuery.ajaxSetup( {}, options ),
7630 // Callbacks context
7631 callbackContext = s.context || s,
7632 // Context for global events
7633 // It's the callbackContext if one was provided in the options
7634 // and if it's a DOM node or a jQuery collection
7635 globalEventContext = callbackContext !== s &&
7636 ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
7637 jQuery( callbackContext ) : jQuery.event,
7638 // Deferreds
7639 deferred = jQuery.Deferred(),
7641 // Status-dependent callbacks
7642 statusCode = s.statusCode || {},
7643 // Headers (they are sent all at once)
7644 requestHeaders = {},
7645 requestHeadersNames = {},
7646 // The jqXHR state
7647 state = 0,
7648 // Default abort message
7650 // Fake xhr
7651 jqXHR = {
7653 readyState: 0,
7655 // Caches the header
7656 setRequestHeader: function( name, value ) {
7657 if ( !state ) {
7658 var lname = name.toLowerCase();
7659 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
7660 requestHeaders[ name ] = value;
7661 }
7662 return this;
7663 },
7665 // Raw string
7666 getAllResponseHeaders: function() {
7667 return state === 2 ? responseHeadersString : null;
7668 },
7670 // Builds headers hashtable if needed
7671 getResponseHeader: function( key ) {
7672 var match;
7673 if ( state === 2 ) {
7674 if ( !responseHeaders ) {
7675 responseHeaders = {};
7676 while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7677 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7678 }
7679 }
7680 match = responseHeaders[ key.toLowerCase() ];
7681 }
7682 return match === undefined ? null : match;
7683 },
7685 // Overrides response content-type header
7686 overrideMimeType: function( type ) {
7687 if ( !state ) {
7688 s.mimeType = type;
7689 }
7690 return this;
7691 },
7693 // Cancel the request
7694 abort: function( statusText ) {
7695 statusText = statusText || strAbort;
7696 if ( transport ) {
7697 transport.abort( statusText );
7698 }
7699 done( 0, statusText );
7700 return this;
7701 }
7702 };
7704 // Callback for when everything is done
7705 // It is defined here because jslint complains if it is declared
7706 // at the end of the function (which would be more logical and readable)
7707 function done( status, nativeStatusText, responses, headers ) {
7708 var isSuccess, success, error, response, modified,
7709 statusText = nativeStatusText;
7711 // Called once
7712 if ( state === 2 ) {
7713 return;
7714 }
7717 state = 2;
7719 // Clear timeout if it exists
7720 if ( timeoutTimer ) {
7721 clearTimeout( timeoutTimer );
7722 }
7724 // Dereference transport for early garbage collection
7725 // (no matter how long the jqXHR object will be used)
7726 transport = undefined;
7728 // Cache response headers
7731 // Set readyState
7732 jqXHR.readyState = status > 0 ? 4 : 0;
7734 // Get response data
7735 if ( responses ) {
7736 response = ajaxHandleResponses( s, jqXHR, responses );
7737 }
7739 // If successful, handle type chaining
7740 if ( status >= 200 && status < 300 || status === 304 ) {
7742 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7743 if ( s.ifModified ) {
7746 if ( modified ) {
7747 jQuery.lastModified[ ifModifiedKey ] = modified;
7748 }
7750 if ( modified ) {
7751 jQuery.etag[ ifModifiedKey ] = modified;
7752 }
7753 }
7755 // If not modified
7756 if ( status === 304 ) {
7759 isSuccess = true;
7761 // If we have data
7762 } else {
7764 isSuccess = ajaxConvert( s, response );
7765 statusText = isSuccess.state;
7766 success = isSuccess.data;
7767 error = isSuccess.error;
7768 isSuccess = !error;
7769 }
7770 } else {
7771 // We extract error from statusText
7772 // then normalize statusText and status for non-aborts
7773 error = statusText;
7774 if ( !statusText || status ) {
7776 if ( status < 0 ) {
7777 status = 0;
7778 }
7779 }
7780 }
7782 // Set data for the fake xhr object
7783 jqXHR.status = status;
7786 // Success/Error
7787 if ( isSuccess ) {
7788 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7789 } else {
7790 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7791 }
7793 // Status-dependent callbacks
7794 jqXHR.statusCode( statusCode );
7795 statusCode = undefined;
7797 if ( fireGlobals ) {
7799 [ jqXHR, s, isSuccess ? success : error ] );
7800 }
7802 // Complete
7803 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
7805 if ( fireGlobals ) {
7807 // Handle the global AJAX counter
7808 if ( !( --jQuery.active ) ) {
7810 }
7811 }
7812 }
7814 // Attach deferreds
7815 deferred.promise( jqXHR );
7816 jqXHR.success = jqXHR.done;
7817 jqXHR.error = jqXHR.fail;
7818 jqXHR.complete = completeDeferred.add;
7820 // Status-dependent callbacks
7821 jqXHR.statusCode = function( map ) {
7822 if ( map ) {
7823 var tmp;
7824 if ( state < 2 ) {
7825 for ( tmp in map ) {
7826 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7827 }
7828 } else {
7829 tmp = map[ jqXHR.status ];
7830 jqXHR.always( tmp );
7831 }
7832 }
7833 return this;
7834 };
7836 // Remove hash character (#7531: and string promotion)
7837 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7838 // We also use the url parameter if available
7839 s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7841 // Extract dataTypes list
7844 // A cross-domain request is in order when we have a protocol:host:port mismatch
7847 s.crossDomain = parts && ( parts.join(":") + ( parts[ 3 ] ? "" : parts[ 1 ] === "http:" ? 80 : 443 ) ) !==
7848 ( ajaxLocParts.join(":") + ( ajaxLocParts[ 3 ] ? "" : ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) );
7849 }
7851 // Convert data if not already a string
7854 }
7856 // Apply prefilters
7859 // If request was aborted inside a prefilter, stop there
7862 }
7864 // We can fire global events as of now if asked to
7867 // Uppercase the type
7870 // Determine if request has content
7873 // Watch for a new set of requests
7876 }
7878 // More options handling for requests with no content
7881 // If data is available, append data to url
7884 // #9682: remove data so that it's not used in an eventual retry
7886 }
7888 // Get ifModifiedKey before adding the anti-cache parameter
7891 // Add anti-cache in url if needed
7895 // try replacing _= if it is there
7898 // if nothing was replaced, add timestamp to the end
7900 }
7901 }
7903 // Set the correct header, if data is being sent
7906 }
7908 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7913 }
7916 }
7917 }
7919 // Set the Accepts header for the server, depending on the dataType
7923 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
7925 );
7927 // Check for headers option
7930 }
7932 // Allow custom headers/mimetypes and early abort
7933 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
7934 // Abort if not done already and return
7937 }
7939 // aborting is no longer a cancellation
7942 // Install callbacks on deferreds
7945 }
7947 // Get transport
7950 // If no transport, we auto-abort
7955 // Send global event
7958 }
7959 // Timeout
7964 }
7970 // Propagate exception as error if not done
7973 // Simply rethrow otherwise
7976 }
7977 }
7978 }
7981 },
7983 // Counter for holding the number of active queries
7986 // Last-Modified header cache for next request
7987 lastModified: {},
7988 etag: {}
7990 });
7992 /* Handles responses to an ajax request:
7993 * - sets all responseXXX fields accordingly
7994 * - finds the right dataType (mediates between content-type and expected dataType)
7995 * - returns the corresponding response
7996 */
8004 // Fill responseXXX fields
8008 }
8009 }
8011 // Remove auto dataType and get content-type in the process
8016 }
8017 }
8019 // Check if we're dealing with a known content-type
8025 }
8026 }
8027 }
8029 // Check to see if we have a response for the expected dataType
8033 // Try convertible dataTypes
8038 }
8041 }
8042 }
8043 // Or just use first one
8045 }
8047 // If we found a dataType
8048 // We add the dataType to the list if needed
8049 // and return the corresponding response
8053 }
8055 }
8056 }
8058 // Chain conversions given the request and the original response
8062 // Work with a copy of dataTypes in case we need to modify it for conversion
8065 converters = {},
8068 // Apply the dataFilter if provided
8071 }
8073 // Create converters map with lowercased keys
8077 }
8078 }
8080 // Convert to each sequential dataType, tolerating list modification
8083 // There's only work to do if current dataType is non-auto
8086 // Convert response if prev dataType is non-auto and differs from current
8089 // Seek a direct converter
8092 // If none found, seek a pair
8096 // If conv2 outputs current
8100 // If prev can be converted to accepted input
8104 // Condense equivalence converters
8108 // Otherwise, insert the intermediate dataType
8112 }
8115 }
8116 }
8117 }
8118 }
8120 // Apply converter (if not an equivalence)
8123 // Unless errors are allowed to bubble, catch and return them
8130 return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
8131 }
8132 }
8133 }
8134 }
8136 // Update prev for next iteration
8138 }
8139 }
8142 }
8148 // Default jsonp settings
8155 }
8156 });
8158 // Detect, normalize options and install callbacks for jsonp requests
8170 // Handle iff the expected data type is "jsonp" or we have a parameter to set
8173 // Get callback name, remembering preexisting value associated with it
8179 // Insert callback into url or form data
8186 }
8188 // Use data converter to retrieve json after script execution
8192 }
8194 };
8196 // force json dataType
8199 // Install callback
8202 };
8204 // Clean-up function (fires after converters)
8206 // Restore preexisting value
8209 // Save back as free
8211 // make sure that re-using the options doesn't screw things around
8214 // save the callback name for future use
8216 }
8218 // Call if it was a function and we have a response
8221 }
8224 });
8226 // Delegate to script
8228 }
8229 });
8230 // Install script dataType
8232 accepts: {
8233 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
8234 },
8235 contents: {
8237 },
8238 converters: {
8242 }
8243 }
8244 });
8246 // Handle cache's special case and global
8250 }
8254 }
8255 });
8257 // Bind script tag hack transport
8260 // This transport only deals with cross domain requests
8264 head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
8276 }
8280 // Attach handlers for all browsers
8285 // Handle memory leak in IE
8288 // Remove the script
8291 }
8293 // Dereference the script
8296 // Callback if not abort
8299 }
8300 }
8301 };
8302 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
8303 // This arises when a base node is used (#2709 and #4378).
8305 },
8310 }
8311 }
8312 };
8313 }
8314 });
8316 // #5280: Internet Explorer will keep connections alive if we don't abort on unload
8318 // Abort all pending requests
8321 }
8325 // Functions to create xhrs
8330 }
8336 }
8338 // Create the request object
8339 // (This is still attached to ajaxSettings for backward compatibility)
8341 /* Microsoft failed to properly
8342 * implement the XMLHttpRequest in IE7 (can't request local files),
8343 * so we use the ActiveXObject when it is available
8344 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
8345 * we need a fallback.
8346 */
8349 } :
8350 // For all other browsers, use the standard XMLHttpRequest object
8351 createStandardXHR;
8353 // Determine support properties
8358 });
8361 // Create transport if the browser can provide an xhr
8365 // Cross domain only allowed if supported through XMLHttpRequest
8373 // Get a new xhr
8377 // Open the socket
8378 // Passing null username, generates a login popup on Opera (#2865)
8383 }
8385 // Apply custom fields if provided
8389 }
8390 }
8392 // Override mime type if needed
8395 }
8397 // X-Requested-With header
8398 // For cross-domain requests, seeing as conditions for a preflight are
8399 // akin to a jigsaw puzzle, we simply never set it to be sure.
8400 // (it can always be set on a per-request basis or even using ajaxSetup)
8401 // For same-domain requests, won't change header if already provided.
8404 }
8406 // Need an extra try/catch for cross domain requests in Firefox 3
8410 }
8413 // Do send the request
8414 // This may raise an exception which is actually
8415 // handled in jQuery.ajax (so no try/catch here)
8418 // Listener
8422 statusText,
8423 responseHeaders,
8424 responses,
8425 xml;
8427 // Firefox throws exceptions when accessing properties
8428 // of an xhr when a network error occurred
8429 // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
8432 // Was never called and is aborted or complete
8435 // Only called once
8438 // Do not keep as active anymore
8443 }
8444 }
8446 // If it's an abort
8448 // Abort it manually if needed
8451 }
8455 responses = {};
8458 // Construct response list
8461 }
8463 // When requesting binary data, IE6-9 will throw an exception
8464 // on any attempt to access responseText (#11426)
8468 }
8470 // Firefox throws an exception when accessing
8471 // statusText for faulty cross-domain requests
8475 // We normalize with Webkit giving an empty statusText
8477 }
8479 // Filter status for non standard behaviors
8481 // If the request is local and we have data: assume a success
8482 // (success with no data won't get notified, that's the best we
8483 // can do given current implementations)
8486 // IE - #1450: sometimes returns 1223 when it should be 204
8489 }
8490 }
8491 }
8495 }
8496 }
8498 // Call complete if needed
8501 }
8502 };
8505 // if we're in sync mode we fire the callback
8508 // (IE6 & IE7) if it's in cache and has been
8509 // retrieved directly we need to fire the callback
8514 // Create the active xhrs callbacks list if needed
8515 // and attach the unload handler
8517 xhrCallbacks = {};
8519 }
8520 // Add to list of active xhrs callbacks
8522 }
8524 }
8525 },
8530 }
8531 }
8532 };
8533 }
8534 });
8535 }
8541 tweeners = {
8555 // We need to compute starting value
8557 // Iteratively approximate from a nonzero starting point
8558 // Prefer the current property, because this process will be trivial if it uses the same units
8559 // Fallback to end or a simple constant
8563 // If previous iteration zeroed out, double until we get *something*
8564 // Use a string for doubling factor so we don't accidentally see scale as unchanged below
8567 // Adjust and apply
8571 // Update scale, tolerating zero or NaN from tween.cur()
8572 // And breaking the loop if scale is unchanged or perfect, or if we've just had enough
8574 }
8578 // If a +=/-= token was provided, we're doing a relative animation
8580 }
8582 }]
8583 };
8585 // Animations created synchronously will run synchronously
8591 }
8601 // we're done with this property
8603 }
8604 }
8605 });
8606 }
8614 // don't match elem in the :animated selector
8616 }),
8626 }
8635 }
8636 },
8645 tweens: [],
8651 },
8654 // if we are going to the end, we want to run all the tweens
8655 // otherwise we skip this part
8660 }
8662 // resolve when we played the last frame
8663 // otherwise, reject
8668 }
8670 }
8671 }),
8680 }
8681 }
8687 }
8693 elem: elem
8694 })
8695 );
8697 // attach callbacks from options
8702 }
8707 // camelCase, specialEasing and expand cssHook pass
8715 }
8720 }
8727 // not quite $.extend, this wont overwrite keys already present.
8728 // also - reusing 'index' from above because we have the correct "name"
8733 }
8734 }
8737 }
8738 }
8739 }
8749 }
8759 }
8760 },
8767 }
8768 }
8769 });
8775 orig = {},
8776 handled = [],
8779 // handle queue: false promises
8788 }
8789 };
8790 }
8794 // doing this makes sure that the complete handler will be called
8795 // before this completes
8800 }
8801 });
8802 });
8803 }
8805 // height/width overflow pass
8807 // Make sure that nothing sneaks out
8808 // Record all 3 overflow attributes because IE does not
8809 // change the overflow attribute when overflowX and
8810 // overflowY are set to the same value
8813 // Set display property to inline-block for height/width
8814 // animations on inline elements that are having width/height animated
8818 // inline-level elements accept inline-block;
8819 // block-level elements need to be inline with layout
8820 if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
8825 }
8826 }
8827 }
8836 });
8837 }
8838 }
8841 // show/hide pass
8848 }
8850 }
8851 }
8861 });
8862 }
8868 }
8869 });
8880 }
8881 }
8882 }
8883 }
8884 }
8888 }
8901 },
8908 },
8916 );
8919 }
8924 }
8930 }
8932 }
8933 };
8938 _default: {
8945 }
8947 // passing any value as a 4th parameter to .css will automatically
8948 // attempt a parseFloat and fallback to a string if the parse fails
8949 // so, simple values such as "10px" are parsed to Float.
8950 // complex values such as "rotate(1rad)" are returned as is.
8952 // Empty strings, null, undefined and "auto" are converted to 0.
8954 },
8956 // use step hook for back compat - use cssHook if its there - use .style if its
8957 // available and use plain properties where available
8960 } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
8964 }
8965 }
8966 }
8967 };
8969 // Remove in 2.0 - this supports IE8's panic based approach
8970 // to setting things on disconnected nodes
8976 }
8977 }
8978 };
8984 // special check for .toggle( handler, handler, ... )
8988 };
8989 });
8994 // show any hidden elements after setting opacity to 0
8997 // animate to the value specified
8999 },
9004 // Operate on a copy of prop so per-property easing won't be lost
9007 // Empty animations resolve immediately
9010 }
9011 };
9016 },
9022 };
9028 }
9031 }
9042 }
9047 }
9048 }
9049 }
9056 }
9057 }
9059 // start the next in the queue if the last step wasn't forced
9060 // timers currently will call their complete callbacks, which will dequeue
9061 // but only if they were gotoEnd
9064 }
9065 });
9066 }
9067 });
9069 // Generate parameters to create a standard animation
9075 // if we include width, step value is 1 to do all cssExpand values,
9076 // if we don't include width, step value is 2 to skip over Left and Right
9081 }
9085 }
9088 }
9090 // Generate shortcuts for custom animations
9101 };
9102 });
9110 };
9113 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
9115 // normalize opt.queue - true/undefined/null -> "fx"
9118 }
9120 // Queueing
9126 }
9130 }
9131 };
9134 };
9139 },
9142 }
9143 };
9154 // Checks the timer has not already been removed
9157 }
9158 }
9162 }
9163 };
9168 }
9169 };
9176 };
9181 // Default speed
9183 };
9185 // Back Compat <1.8 extension point
9193 };
9194 }
9203 });
9204 }
9213 }
9217 }
9221 // Make sure it's not a disconnected DOM node
9224 }
9226 // If we don't have gBCR, just use 0,0 rather than error
9227 // BlackBerry 5, iOS 3 (original iPhone)
9230 }
9239 };
9240 };
9251 }
9254 },
9259 // set position first, in-case top/left are set even on static elem
9262 }
9268 calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
9271 // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
9279 }
9283 }
9287 }
9290 }
9296 }
9297 }
9298 };
9306 }
9310 // Get *real* offsetParent
9313 // Get correct offsets
9315 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
9317 // Subtract element margins
9318 // note: when an element has margin: auto the offsetLeft and marginLeft
9319 // are the same in Safari causing offset.left to incorrectly be 0
9323 // Add offsetParent borders
9327 // Subtract the two offsets
9331 };
9332 },
9337 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
9339 }
9341 });
9342 }
9343 });
9346 // Create scrollLeft and scrollTop methods
9358 }
9364 );
9368 }
9370 };
9371 });
9375 elem :
9379 }
9380 // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
9382 jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
9383 // margin is only for outerHeight, outerWidth
9392 // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
9393 // isn't a whole lot we can do. See pull request at this URL for discussion:
9394 // https://github.com/jquery/jquery/pull/764
9396 }
9398 // Get document width or height
9402 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
9403 // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
9408 );
9409 }
9412 // Get width or height on the element, requesting but not forcing parseFloat
9415 // Set width or height on the element
9418 };
9419 });
9420 });
9421 // Expose jQuery to the global object
9424 // Expose jQuery as an AMD module, but only for AMD loaders that
9425 // understand the issues with loading multiple versions of jQuery
9426 // in a page that all might call define(). The loader will indicate
9427 // they have special allowances for multiple jQuery versions by
9428 // specifying define.amd.jQuery = true. Register as a named module,
9429 // since jQuery can be concatenated with other files that may use define,
9430 // but not use a proper concatenation script that understands anonymous
9431 // AMD modules. A named AMD is safest and most robust way to register.
9432 // Lowercase jquery is used because AMD module names are derived from
9433 // file names, and jQuery is normally delivered in a lowercase file name.
9434 // Do this after creating the global so that if an AMD module wants to call
9435 // noConflict to hide this version of jQuery, it will work.
9438 }